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