Video.java

package ui.videoscreen;

import javafx.animation.*;
import javafx.application.Platform;
import javafx.beans.binding.Bindings;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.fxml.FXML;
import javafx.scene.Node;
import javafx.scene.control.*;
import javafx.scene.image.Image;
import javafx.scene.image.ImageView;
import javafx.scene.image.PixelFormat;
import javafx.scene.image.WritableImage;
import javafx.scene.input.KeyCode;
import javafx.stage.FileChooser;
import javafx.stage.FileChooser.ExtensionFilter;
import javafx.stage.Modality;
import javafx.util.Duration;
import libsidplay.common.*;
import libsidplay.components.c1530.Datasette.DatasetteStatus;
import libsidplay.components.c1541.C1541.FloppyStatus;
import libsidplay.components.c1541.FloppyType;
import libsidplay.components.cart.CartridgeType;
import libsidplay.components.keyboard.KeyTableEntry;
import libsidplay.components.mos656x.VIC;
import libsidplay.sidtune.SidTune;
import libsidplay.sidtune.SidTuneError;
import libsidutils.debug.InspectionImage;
import libsidutils.debug.InspectionService;
import libsidutils.debug.InspectionSnapshot;
import sidplay.Player;
import sidplay.audio.VideoDriver;
import sidplay.player.State;
import ui.common.C64VBox;
import ui.common.C64Window;
import ui.common.ImageQueue;
import ui.common.UIPart;
import ui.common.converter.EnumToStringConverter;
import ui.common.converter.NumberToStringConverter;
import ui.common.fileextension.CartFileExtensions;
import ui.common.fileextension.DiskFileExtensions;
import ui.common.fileextension.TapeFileExtensions;
import ui.entities.config.EmulationSection;
import ui.entities.config.KeyTableEntity;
import ui.entities.config.SidPlay2Section;
import ui.virtualKeyboard.Keyboard;

import java.beans.PropertyChangeListener;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.Optional;
import java.util.ResourceBundle;
import java.util.function.Consumer;

import static sidplay.ini.IniDefaults.*;
import static ui.entities.config.SidPlay2Section.DEFAULT_VIDEO_SCALING;

public class Video extends C64VBox implements UIPart, VideoDriver {

    public static final String ID = "VIDEO";

    // monitorBorder transformation parameters
    private static final double SCALE_X = 1.2;
    private static final double PAL_SCALE_Y = 1.2;
    private static final double NTSC_SCALE_Y = 1.0;
    private static final int TRANSLATE_Y = 8;
    public Button keyboard;

    @FXML
    private TitledPane monitor;
    @FXML
    private ImageView screen;
    @FXML
    private ImageView monitorBorder, breadbox, pc64;
    @FXML
    private Slider scaling, brightness, contrast, gamma, saturation, phaseShift, offset, tint, blur, bleed;
    @FXML
    private CheckBox palEmulation, applyImmediately, showMonitorBorder;
    @FXML
    private ComboBox<PalEmulationMode> palEmulationMode;
    @FXML
    private Label scalingValue, brightnessValue, contrastValue, gammaValue, saturationValue, phaseShiftValue,
            offsetValue, tintValue, blurValue, bleedValue;
    @FXML
    private ImageView datasetteOff, datasetteLoad, datasetteSave, c1541Off, c1541On, c1541Load, c1541IIOff, c1541IIOn,
            c1541IILoad, c1571Off, c1571On, c1571Load, c1581Off, c1581On, c1581Load;
    @FXML
    private Label tapeName, diskName, cartridgeName, inspectionPosition, inspectionOverlay;

    private Timeline timer;

    private ImageQueue<Image> imageQueue;

    /**
     * Note: volatile, because Screen Updater thread writes it and javafx thread reads it!
     */
    private static volatile Image currentImage;

    private double scaleY;

    private PauseTransition pauseTransition;
    private SequentialTransition sequentialTransition;

    private PropertyChangeListener stateListener;
    private PropertyChangeListener inspectionListener;
    private boolean inspectionPaused;

    public Video() {
        super();
    }

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

    @FXML
    @Override
    protected void initialize() {
        ResourceBundle bundle = util.getBundle();
        SidPlay2Section sidplay2Section = util.getConfig().getSidplay2Section();
        EmulationSection emulationSection = util.getConfig().getEmulationSection();

        stateListener = event -> {
            if (event.getNewValue() == State.PLAY || event.getNewValue() == State.START) {
                Platform.runLater(() -> {
                    if (inspectionPaused) {
                        inspectionPaused = false;
                        inspectionPosition.setVisible(false);
                        inspectionPosition.setManaged(false);
                        inspectionOverlay.setVisible(false);
                        inspectionOverlay.setManaged(false);
                        setVisibilityBasedOnChipType(util.getPlayer().getTune());
                        sequentialTransition.playFromStart();
                    }
                });
            }
            if (event.getNewValue() == State.START) {
                Platform.runLater(() -> {
                    SidTune tune = util.getPlayer().getTune();
                    setupVideoScreen(CPUClock.getCPUClock(emulationSection, tune));
                    setVisibilityBasedOnChipType(tune);
                });
            }
        };
        util.getPlayer().stateProperty().addListener(stateListener);

        scaling.setLabelFormatter(new NumberToStringConverter<>(2));
        scaling.valueProperty().bindBidirectional(sidplay2Section.videoScalingProperty());
        scalingValue.textProperty().bindBidirectional(sidplay2Section.videoScalingProperty(),
                new NumberToStringConverter<>(2));
        scaling.valueProperty().addListener((observable, oldValue, newValue) -> {
            if (applyImmediately.isSelected()) {
                updateScaling();
            }
        });

        palEmulation.selectedProperty().bindBidirectional(sidplay2Section.palEmulationProperty());
        palEmulation.selectedProperty().addListener((observable, oldValue, newValue) -> util.getPlayer()
                .configureVICs(vic -> vic.getPalEmulation().setPalEmulationEnable(newValue)));

        ObservableList<PalEmulationMode> palEmulationModes = FXCollections.observableArrayList(PalEmulationMode.values());
        palEmulationMode.setConverter(new EnumToStringConverter<>(bundle));
        palEmulationMode.valueProperty().bindBidirectional(sidplay2Section.palEmulationModeProperty());
        palEmulationMode.setItems(palEmulationModes);
        palEmulationMode.setTooltip(new Tooltip(bundle.getString("PAL_EMULATION_MODE_TIP")));

        brightness.setLabelFormatter(new NumberToStringConverter<>(2));
        brightness.valueProperty().bindBidirectional(sidplay2Section.brightnessProperty());
        brightnessValue.textProperty().bindBidirectional(sidplay2Section.brightnessProperty(),
                new NumberToStringConverter<>(2));
        brightness.valueProperty()
                .addListener((observable, oldValue, newValue) -> updateVICChipConfiguration(
                        vic -> vic.getPalEmulation().getPalette().setBrightness(newValue.floatValue()),
                        applyImmediately.isSelected()));

        contrast.setLabelFormatter(new NumberToStringConverter<>(2));
        contrast.valueProperty().bindBidirectional(sidplay2Section.contrastProperty());
        contrastValue.textProperty().bindBidirectional(sidplay2Section.contrastProperty(),
                new NumberToStringConverter<>(2));
        contrast.valueProperty()
                .addListener((observable, oldValue, newValue) -> updateVICChipConfiguration(
                        vic -> vic.getPalEmulation().getPalette().setContrast(newValue.floatValue()),
                        applyImmediately.isSelected()));

        gamma.setLabelFormatter(new NumberToStringConverter<>(2));
        gamma.valueProperty().bindBidirectional(sidplay2Section.gammaProperty());
        gammaValue.textProperty().bindBidirectional(sidplay2Section.gammaProperty(), new NumberToStringConverter<>(2));
        gamma.valueProperty()
                .addListener((observable, oldValue, newValue) -> updateVICChipConfiguration(
                        vic -> vic.getPalEmulation().getPalette().setGamma(newValue.floatValue()),
                        applyImmediately.isSelected()));

        saturation.setLabelFormatter(new NumberToStringConverter<>(2));
        saturation.valueProperty().bindBidirectional(sidplay2Section.saturationProperty());
        saturationValue.textProperty().bindBidirectional(sidplay2Section.saturationProperty(),
                new NumberToStringConverter<>(2));
        saturation.valueProperty()
                .addListener((observable, oldValue, newValue) -> updateVICChipConfiguration(
                        vic -> vic.getPalEmulation().getPalette().setSaturation(newValue.floatValue()),
                        applyImmediately.isSelected()));

        phaseShift.setLabelFormatter(new NumberToStringConverter<>(2));
        phaseShift.valueProperty().bindBidirectional(sidplay2Section.phaseShiftProperty());
        phaseShiftValue.textProperty().bindBidirectional(sidplay2Section.phaseShiftProperty(),
                new NumberToStringConverter<>(2));
        phaseShift.valueProperty()
                .addListener((observable, oldValue, newValue) -> updateVICChipConfiguration(
                        vic -> vic.getPalEmulation().getPalette().setPhaseShift(newValue.floatValue()),
                        applyImmediately.isSelected()));

        offset.setLabelFormatter(new NumberToStringConverter<>(2));
        offset.valueProperty().bindBidirectional(sidplay2Section.offsetProperty());
        offsetValue.textProperty().bindBidirectional(sidplay2Section.offsetProperty(),
                new NumberToStringConverter<>(2));
        offset.valueProperty()
                .addListener((observable, oldValue, newValue) -> updateVICChipConfiguration(
                        vic -> vic.getPalEmulation().getPalette().setOffset(newValue.floatValue()),
                        applyImmediately.isSelected()));

        tint.setLabelFormatter(new NumberToStringConverter<>(2));
        tint.valueProperty().bindBidirectional(sidplay2Section.tintProperty());
        tintValue.textProperty().bindBidirectional(sidplay2Section.tintProperty(), new NumberToStringConverter<>(2));
        tint.valueProperty()
                .addListener((observable, oldValue, newValue) -> updateVICChipConfiguration(
                        vic -> vic.getPalEmulation().getPalette().setTint(newValue.floatValue()),
                        applyImmediately.isSelected()));

        blur.setLabelFormatter(new NumberToStringConverter<>(2));
        blur.valueProperty().bindBidirectional(sidplay2Section.blurProperty());
        blurValue.textProperty().bindBidirectional(sidplay2Section.blurProperty(), new NumberToStringConverter<>(2));
        blur.valueProperty()
                .addListener((observable, oldValue, newValue) -> updateVICChipConfiguration(
                        vic -> vic.getPalEmulation().getPalette().setLuminanceC(newValue.floatValue()),
                        applyImmediately.isSelected()));

        bleed.setLabelFormatter(new NumberToStringConverter<>(2));
        bleed.valueProperty().bindBidirectional(sidplay2Section.bleedProperty());
        bleedValue.textProperty().bindBidirectional(sidplay2Section.bleedProperty(), new NumberToStringConverter<>(2));
        bleed.valueProperty()
                .addListener((observable, oldValue, newValue) -> updateVICChipConfiguration(
                        vic -> vic.getPalEmulation().getPalette().setDotCreep(newValue.floatValue()),
                        applyImmediately.isSelected()));

        showMonitorBorder.selectedProperty().bindBidirectional(sidplay2Section.showMonitorProperty());

        pauseTransition = new PauseTransition();
        sequentialTransition = new SequentialTransition(pauseTransition);
        pauseTransition.setOnFinished(evt -> {
            Image image = imageQueue.pull();
            if (image != null) {
                currentImage = image;
                screen.setImage(image);
            }
        });
        sequentialTransition.setCycleCount(Animation.INDEFINITE);

        imageQueue = new ImageQueue<>();

        SidTune tune = util.getPlayer().getTune();
        setupVideoScreen(CPUClock.getCPUClock(emulationSection, tune));
        setVisibilityBasedOnChipType(tune);

        setupKeyboard();

        updatePeripheralImages();

        sequentialTransition.playFromStart();
        inspectionListener = event -> {
            if (event.getNewValue().equals("PAUSED")) showInspection();
        };
        util.getPlayer().inspectionStatusProperty().addListener(inspectionListener);
        inspectionOverlay.translateXProperty().bind(Bindings.createDoubleBinding(
                () -> screen.getBoundsInParent().getMinX() + 5 - inspectionOverlay.getLayoutX(),
                screen.boundsInParentProperty(), inspectionOverlay.layoutXProperty()));
        inspectionOverlay.translateYProperty().bind(Bindings.createDoubleBinding(
                () -> screen.getBoundsInParent().getMinY() + 5 - inspectionOverlay.getLayoutY(),
                screen.boundsInParentProperty(), inspectionOverlay.layoutYProperty()));
        showInspection();
    }

    private void showInspection() {
        InspectionService service = util.getPlayer().getC64().peekInspection();
        InspectionSnapshot snapshot = service == null || !service.isPaused() ? null : service.latest();
        if (snapshot == null || snapshot.video() == null) return;
        Platform.runLater(() -> {
            inspectionPaused = true;
            sequentialTransition.pause();
            imageQueue.clear();
            var frame = snapshot.video();
            WritableImage image = new WritableImage(frame.width(), frame.height());
            image.getPixelWriter().setPixels(0, 0, frame.width(), frame.height(), PixelFormat.getIntArgbInstance(),
                    InspectionImage.video(frame), 0, frame.width());
            currentImage = image;
            screen.setImage(image);
            setVisibilityBasedOnChipType(util.getPlayer().getTune());
            inspectionPosition.setText(String.format(util.getBundle().getString("INSPECTION_POSITION"),
                    snapshot.frame(), snapshot.vic().raster(), snapshot.vic().cycle(), snapshot.phase(), snapshot.time()));
            inspectionPosition.setVisible(true);
            inspectionPosition.setManaged(true);
            inspectionOverlay.setText(String.format(util.getBundle().getString("INSPECTION_RASTER"),
                    snapshot.vic().raster(), snapshot.vic().cycle(), snapshot.phase()));
            inspectionOverlay.setVisible(true);
            inspectionOverlay.setManaged(true);
        });
    }

    @Override
    public void doClose() {
        util.getPlayer().stateProperty().removeListener(stateListener);
        util.getPlayer().inspectionStatusProperty().removeListener(inspectionListener);
        util.getPlayer().removeVideoDriver(this);
        sequentialTransition.stop();
        timer.stop();
        imageQueue.dispose();
        currentImage = null;
    }

    @FXML
    private void showVirtualKeyboard() {
        Keyboard virtualKeyboard = new Keyboard(util.getPlayer());
        virtualKeyboard.getStage().initModality(Modality.WINDOW_MODAL);
        virtualKeyboard.getStage().initOwner(screen.getScene().getWindow());
        virtualKeyboard.open();
    }

    @FXML
    private void insertTape() {
        final FileChooser fileDialog = new FileChooser();
        fileDialog.setInitialDirectory(util.getConfig().getSidplay2Section().getLastDirectory());
        fileDialog.getExtensionFilters()
                .add(new ExtensionFilter(TapeFileExtensions.DESCRIPTION, TapeFileExtensions.EXTENSIONS));
        fileDialog.setTitle(util.getBundle().getString("INSERT_TAPE"));
        final File file = fileDialog.showOpenDialog(screen.getScene().getWindow());
        if (file != null) {
            try {
                util.getPlayer().insertTape(file);
            } catch (IOException | SidTuneError e) {
                System.err.printf("Cannot insert media file '%s'.%n", file.getAbsolutePath());
            }
        }
    }

    @FXML
    private void insertDisk() {
        final FileChooser fileDialog = new FileChooser();
        fileDialog.setInitialDirectory(util.getConfig().getSidplay2Section().getLastDirectory());
        fileDialog.getExtensionFilters()
                .add(new ExtensionFilter(DiskFileExtensions.DESCRIPTION, DiskFileExtensions.EXTENSIONS));
        fileDialog.setTitle(util.getBundle().getString("INSERT_DISK"));
        final File file = fileDialog.showOpenDialog(screen.getScene().getWindow());
        if (file != null) {
            try {
                util.getPlayer().insertDisk(file);
            } catch (IOException e) {
                System.err.printf("Cannot insert media file '%s'.%n", file.getAbsolutePath());
            }
        }
    }

    @FXML
    private void insertCartridge() {
        final FileChooser fileDialog = new FileChooser();
        fileDialog.setInitialDirectory(util.getConfig().getSidplay2Section().getLastDirectory());
        fileDialog.getExtensionFilters()
                .add(new ExtensionFilter(CartFileExtensions.DESCRIPTION, CartFileExtensions.EXTENSIONS));
        fileDialog.setTitle(util.getBundle().getString("INSERT_CARTRIDGE"));
        final File file = fileDialog.showOpenDialog(screen.getScene().getWindow());
        if (file != null) {
            try {
                util.getPlayer().insertCartridge(CartridgeType.CRT, file);
                util.getPlayer().play(SidTune.RESET);
            } catch (IOException e) {
                System.err.printf("Cannot insert media file '%s'.%n", file.getAbsolutePath());
            }
        }
    }

    @FXML
    private void apply() {
        updateScaling();
        util.getPlayer().configureVICs(vic -> vic.getPalEmulation().updatePalette());
    }

    @FXML
    private void showMonitorBorder() {
        util.getConfig().getSidplay2Section().setShowMonitor(showMonitorBorder.isSelected());
        setVisibilityBasedOnChipType(util.getPlayer().getTune());
    }

    @FXML
    private void defaultPalette() {
        applyImmediately.setSelected(false);

        scaling.setValue(DEFAULT_VIDEO_SCALING);
        brightness.setValue(DEFAULT_BRIGHTNESS);
        contrast.setValue(DEFAULT_CONTRAST);
        gamma.setValue(DEFAULT_GAMMA);
        saturation.setValue(DEFAULT_SATURATION);
        phaseShift.setValue(DEFAULT_PHASE_SHIFT);
        offset.setValue(DEFAULT_OFFSET);
        tint.setValue(DEFAULT_TINT);
        blur.setValue(DEFAULT_BLUR);
        bleed.setValue(DEFAULT_BLEED);
        apply();

        util.getConfig().getSidplay2Section().setShowMonitor(true);
        showMonitorBorder();

        applyImmediately.setSelected(true);
    }

    /**
     * Connect VIC output with screen.
     */
    private void setupVideoScreen(final CPUClock cpuClock) {
        scaleY = (cpuClock == CPUClock.PAL) ? PAL_SCALE_Y : NTSC_SCALE_Y;
        pauseTransition.setDuration(Duration.millis(1000. / util.getPlayer().getC64().getScreenRefresh()));

        screen.setFitWidth(util.getPlayer().getC64().getVIC().getBorderWidth());
        screen.setFitHeight(util.getPlayer().getC64().getVIC().getBorderHeight());
        updateScaling();
        var renderer = util.getPlayer().getC64().getVIC().getPalEmulation();
        boolean fixedPalette = renderer != null && renderer.getPalette()
                == libsidplay.components.mos656x.IPalette.FIXED;
        for (Slider slider : Arrays.asList(brightness, contrast, gamma, saturation, phaseShift, offset, tint, blur, bleed)) {
            slider.setDisable(fixedPalette);
        }
    }

    private void updateScaling() {
        final SidPlay2Section sidplay2Section = util.getConfig().getSidplay2Section();

        double scale = sidplay2Section.getVideoScaling();
        for (Node node : Arrays.asList(monitorBorder, screen, breadbox, pc64)) {
            node.setScaleX(scale);
            node.setScaleY(scale);
        }
        // adjust monitorBorder to surround screen
        monitorBorder.setScaleX(monitorBorder.getScaleX() * SCALE_X);
        monitorBorder.setScaleY(monitorBorder.getScaleY() * scaleY);
        monitorBorder.setTranslateY(TRANSLATE_Y * monitorBorder.getScaleY());
    }

    /**
     * Connect Keyboard with C64 keyboard.
     */
    private void setupKeyboard() {
        monitor.setOnKeyPressed(event -> {
            // Let the scene's WARP accelerator handle Alt+W; do not type W into the C64.
            if (event.getCode() == KeyCode.W && event.isAltDown() && !event.isControlDown()
                    && !event.isShiftDown() && !event.isMetaDown()) {
                return;
            }
            event.consume();
            Optional<KeyTableEntry> keyTableEntry = util.getConfig().getKeyCodeMap().stream()
                    .filter(keyCode -> keyCode.getKeyCodeName().equals(event.getCode().getName()))
                    .map(KeyTableEntity::getEntry).findFirst();

            if (event.isShiftDown()) {
                pressC64Key(KeyTableEntry.SHIFT_LEFT);
            }
            if (event.isControlDown()) {
                pressC64Key(KeyTableEntry.COMMODORE);
            }

            if (keyTableEntry.isPresent()) {
                pressC64Key(keyTableEntry.get());
                releaseC64Key(keyTableEntry.get());
            }

            if (event.isControlDown()) {
                releaseC64Key(KeyTableEntry.COMMODORE);
            }
            if (event.isShiftDown()) {
                releaseC64Key(KeyTableEntry.SHIFT_LEFT);
            }
            // prevent focus traversal using cursor keys or tab!
            monitor.requestFocus();
        });
    }

    private void pressC64Key(final KeyTableEntry key) {
        final EventScheduler ctx = util.getPlayer().getC64().getEventScheduler();
        ctx.scheduleThreadSafeKeyEvent(Event.of("Virtual Keyboard Key Pressed: " + key.name(),
                event -> util.getPlayer().getC64().getKeyboard().keyPressed(key)));
    }

    private void releaseC64Key(final KeyTableEntry key) {
        final EventScheduler ctx = util.getPlayer().getC64().getEventScheduler();
        ctx.scheduleThreadSafeKeyEvent(Event.of("Virtual Keyboard Key Released: " + key.name(),
                event -> util.getPlayer().getC64().getKeyboard().keyReleased(key)));
    }

    private void updatePeripheralImages() {
        updateFloppyImage();
        final Duration duration = Duration.millis(1000);
        final KeyFrame oneFrame = new KeyFrame(duration, evt -> {
            DatasetteStatus datasetteStatus = util.getPlayer().getDatasette().getStatus();
            tapeName.setText(util.getPlayer().getDatasette().getTapeImage().getName());
            switch (datasetteStatus) {
                case OFF:
                    datasetteOff.setVisible(true);
                    for (ImageView imageView : Arrays.asList(datasetteLoad, datasetteSave)) {
                        imageView.setVisible(false);
                    }
                    break;
                case LOAD:
                    datasetteLoad.setVisible(true);
                    for (ImageView imageView : Arrays.asList(datasetteOff, datasetteSave)) {
                        imageView.setVisible(false);
                    }
                    break;
                case SAVE:
                    datasetteSave.setVisible(true);
                    for (ImageView imageView : Arrays.asList(datasetteOff, datasetteLoad)) {
                        imageView.setVisible(false);
                    }
                    break;

                default:
                    throw new RuntimeException("Unexpected datasette status: " + datasetteStatus);
            }
            updateFloppyImage();
            cartridgeName.setText(util.getPlayer().getC64().getCartridge().toString());
        });
        timer = new Timeline(oneFrame);
        timer.setCycleCount(Animation.INDEFINITE);
        timer.playFromStart();
    }

    /**
     * Display the active drive model, mounted disk name and power/activity image.
     */
    private void updateFloppyImage() {
        final FloppyType floppyType = util.getPlayer().getFloppyType();
        diskName.setText(floppyType + ": " + java.util.Objects.toString(util.getPlayer().getFloppyDiskName(), ""));
        final FloppyStatus floppyStatus = util.getPlayer().getFloppyStatus();
        final ImageView activeImage = switch (floppyType) {
            case C1541 -> switch (floppyStatus) {
                case OFF -> c1541Off;
                case ON -> c1541On;
                case LOAD -> c1541Load;
            };
            case C1541_II -> switch (floppyStatus) {
                case OFF -> c1541IIOff;
                case ON -> c1541IIOn;
                case LOAD -> c1541IILoad;
            };
            case C1571 -> switch (floppyStatus) {
                case OFF -> c1571Off;
                case ON -> c1571On;
                case LOAD -> c1571Load;
            };
            case C1581 -> switch (floppyStatus) {
                case OFF -> c1581Off;
                case ON -> c1581On;
                case LOAD -> c1581Load;
            };
        };
        for (ImageView imageView : Arrays.asList(c1541Off, c1541On, c1541Load, c1541IIOff, c1541IIOn, c1541IILoad,
                c1571Off, c1571On, c1571Load, c1581Off, c1581On, c1581Load)) {
            imageView.setVisible(imageView == activeImage);
        }
    }

    /**
     * Make breadbox/pc64 image visible, if the internal SID player is used.
     */
    private void setVisibilityBasedOnChipType(final SidTune sidTune) {
        if (inspectionPaused) {
            screen.setVisible(true);
            monitorBorder.setVisible(false);
            breadbox.setVisible(false);
            pc64.setVisible(false);
            return;
        }
        util.getPlayer().removeVideoDriver(this);
        EmulationSection emulationSection = util.getConfig().getEmulationSection();
        if (sidTune != SidTune.RESET && sidTune.getInfo().getPlayAddr() != 0) {
            // SID Tune is loaded and uses internal player?
            screen.setVisible(false);
            monitorBorder.setVisible(false);
            if (ChipModel.getChipModel(emulationSection, sidTune, 0) == ChipModel.MOS6581) {
                // Old SID chip model? Show breadbox
                breadbox.setVisible(true);
                pc64.setVisible(false);
            } else {
                // New SID chip model? Show PC64
                pc64.setVisible(true);
                breadbox.setVisible(false);
            }
        } else {
            // Normal RESET: Show video screen and monitor
            breadbox.setVisible(false);
            pc64.setVisible(false);
            screen.setVisible(true);
            monitorBorder.setVisible(showMonitorBorder.isSelected());
            util.getPlayer().addVideoDriver(this);
        }
    }

    private void updateVICChipConfiguration(Consumer<VIC> action, boolean apply) {
        util.getPlayer().configureVICs(action.andThen(vic -> {
            if (apply)
                apply();

        }));
    }

    /**
     * Create an image per frame of VIC screen output.
     */
    @Override
    public void accept(VIC vic) {
        // WARP always displays the latest available frame, without a stale image backlog.
        if (util.getPlayer().isWarp()) {
            imageQueue.clear();
        }
        WritableImage image = new WritableImage(vic.getBorderWidth(), vic.getBorderHeight());
        image.getPixelWriter().setPixels(0, 0, vic.getBorderWidth(), vic.getBorderHeight(),
                PixelFormat.getByteBgraPreInstance(), vic.getPalEmulation().getPixels().array(), 0,
                vic.getBorderWidth() << 2);
        imageQueue.push(image);
    }

    @Override
    public void clearQueuedFrames() {
        if (imageQueue != null) {
            imageQueue.clear();
        }
    }

    /**
     * @return VIC image with current frame
     */
    public static Image getVicImage() {
        return currentImage;
    }

}