EmulationSettings.java

package ui.emulationsettings;

import builder.netsiddev.commands.TrySetSidModel;
import javafx.application.Platform;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.fxml.FXML;
import javafx.scene.chart.LineChart;
import javafx.scene.chart.XYChart;
import javafx.scene.chart.XYChart.Data;
import javafx.scene.control.*;
import libsidplay.common.*;
import libsidplay.config.IEmulationSection;
import libsidplay.config.IFilterSection;
import libsidplay.sidtune.SidTune;
import sidplay.Player;
import sidplay.player.State;
import ui.common.C64Window;
import ui.common.converter.EnumToStringConverter;
import ui.common.converter.HexNumberToStringConverter;
import ui.common.converter.MinimumNumberToStringConverter;
import ui.common.converter.NumberToStringConverter;
import ui.entities.config.AudioSection;
import ui.entities.config.EmulationSection;
import ui.entities.config.FilterSection;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.*;

import static javafx.beans.binding.Bindings.bindBidirectional;
import static libsidplay.common.CPUClock.NTSC;
import static libsidplay.common.CPUClock.PAL;
import static libsidplay.common.ChipModel.MOS6581;
import static libsidplay.common.ChipModel.MOS8580;
import static libsidplay.common.Emulation.*;
import static libsidplay.common.Engine.NETSID;
import static libsidplay.common.SIDChip.FC_MAX;
import static sidplay.ini.IniDefaults.*;

public class EmulationSettings extends C64Window {

    protected final class EmulationChange implements PropertyChangeListener {
        @Override
        public void propertyChange(PropertyChangeEvent event) {
            if (event.getNewValue() == State.START) {
                Platform.runLater(() -> updateSettingsForTune(util.getPlayer().getTune()));
            }
        }
    }

    @FXML
    private CheckBox muteVoice1, muteVoice2, muteVoice3, muteVoice4, muteVoice5, muteVoice6, muteVoice7, muteVoice8,
            muteVoice9, muteVoice10, muteVoice11, muteVoice12;
    @FXML
    private ComboBox<CPUClock> defaultVideoStandard;
    @FXML
    private ComboBox<Emulation> sid1Emulation, sid2Emulation, sid3Emulation, defaultEmulation;
    @FXML
    private ComboBox<ChipModel> sid1Model, sid2Model, sid3Model, defaultModel;
    @FXML
    private ComboBox<String> mainFilter, secondFilter, thirdFilter;
    @FXML
    private ComboBox<SidReads> sidToRead;
    @FXML
    private ComboBox<C64Model> c64Model;
    @FXML
    private ComboBox<VICModel> vicModel;
    @FXML
    private ComboBox<StereoMode> stereoMode;
    @FXML
    private TextField baseAddress, thirdAddress, silenceTimeout;
    @FXML
    private CheckBox boosted8580, fakeStereo, detectPSID64ChipModel, stereoSniffer, filter, stereoFilter, thirdSidFilter;
    @FXML
    private Slider mainVolume, secondVolume, thirdVolume, mainBalance, secondBalance, thirdBalance, mainDelay,
            secondDelay, thirdDelay;
    @FXML
    private Label mainVolumeValue, secondVolumeValue, thirdVolumeValue;
    @FXML
    private LineChart<Number, Number> mainFilterCurve, secondFilterCurve, thirdFilterCurve;

    @FXML
    private Button copy;

    @FXML
    private javafx.scene.layout.VBox circuitPresetEditor;

    private ObservableList<String> mainFilters, secondFilters, thirdFilters;

    private PropertyChangeListener emulationChange;

    private boolean duringInitialization;

    public EmulationSettings() {
        super();
    }

    public EmulationSettings(Player player) {
        super(player);
    }

    @FXML
    @Override
    protected void initialize() {
        duringInitialization = true;
        ResourceBundle bundle = util.getBundle();
        AudioSection audioSection = util.getConfig().getAudioSection();
        EmulationSection emulationSection = util.getConfig().getEmulationSection();

        muteVoice1.selectedProperty().bindBidirectional(emulationSection.muteVoice1Property());
        muteVoice1.selectedProperty().addListener(
                (obj, o, n) -> util.getPlayer().configureSID(0, sid -> sid.setVoiceMute(0, n)));
        muteVoice2.selectedProperty().bindBidirectional(emulationSection.muteVoice2Property());
        muteVoice2.selectedProperty().addListener(
                (obj, o, n) -> util.getPlayer().configureSID(0, sid -> sid.setVoiceMute(1, n)));
        muteVoice3.selectedProperty().bindBidirectional(emulationSection.muteVoice3Property());
        muteVoice3.selectedProperty().addListener(
                (obj, o, n) -> util.getPlayer().configureSID(0, sid -> sid.setVoiceMute(2, n)));
        muteVoice4.selectedProperty().bindBidirectional(emulationSection.muteVoice4Property());
        muteVoice4.selectedProperty().addListener(
                (obj, o, n) -> util.getPlayer().configureSID(0, sid -> sid.setVoiceMute(3, n)));
        muteVoice5.selectedProperty().bindBidirectional(emulationSection.muteStereoVoice1Property());
        muteVoice5.selectedProperty().addListener(
                (obj, o, n) -> util.getPlayer().configureSID(1, sid -> sid.setVoiceMute(0, n)));
        muteVoice6.selectedProperty().bindBidirectional(emulationSection.muteStereoVoice2Property());
        muteVoice6.selectedProperty().addListener(
                (obj, o, n) -> util.getPlayer().configureSID(1, sid -> sid.setVoiceMute(1, n)));
        muteVoice7.selectedProperty().bindBidirectional(emulationSection.muteStereoVoice3Property());
        muteVoice7.selectedProperty().addListener(
                (obj, o, n) -> util.getPlayer().configureSID(1, sid -> sid.setVoiceMute(2, n)));
        muteVoice8.selectedProperty().bindBidirectional(emulationSection.muteStereoVoice4Property());
        muteVoice8.selectedProperty().addListener(
                (obj, o, n) -> util.getPlayer().configureSID(1, sid -> sid.setVoiceMute(3, n)));
        muteVoice9.selectedProperty().bindBidirectional(emulationSection.muteThirdSIDVoice1Property());
        muteVoice9.selectedProperty().addListener(
                (obj, o, n) -> util.getPlayer().configureSID(2, sid -> sid.setVoiceMute(0, n)));
        muteVoice10.selectedProperty().bindBidirectional(emulationSection.muteThirdSIDVoice2Property());
        muteVoice10.selectedProperty().addListener(
                (obj, o, n) -> util.getPlayer().configureSID(2, sid -> sid.setVoiceMute(1, n)));
        muteVoice11.selectedProperty().bindBidirectional(emulationSection.muteThirdSIDVoice3Property());
        muteVoice11.selectedProperty().addListener(
                (obj, o, n) -> util.getPlayer().configureSID(2, sid -> sid.setVoiceMute(2, n)));
        muteVoice12.selectedProperty().bindBidirectional(emulationSection.muteThirdSIDVoice4Property());
        muteVoice12.selectedProperty().addListener(
                (obj, o, n) -> util.getPlayer().configureSID(2, sid -> sid.setVoiceMute(3, n)));

        mainFilters = FXCollections.observableArrayList();
        mainFilter.valueProperty().addListener((obj, o, n) -> updateSIDChipConfiguration());
        mainFilter.setItems(mainFilters);
        secondFilters = FXCollections.observableArrayList();
        secondFilter.valueProperty().addListener((obj, o, n) -> updateSIDChipConfiguration());
        secondFilter.setItems(secondFilters);
        thirdFilters = FXCollections.observableArrayList();
        thirdFilter.valueProperty().addListener((obj, o, n) -> updateSIDChipConfiguration());
        thirdFilter.setItems(thirdFilters);

        mainBalance.setLabelFormatter(new NumberToStringConverter<>(1));
        mainBalance.valueProperty().bindBidirectional(audioSection.mainBalanceProperty());
        mainBalance.valueProperty()
                .addListener((obj, o, n) -> util.getPlayer().configureMixer(m -> m.setBalance(0, n.floatValue())));
        secondBalance.setLabelFormatter(new NumberToStringConverter<>(1));
        secondBalance.valueProperty().bindBidirectional(audioSection.secondBalanceProperty());
        secondBalance.valueProperty()
                .addListener((obj, o, n) -> util.getPlayer().configureMixer(m -> m.setBalance(1, n.floatValue())));
        thirdBalance.setLabelFormatter(new NumberToStringConverter<>(1));
        thirdBalance.valueProperty().bindBidirectional(audioSection.thirdBalanceProperty());
        thirdBalance.valueProperty()
                .addListener((obj, o, n) -> util.getPlayer().configureMixer(m -> m.setBalance(2, n.floatValue())));

        mainDelay.valueProperty().bindBidirectional(audioSection.mainDelayProperty());
        mainDelay.valueProperty()
                .addListener((obj, o, n) -> util.getPlayer().configureMixer(m -> m.setDelay(0, n.intValue())));
        secondDelay.valueProperty().bindBidirectional(audioSection.secondDelayProperty());
        secondDelay.valueProperty()
                .addListener((obj, o, n) -> util.getPlayer().configureMixer(m -> m.setDelay(1, n.intValue())));
        thirdDelay.valueProperty().bindBidirectional(audioSection.thirdDelayProperty());
        thirdDelay.valueProperty()
                .addListener((obj, o, n) -> util.getPlayer().configureMixer(m -> m.setDelay(2, n.intValue())));

        mainVolume.valueProperty().bindBidirectional(audioSection.mainVolumeProperty());
        mainVolumeValue.textProperty().bindBidirectional(audioSection.mainVolumeProperty(),
                new NumberToStringConverter<>(2));
        mainVolume.valueProperty()
                .addListener((obj, o, n) -> util.getPlayer().configureMixer(m -> m.setVolume(0, n.floatValue())));

        secondVolume.valueProperty().bindBidirectional(audioSection.secondVolumeProperty());
        secondVolumeValue.textProperty().bindBidirectional(audioSection.secondVolumeProperty(),
                new NumberToStringConverter<>(2));
        secondVolume.valueProperty()
                .addListener((obj, o, n) -> util.getPlayer().configureMixer(b -> b.setVolume(1, n.floatValue())));

        thirdVolume.valueProperty().bindBidirectional(audioSection.thirdVolumeProperty());
        thirdVolumeValue.textProperty().bindBidirectional(audioSection.thirdVolumeProperty(),
                new NumberToStringConverter<>(2));
        thirdVolume.valueProperty()
                .addListener((obj, o, n) -> util.getPlayer().configureMixer(b -> b.setVolume(2, n.floatValue())));

        ObservableList<StereoMode> stereoModes = FXCollections.observableArrayList(StereoMode.values());
        stereoMode.setConverter(new EnumToStringConverter<>(bundle));
        stereoMode.valueProperty().addListener((obj, o, n) -> updateSIDChipConfiguration());
        stereoMode.setItems(stereoModes);

        baseAddress.textProperty().bindBidirectional(emulationSection.dualSidBaseProperty(),
                new HexNumberToStringConverter());
        baseAddress.textProperty().addListener((obj, o, n) -> updateSIDChipConfiguration());
        thirdAddress.textProperty().bindBidirectional(emulationSection.thirdSIDBaseProperty(),
                new HexNumberToStringConverter());
        thirdAddress.textProperty().addListener((obj, o, n) -> updateSIDChipConfiguration());

        ObservableList<SidReads> sidReads = FXCollections.observableArrayList(SidReads.values());

        sidToRead.setConverter(new EnumToStringConverter<>(bundle));
        sidToRead.setItems(sidReads);
        sidToRead.valueProperty().bindBidirectional(emulationSection.sidToReadProperty());

        ObservableList<Emulation> sid1Emulations = FXCollections.observableArrayList(Emulation.values());
        sid1Emulation.setConverter(new EnumToStringConverter<>(bundle));
        sid1Emulation.valueProperty().bindBidirectional(emulationSection.userEmulationProperty());
        sid1Emulation.valueProperty().addListener((obj, o, n) -> updateSIDChipConfiguration());
        sid1Emulation.setItems(sid1Emulations);

        ObservableList<Emulation> sid2Emulations = FXCollections.observableArrayList(Emulation.values());
        sid2Emulation.setConverter(new EnumToStringConverter<>(bundle));
        sid2Emulation.valueProperty().bindBidirectional(emulationSection.stereoEmulationProperty());
        sid2Emulation.valueProperty().addListener((obj, o, n) -> updateSIDChipConfiguration());
        sid2Emulation.setItems(sid2Emulations);

        ObservableList<Emulation> sid3Emulations = FXCollections.observableArrayList(Emulation.values());
        sid3Emulation.setConverter(new EnumToStringConverter<>(bundle));
        sid3Emulation.valueProperty().bindBidirectional(emulationSection.thirdEmulationProperty());
        sid3Emulation.valueProperty().addListener((obj, o, n) -> updateSIDChipConfiguration());
        sid3Emulation.setItems(sid3Emulations);

        ObservableList<ChipModel> sid1Models = FXCollections.observableArrayList(ChipModel.values());
        sid1Model.setConverter(new EnumToStringConverter<>(bundle));
        sid1Model.valueProperty().bindBidirectional(emulationSection.userSidModelProperty());
        sid1Model.valueProperty().addListener((obj, o, n) -> updateSIDChipConfiguration());
        sid1Model.setItems(sid1Models);

        ObservableList<ChipModel> sid2Models = FXCollections.observableArrayList(ChipModel.values());
        sid2Model.setConverter(new EnumToStringConverter<>(bundle));
        sid2Model.valueProperty().bindBidirectional(emulationSection.stereoSidModelProperty());
        sid2Model.valueProperty().addListener((obj, o, n) -> updateSIDChipConfiguration());
        sid2Model.setItems(sid2Models);

        ObservableList<ChipModel> sid3Models = FXCollections.observableArrayList(ChipModel.values());
        sid3Model.setConverter(new EnumToStringConverter<>(bundle));
        sid3Model.valueProperty().bindBidirectional(emulationSection.thirdSIDModelProperty());
        sid3Model.valueProperty().addListener((obj, o, n) -> updateSIDChipConfiguration());
        sid3Model.setItems(sid3Models);

        ObservableList<ChipModel> defaultModels = FXCollections.observableArrayList(MOS6581, MOS8580);
        defaultModel.setConverter(new EnumToStringConverter<>(bundle));
        defaultModel.valueProperty().bindBidirectional(emulationSection.defaultSidModelProperty());
        defaultModel.valueProperty().addListener((obj, o, n) -> updateSIDChipConfiguration());
        defaultModel.setItems(defaultModels);

        ObservableList<CPUClock> defaultVideoStandards = FXCollections.observableArrayList(PAL, NTSC);
        defaultVideoStandard.setConverter(new EnumToStringConverter<>(bundle));
        defaultVideoStandard.valueProperty().bindBidirectional(emulationSection.defaultClockSpeedProperty());
        defaultVideoStandard.valueProperty().addListener((obj, o, n) -> restart());
        defaultVideoStandard.setItems(defaultVideoStandards);

        ObservableList<Emulation> defaultEmulations = FXCollections.observableArrayList(RESID, RESIDFP, RESIDFP_CIRCUIT);
        defaultEmulation.setConverter(new EnumToStringConverter<>(bundle));
        defaultEmulation.valueProperty().bindBidirectional(emulationSection.defaultEmulationProperty());
        defaultEmulation.valueProperty().addListener((obj, o, n) -> updateSIDChipConfiguration());
        defaultEmulation.setItems(defaultEmulations);

        boosted8580.selectedProperty().bindBidirectional(emulationSection.digiBoosted8580Property());
        boosted8580.selectedProperty().addListener((obj, o, n) -> util.getPlayer()
                .configureSIDs((num, sid) -> sid.setDigiBoost(emulationSection.isDigiBoosted8580())));

        fakeStereo.selectedProperty().bindBidirectional(emulationSection.fakeStereoProperty());
        fakeStereo.selectedProperty().addListener((obj, o, n) -> updateSIDChipConfiguration());

        filter.selectedProperty().bindBidirectional(emulationSection.filterProperty());
        filter.selectedProperty().addListener(
                (obj, o, n) -> util.getPlayer().configureSID(0, sid -> sid.setFilterEnable(emulationSection, 0)));
        stereoFilter.selectedProperty().bindBidirectional(emulationSection.stereoFilterProperty());
        stereoFilter.selectedProperty().addListener(
                (obj, o, n) -> util.getPlayer().configureSID(1, sid -> sid.setFilterEnable(emulationSection, 1)));
        thirdSidFilter.selectedProperty().bindBidirectional(emulationSection.thirdSIDFilterProperty());
        thirdSidFilter.selectedProperty().addListener(
                (obj, o, n) -> util.getPlayer().configureSID(2, sid -> sid.setFilterEnable(emulationSection, 2)));

        detectPSID64ChipModel.selectedProperty().bindBidirectional(emulationSection.detectPSID64ChipModelProperty());
        stereoSniffer.selectedProperty().bindBidirectional(emulationSection.stereoSnifferProperty());
        bindBidirectional(silenceTimeout.textProperty(), emulationSection.silenceTimeoutProperty(),
                new MinimumNumberToStringConverter("#", 0));
        emulationSection.silenceTimeoutProperty()
                .addListener((obj, o, n) -> util.checkTextField(silenceTimeout, () -> n.intValue() >= 0, () -> {
                }, "SILENCE_TIMEOUT_TIP", "SILENCE_TIMEOUT_FORMAT"));

        ObservableList<C64Model> c64Models = FXCollections.observableArrayList(C64Model.values());
        c64Model.setConverter(new EnumToStringConverter<>(bundle));
        c64Model.valueProperty().bindBidirectional(emulationSection.c64ModelProperty());
        c64Model.setItems(c64Models);

        vicModel.setConverter(new EnumToStringConverter<>(bundle));
        vicModel.valueProperty().bindBidirectional(emulationSection.vicModelProperty());
        vicModel.setItems(FXCollections.observableArrayList(VICModel.values()));
        defaultVideoStandard.disableProperty().bind(emulationSection.vicModelProperty().isNotEqualTo(VICModel.DEFAULT));

        circuitPresetEditor.getChildren().add(new CircuitPresetEditor(util.getConfig().getFilterSection(), bundle, () -> {
            SidTune tune = util.getPlayer().getTune();
            drawFilterCurve(tune, 0, mainFilter, mainFilterCurve);
            drawFilterCurve(tune, 1, secondFilter, secondFilterCurve);
            drawFilterCurve(tune, 2, thirdFilter, thirdFilterCurve);
            updateSIDChipConfiguration();
        }));

        emulationChange = new EmulationChange();
        util.getPlayer().stateProperty().addListener(emulationChange);

        Platform.runLater(() -> {
            updateSettingsForTune(util.getPlayer().getTune());
            duringInitialization = false;
        });
    }

    private void updateSettingsForTune(SidTune tune) {
        updateFilterList(tune, 0, mainFilters, mainFilter);
        updateFilterList(tune, 1, secondFilters, secondFilter);
        updateFilterList(tune, 2, thirdFilters, thirdFilter);
        enableStereoSettings(tune);
    }

    private void enableStereoSettings(SidTune tune) {
        EmulationSection emulationSection = util.getConfig().getEmulationSection();

        boolean hardwareBasedSid = emulationSection.getEngine().isHardwareBased();
        boolean second = SidTune.isSIDUsed(emulationSection, tune, 1);
        boolean third = SidTune.isSIDUsed(emulationSection, tune, 2);
        boolean isForcedStereo = emulationSection.isForceStereo(1);
        boolean isForced3Sid = emulationSection.isForceStereo(2);

        stereoMode.getSelectionModel().select(emulationSection.getStereoMode());
        mainVolume.setDisable(hardwareBasedSid);
        sid1Emulation.setDisable(hardwareBasedSid);
        mainFilter.setDisable(hardwareBasedSid);
        mainFilterCurve.setDisable(hardwareBasedSid);
        copy.setDisable(hardwareBasedSid);
        // stereo, only:
        secondVolume.setDisable(!second || hardwareBasedSid);
        mainBalance.setDisable(!second || hardwareBasedSid);
        mainDelay.setDisable(!second);
        secondBalance.setDisable(!second || hardwareBasedSid);
        secondDelay.setDisable(!second);
        sid2Emulation.setDisable(!second || hardwareBasedSid);
        sid2Model.setDisable(!second);
        secondFilter.setDisable(!second || hardwareBasedSid);
        secondFilterCurve.setDisable(!second || hardwareBasedSid);
        stereoFilter.setDisable(!second);
        muteVoice5.setDisable(!second);
        muteVoice6.setDisable(!second);
        muteVoice7.setDisable(!second);
        muteVoice8.setDisable(!second);
        // 3-SID, only:
        thirdVolume.setDisable(!third || hardwareBasedSid);
        thirdBalance.setDisable(!third || hardwareBasedSid);
        thirdDelay.setDisable(!third);
        sid3Emulation.setDisable(!third || hardwareBasedSid);
        sid3Model.setDisable(!third);
        thirdFilter.setDisable(!third || hardwareBasedSid);
        thirdFilterCurve.setDisable(!third || hardwareBasedSid);
        thirdSidFilter.setDisable(!third);
        muteVoice9.setDisable(!third);
        muteVoice10.setDisable(!third);
        muteVoice11.setDisable(!third);
        muteVoice12.setDisable(!third);
        // fake stereo, only:
        sidToRead.setDisable(!emulationSection.isFakeStereo());
        // forced stereo or forced 3-SID, only:
        baseAddress.setDisable(!isForcedStereo && !isForced3Sid);
        // forced 3-SID, only:
        thirdAddress.setDisable(!isForced3Sid);
        // no SID boost for hardware SIDs
        boosted8580.setDisable(hardwareBasedSid);
    }

    @Override
    public void doClose() {
        util.getPlayer().stateProperty().removeListener(emulationChange);
    }

    @FXML
    private void setSid1Emulation() {
        updateFilterList(util.getPlayer().getTune(), 0, mainFilters, mainFilter);
    }

    @FXML
    private void setSid2Emulation() {
        updateFilterList(util.getPlayer().getTune(), 1, secondFilters, secondFilter);
    }

    @FXML
    private void setSid3Emulation() {
        updateFilterList(util.getPlayer().getTune(), 2, thirdFilters, thirdFilter);
    }

    @FXML
    private void setDefaultEmulation() {
        // default emulation has an impact on all emulation settings
        // (because "Default" means: use default emulation)
        updateFilterList(util.getPlayer().getTune(), 0, mainFilters, mainFilter);
        updateFilterList(util.getPlayer().getTune(), 1, secondFilters, secondFilter);
        updateFilterList(util.getPlayer().getTune(), 2, thirdFilters, thirdFilter);
    }

    @FXML
    private void setSid1Model() {
        // 1st chip model has an impact on all chip model settings
        // (because "Automatic" means: use 1st chip model)
        updateFilterList(util.getPlayer().getTune(), 0, mainFilters, mainFilter);
        updateFilterList(util.getPlayer().getTune(), 1, secondFilters, secondFilter);
        updateFilterList(util.getPlayer().getTune(), 2, thirdFilters, thirdFilter);
    }

    @FXML
    private void setSid2Model() {
        updateFilterList(util.getPlayer().getTune(), 1, secondFilters, secondFilter);
    }

    @FXML
    private void setSid3Model() {
        updateFilterList(util.getPlayer().getTune(), 2, thirdFilters, thirdFilter);
    }

    @FXML
    private void setDefaultModel() {
        // the default chip model has an impact on all chip model settings
        // (because "Automatic" means: use a default chip model if a tune model is unknown)
        updateFilterList(util.getPlayer().getTune(), 0, mainFilters, mainFilter);
        updateFilterList(util.getPlayer().getTune(), 1, secondFilters, secondFilter);
        updateFilterList(util.getPlayer().getTune(), 2, thirdFilters, thirdFilter);
    }

    @FXML
    private void setBaseAddress() {
        enableStereoSettings(util.getPlayer().getTune());
    }

    @FXML
    private void setThirdAddress() {
        enableStereoSettings(util.getPlayer().getTune());
    }

    @FXML
    private void setFakeStereo() {
        enableStereoSettings(util.getPlayer().getTune());
        // fake stereo mode has an impact on mono and stereo filter curves
        drawFilterCurve(util.getPlayer().getTune(), 0, mainFilter, mainFilterCurve);
        drawFilterCurve(util.getPlayer().getTune(), 1, secondFilter, secondFilterCurve);
    }

    @FXML
    private void setStereoMode() {
        util.getConfig().getEmulationSection().setStereoMode(stereoMode.getSelectionModel().getSelectedItem());

        enableStereoSettings(util.getPlayer().getTune());
        // stereo mode changes have an impact on all filter curves
        drawFilterCurve(util.getPlayer().getTune(), 0, mainFilter, mainFilterCurve);
        drawFilterCurve(util.getPlayer().getTune(), 1, secondFilter, secondFilterCurve);
        drawFilterCurve(util.getPlayer().getTune(), 2, thirdFilter, thirdFilterCurve);
    }

    @FXML
    private void setSidToRead() {
    }

    @FXML
    private void setDigiBoost() {
    }

    @FXML
    private void setMainFilter() {
        drawFilterCurve(util.getPlayer().getTune(), 0, mainFilter, mainFilterCurve);
    }

    @FXML
    private void setSecondFilter() {
        drawFilterCurve(util.getPlayer().getTune(), 1, secondFilter, secondFilterCurve);
    }

    @FXML
    private void setThirdFilter() {
        drawFilterCurve(util.getPlayer().getTune(), 2, thirdFilter, thirdFilterCurve);
    }

    @FXML
    private void restoreDefaults() {
        EmulationSection emulationSection = util.getConfig().getEmulationSection();
        AudioSection audioSection = util.getConfig().getAudioSection();

        emulationSection.setMuteVoice(0, 0, DEFAULT_MUTE_VOICE1);
        emulationSection.setMuteVoice(0, 1, DEFAULT_MUTE_VOICE2);
        emulationSection.setMuteVoice(0, 2, DEFAULT_MUTE_VOICE3);
        emulationSection.setMuteVoice(0, 3, DEFAULT_MUTE_VOICE4);
        emulationSection.setMuteVoice(1, 0, DEFAULT_MUTE_STEREO_VOICE1);
        emulationSection.setMuteVoice(1, 1, DEFAULT_MUTE_STEREO_VOICE2);
        emulationSection.setMuteVoice(1, 2, DEFAULT_MUTE_STEREO_VOICE3);
        emulationSection.setMuteVoice(1, 3, DEFAULT_MUTE_STEREO_VOICE4);
        emulationSection.setMuteVoice(2, 0, DEFAULT_MUTE_THIRDSID_VOICE1);
        emulationSection.setMuteVoice(2, 1, DEFAULT_MUTE_THIRDSID_VOICE2);
        emulationSection.setMuteVoice(2, 2, DEFAULT_MUTE_THIRDSID_VOICE3);
        emulationSection.setMuteVoice(2, 3, DEFAULT_MUTE_THIRDSID_VOICE4);

        audioSection.setVolume(0, DEFAULT_MAIN_VOLUME);
        audioSection.setVolume(1, DEFAULT_SECOND_VOLUME);
        audioSection.setVolume(2, DEFAULT_THIRD_VOLUME);
        audioSection.setBalance(0, DEFAULT_MAIN_BALANCE);
        audioSection.setBalance(1, DEFAULT_SECOND_BALANCE);
        audioSection.setBalance(2, DEFAULT_THIRD_BALANCE);
        audioSection.setDelay(0, DEFAULT_MAIN_DELAY);
        audioSection.setDelay(1, DEFAULT_SECOND_DELAY);
        audioSection.setDelay(2, DEFAULT_THIRD_DELAY);

        emulationSection.setForceStereo(1, DEFAULT_FORCE_STEREO_TUNE);
        emulationSection.setForceStereo(2, DEFAULT_FORCE_3SID_TUNE);
        emulationSection.setDualSidBase(DEFAULT_DUAL_SID_BASE);
        emulationSection.setThirdSIDBase(DEFAULT_THIRD_SID_BASE);
        emulationSection.setSidToRead(DEFAULT_SID_TO_READ);

        emulationSection.setDefaultSidModel(DEFAULT_SID_MODEL);
        emulationSection.setDefaultEmulation(DEFAULT_EMULATION);

        emulationSection.setDigiBoosted8580(DEFAULT_DIGI_BOOSTED_8580);
        emulationSection.setFakeStereo(DEFAULT_FAKE_STEREO);
        emulationSection.setDetectPSID64ChipModel(DEFAULT_DETECT_PSID64_CHIP_MODEL);
        emulationSection.setStereoSniffer(DEFAULT_STEREO_SNIFFER);
        emulationSection.setSilenceTimeout(DEFAULT_SILENCE_TIMEOUT);
        emulationSection.setC64Model(DEFAULT_C64_MODEL);
        emulationSection.setVicModel(DEFAULT_VIC_MODEL);

        emulationSection.setForcedEmulation(0, DEFAULT_USER_EMULATION);
        emulationSection.setForcedEmulation(1, DEFAULT_STEREO_EMULATION);
        emulationSection.setForcedEmulation(2, DEFAULT_3SID_EMULATION);

        emulationSection.setForcedSidModel(0, DEFAULT_USER_MODEL);
        emulationSection.setForcedSidModel(1, DEFAULT_STEREO_MODEL);
        emulationSection.setForcedSidModel(2, DEFAULT_3SID_MODEL);

        emulationSection.setFilter(DEFAULT_USE_FILTER);
        emulationSection.setStereoFilter(DEFAULT_USE_STEREO_FILTER);
        emulationSection.setThirdSIDFilter(DEFAULT_USE_3SID_FILTER);

        emulationSection.setFilter6581(DEFAULT_FILTER_6581);
        emulationSection.setFilter8580(DEFAULT_FILTER_8580);
        emulationSection.setStereoFilter6581(DEFAULT_STEREO_FILTER_6581);
        emulationSection.setStereoFilter8580(DEFAULT_STEREO_FILTER_8580);
        emulationSection.setThirdSIDFilter6581(DEFAULT_3SID_FILTER_6581);
        emulationSection.setThirdSIDFilter8580(DEFAULT_3SID_FILTER_8580);

        emulationSection.setReSIDfpFilter6581(DEFAULT_ReSIDfp_FILTER_6581);
        emulationSection.setReSIDfpFilter8580(DEFAULT_ReSIDfp_FILTER_8580);
        emulationSection.setReSIDfpStereoFilter6581(DEFAULT_ReSIDfp_STEREO_FILTER_6581);
        emulationSection.setReSIDfpStereoFilter8580(DEFAULT_ReSIDfp_STEREO_FILTER_8580);
        emulationSection.setReSIDfpThirdSIDFilter6581(DEFAULT_ReSIDfp_3SID_FILTER_6581);
        emulationSection.setReSIDfpThirdSIDFilter8580(DEFAULT_ReSIDfp_3SID_FILTER_8580);

        emulationSection.setReSIDfpCircuitFilter6581(DEFAULT_ReSIDfpCircuit_FILTER_6581);
        emulationSection.setReSIDfpCircuitFilter8580(DEFAULT_ReSIDfpCircuit_FILTER_8580);
        emulationSection.setReSIDfpCircuitStereoFilter6581(DEFAULT_ReSIDfpCircuit_STEREO_FILTER_6581);
        emulationSection.setReSIDfpCircuitStereoFilter8580(DEFAULT_ReSIDfpCircuit_STEREO_FILTER_8580);
        emulationSection.setReSIDfpCircuitThirdSIDFilter6581(DEFAULT_ReSIDfpCircuit_3SID_FILTER_6581);
        emulationSection.setReSIDfpCircuitThirdSIDFilter8580(DEFAULT_ReSIDfpCircuit_3SID_FILTER_8580);

        emulationSection.setNetSIDFilter6581(DEFAULT_NETSID_FILTER_6581);
        emulationSection.setNetSIDFilter8580(DEFAULT_NETSID_FILTER_8580);
        emulationSection.setNetSIDStereoFilter6581(DEFAULT_NETSID_STEREO_FILTER_6581);
        emulationSection.setNetSIDStereoFilter8580(DEFAULT_NETSID_STEREO_FILTER_8580);
        emulationSection.setNetSIDThirdSIDFilter6581(DEFAULT_NETSID_3SID_FILTER_6581);
        emulationSection.setNetSIDThirdSIDFilter8580(DEFAULT_NETSID_3SID_FILTER_8580);

        updateSettingsForTune(util.getPlayer().getTune());
    }

    @FXML
    private void doCopy() {
        EmulationSection emulationSection = util.getConfig().getEmulationSection();

        emulationSection.setStereoEmulation(emulationSection.getUserEmulation());
        emulationSection.setThirdEmulation(emulationSection.getUserEmulation());

        emulationSection.setStereoSidModel(emulationSection.getUserSidModel());
        emulationSection.setThirdSIDModel(emulationSection.getUserSidModel());

        emulationSection.setStereoFilter(emulationSection.isFilter());
        emulationSection.setThirdSIDFilter(emulationSection.isFilter());

        emulationSection.setStereoFilter6581(emulationSection.getFilter6581());
        emulationSection.setThirdSIDFilter6581(emulationSection.getFilter6581());
        emulationSection.setStereoFilter8580(emulationSection.getFilter8580());
        emulationSection.setThirdSIDFilter8580(emulationSection.getFilter8580());

        emulationSection.setReSIDfpStereoFilter6581(emulationSection.getReSIDfpFilter6581());
        emulationSection.setReSIDfpThirdSIDFilter6581(emulationSection.getReSIDfpFilter6581());
        emulationSection.setReSIDfpStereoFilter8580(emulationSection.getReSIDfpFilter8580());
        emulationSection.setReSIDfpThirdSIDFilter8580(emulationSection.getReSIDfpFilter8580());

        emulationSection.setReSIDfpCircuitStereoFilter6581(emulationSection.getReSIDfpCircuitFilter6581());
        emulationSection.setReSIDfpCircuitThirdSIDFilter6581(emulationSection.getReSIDfpCircuitFilter6581());
        emulationSection.setReSIDfpCircuitStereoFilter8580(emulationSection.getReSIDfpCircuitFilter8580());
        emulationSection.setReSIDfpCircuitThirdSIDFilter8580(emulationSection.getReSIDfpCircuitFilter8580());

        emulationSection.setNetSIDStereoFilter6581(emulationSection.getNetSIDFilter6581());
        emulationSection.setNetSIDThirdSIDFilter6581(emulationSection.getNetSIDFilter6581());
        emulationSection.setNetSIDStereoFilter8580(emulationSection.getNetSIDFilter8580());
        emulationSection.setNetSIDThirdSIDFilter8580(emulationSection.getNetSIDFilter8580());

        updateFilterList(util.getPlayer().getTune(), 1, secondFilters, secondFilter);
        updateFilterList(util.getPlayer().getTune(), 2, thirdFilters, thirdFilter);
    }

    private void restart() {
        if (!duringInitialization && util.getPlayer().stateProperty().get() != State.RESTART) {
            util.getPlayer().play(util.getPlayer().getTune());
        }
    }

    /**
     * Update SID configuration on-the-fly.
     */
    private void updateSIDChipConfiguration() {
        if (!duringInitialization) {
            util.getPlayer().updateSIDChipConfiguration();
        }
    }

    /**
     * Update the combo-box filter list according to the current emulation and chip model.
     *
     * @param tune    currently played tune
     * @param sidNum  SID chip number
     * @param filters resulting filter list to add matching filter names to
     * @param filter  combo box to select the currently selected filter
     */
    private void updateFilterList(final SidTune tune, int sidNum, ObservableList<String> filters,
                                  ComboBox<String> filter) {
        EmulationSection emulationSection = util.getConfig().getEmulationSection();
        List<FilterSection> filterSections = util.getConfig().getFilterSection();

        Engine engine = emulationSection.getEngine();
        Emulation emulation = Emulation.getEmulation(emulationSection, sidNum);
        ChipModel model = ChipModel.getChipModel(emulationSection, tune, sidNum);
        String filterName = emulationSection.getFilterName(sidNum, engine, emulation, model);
        boolean filterEnable = emulationSection.isFilterEnable(sidNum);

        filters.clear();
        if (engine == NETSID) {
            filters.addAll(TrySetSidModel.getFilterNames(model));
        } else {
            filters.add(""/* filter disabled */);
            for (IFilterSection filterSection : filterSections) {
                switch (model) {
                    case MOS6581:
                        if (filterSection.matches(emulation, model)) {
                            filters.add(filterSection.getName());
                        }
                        break;
                    case MOS8580:
                        if (filterSection.matches(emulation, model)) {
                            filters.add(filterSection.getName());
                        }
                        break;
                    default:
                        break;
                }
            }
        }
        // Keep the selected network calibration even while its routing is bypassed.
        if (engine == NETSID || filterEnable) {
            filter.getSelectionModel().select(filterName);
        } else {
            filter.getSelectionModel().select(0);
        }
    }

    /**
     * Update filter settings of the specified SID number according to the currently selected filter and re-draw the
     * filter curve.
     *
     * @param sidNum      SID chip number
     * @param filterBox   filter combo box
     * @param filterCurve filter curve to update
     */
    private void drawFilterCurve(SidTune tune, int sidNum, ComboBox<String> filterBox,
                                 LineChart<Number, Number> filterCurve) {
        IEmulationSection emulationSection = util.getConfig().getEmulationSection();
        List<FilterSection> filterSections = util.getConfig().getFilterSection();

        Engine engine = emulationSection.getEngine();
        Emulation emulation = Emulation.getEmulation(emulationSection, sidNum);
        ChipModel model = ChipModel.getChipModel(emulationSection, tune, sidNum);
        boolean second = SidTune.isSIDUsed(emulationSection, tune, 1);
        boolean third = SidTune.isSIDUsed(emulationSection, tune, 2);

        String filterName = filterBox.getSelectionModel().getSelectedItem();
        boolean filterDisabled = filterName == null || filterName.isEmpty();

        // Network presets select a remote model; the checkbox controls filter routing independently.
        if (engine != NETSID) {
            emulationSection.setFilterEnable(sidNum, !filterDisabled);
        }
        emulationSection.setFilterName(sidNum, engine, emulation, model, !filterDisabled ? filterName : null);

        List<Data<Number, Number>> dataList = new ArrayList<>();

        Optional<FilterSection> optFilter = filterSections.stream().filter(f -> f.getName().equals(filterName))
                .findFirst();
        if (optFilter.isPresent()) {
            FilterSection filterSection = optFilter.get();
            // stereo curve or 3-SID curve currently used?
            if (!(filterCurve == secondFilterCurve && !second || filterCurve == thirdFilterCurve && !third)) {
                for (int fc = 0; fc < FC_MAX; fc++) {
                    if (filterSection.isReSIDFilter6581() || filterSection.isReSIDFilter8580()) {
                        double data = builder.resid.resid.FilterModelConfig.estimateFrequency(filterSection, fc);
                        dataList.add(new XYChart.Data<>(fc, data));
                    } else if (filterSection.isReSIDfpFilter6581() || filterSection.isReSIDfpFilter8580()) {
                        double data = builder.resid.residfp.FilterModelConfig.estimateFrequency(filterSection, fc);
                        dataList.add(new XYChart.Data<>(fc, data));
                    } else if (filterSection.getCircuitModel() != ChipModel.AUTO) {
                        double data = builder.resid.residfp.circuit.FilterModelConfig.estimateFrequency(filterSection, fc);
                        dataList.add(new XYChart.Data<>(fc, data));
                    }
                }
            }
        }
        if (dataList.isEmpty()) {
            dataList.add(new XYChart.Data<>(0, 0));
        }
        XYChart.Series<Number, Number> series = new XYChart.Series<>();
        series.setData(FXCollections.observableArrayList(dataList));

        List<XYChart.Series<Number, Number>> seriesList = Collections.singletonList(series);
        filterCurve.setData(FXCollections.observableArrayList(seriesList));
    }

}