VicePALEmulationTeaVM.java

package client.teavm.common.video;

import client.teavm.common.IImportedApi;
import libsidplay.components.mos656x.IPALEmulation;
import libsidplay.components.mos656x.IPalette;
import libsidplay.components.mos656x.MOS6569;
import libsidplay.components.mos656x.VIC;
import libsidplay.components.mos656x.VicePALRenderer;

import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.util.Arrays;

import static java.nio.ByteOrder.LITTLE_ENDIAN;

/**
 * Native-resolution VICE PAL adapter for browser RGBA frame consumers.
 */
public final class VicePALEmulationTeaVM implements IPALEmulation {

    public static final int WIDTH = VIC.MAX_WIDTH;
    public static final int HEIGHT = MOS6569.BORDER_HEIGHT;

    /**
     * VIC colors without PAL emulation. Converted from RGBA (MSB to LSB) to little-endian integers during initialization.
     * <a href="https://www.pepto.de/projects/colorvic/2001/">Pepto</a>
     */
    private final int[] vicPaletteNoPal = new int[]{0x000000FF, 0xFFFFFFFF, 0x68372BFF, 0x70A4B2FF, 0x6F3D86FF,
            0x588D43FF, 0x352879FF, 0xB8C76FFF, 0x6F4F25FF, 0x433900FF, 0x9A6759FF, 0x444444FF, 0x6C6C6CFF, 0x9AD284FF,
            0x6C5EB5FF, 0x959595FF,};

    private final IImportedApi importedApi;

    private final int nthFrame;

    private final VicePALRenderer renderer = new VicePALRenderer(WIDTH);
    /**
     * VIC color indices for the current raster line.
     */
    private final byte[] lineColors = new byte[WIDTH];
    /**
     * Decoded RGBA pixels for the current raster line, packed as little-endian integers.
     */
    private final int[] linePixels = new int[WIDTH];
    /**
     * Current raster line.
     */
    private int currentRasterY;
    /**
     * Index into the current line.
     */
    private int linePixelIndex;

    private int n;
    private int frameOffset;
    private boolean inspectionRendering, frameRendered = true;
    private final ByteBuffer pixels;
    private final IntBuffer packedPixels;

    private boolean palEmulationEnable = true;
    private boolean palEmulationEnablePending = true;

    public VicePALEmulationTeaVM(IImportedApi importedApi, int nthFrame) {
        if (nthFrame <= 0) {
            throw new IllegalArgumentException("A positive frame interval is required");
        }
        this.importedApi = importedApi;
        this.nthFrame = nthFrame;

        // The renderer packs RGBA bytes in native WASM order.
        // Bulk row copies avoid per-pixel buffer checks and byte swapping.
        pixels = importedApi.initFrameBuffer(WIDTH, HEIGHT).order(LITTLE_ENDIAN);
        packedPixels = pixels.asIntBuffer();
        for (int i = 0; i < vicPaletteNoPal.length; i++) {
            vicPaletteNoPal[i] = Integer.reverseBytes(vicPaletteNoPal[i]);
        }
    }

    /**
     * Determine a palette for the current raster line.
     *
     * @param rasterY      current raster line
     * @param isFrameStart a new frame is about to start?
     */
    @Override
    public void determineCurrentPalette(int rasterY, boolean isFrameStart) {
        if (isFrameStart) {
            // apply new setting, only at frame start
            palEmulationEnable = palEmulationEnablePending;
            if (++n == nthFrame) {
                n = 0;
            }
            frameRendered = n == 0 || inspectionRendering;
            if (frameRendered) {
                importedApi.prepareFrame(pixels);
                frameOffset = pixels.position();
                packedPixels.position(pixels.position() >>> 2);
                renderer.reset();
            }
        }
        currentRasterY = rasterY;
        linePixelIndex = 0;
    }

    /**
     * Draw eight pixels at once. Pixels arrive in 0x12345678 order (MSB to LSB).
     *
     * @param graphicsDataBuffer eight pixels each of 4 bits (VIC color value range 0x0-0xF)
     */
    @Override
    public void drawPixels(int graphicsDataBuffer) {
        if (!frameRendered) {
            return;
        }
        for (int shift = 28; shift >= 0; shift -= 4) {
            lineColors[linePixelIndex++] = (byte) (graphicsDataBuffer >>> shift & 15);
        }
        if (linePixelIndex == lineColors.length) {
            if (palEmulationEnable) {
                renderer.renderLine(lineColors, currentRasterY, linePixels);
            } else {
                for (int x = 0; x < lineColors.length; x++) {
                    linePixels[x] = vicPaletteNoPal[lineColors[x]];
                }
            }
            packedPixels.put(linePixels);
            pixels.position(packedPixels.position() << 2);
            linePixelIndex = 0;
        }
    }

    @Override
    public void updatePalette() {
    }

    @Override
    public void setPalEmulationEnable(boolean palEmulationEnablePending) {
        this.palEmulationEnablePending = palEmulationEnablePending;
    }

    @Override
    public void setVicPaletteNoPal(int[] vicPaletteNoPal) {
        for (int i = 0; i < this.vicPaletteNoPal.length; i++) {
            this.vicPaletteNoPal[i] = Integer.reverseBytes(vicPaletteNoPal[i]);
        }
    }

    @Override
    public IPalette getPalette() {
        return IPalette.FIXED;
    }

    /**
     * @return Output RGBA screen buffer in red, green, blue, alpha byte order.
     */
    @Override
    public ByteBuffer getPixels() {
        return pixels;
    }

    @Override
    public FrameBuffer getFrameBuffer() {
        return new FrameBuffer(pixels, frameOffset, (pixels.position() - frameOffset) >>> 2, true, frameRendered);
    }

    @Override
    public void setInspectionRendering(boolean enabled) {
        inspectionRendering = enabled;
    }

    @Override
    public void reset() {
        renderer.reset();
        n = 0;
        frameOffset = 0;
        frameRendered = true;
        linePixelIndex = 0;

        // clear the screen, including both shared frame slots
        Arrays.fill(linePixels, 0xFF000000);
        packedPixels.clear();
        while (packedPixels.hasRemaining()) {
            packedPixels.put(linePixels);
        }
        pixels.clear();
    }
}