AudioDriverTeaVM.java

package client.teavm.common.audio;

import builder.resid.SIDMixer;
import client.teavm.common.IImportedApi;
import libsidplay.common.*;
import libsidplay.components.mos656x.VIC;
import libsidplay.config.IAudioSection;
import sidplay.audio.AudioConfig;
import sidplay.audio.AudioDriver;
import sidplay.audio.VideoDriver;

import java.nio.ByteBuffer;

/**
 * Audio driver to be used in the JavaScript and web assembly version builds.
 */
public final class AudioDriverTeaVM implements AudioDriver, VideoDriver, SIDListener {

    public static final int MAX_SID_WRITE_SIDS = 3;

    private static final short REGULAR_DELAY = 8192;

    private final IImportedApi importedApi;
    private final float[] lookupTable;
    private final SIDMixer mixer;
    private final boolean usb;
    private final int nthFrame;

    private EventScheduler context;
    private ByteBuffer sampleBuffer;
    private int sampleRate;
    private ByteBuffer timing;
    private int n, fastForwardVICFrames;
    private long lastSIDWriteTime;
    private boolean warp;
    private long nextWarpFrameNanos;

    public AudioDriverTeaVM(IImportedApi importedApi, float[] lookupTable, SIDMixer mixer, boolean usb, int nthFrame) {
        this.importedApi = importedApi;
        this.lookupTable = lookupTable;
        this.mixer = mixer;
        this.usb = usb;
        this.nthFrame = nthFrame;
    }

    //
    // implements AudioDriver
    //

    @Override
    public void open(IAudioSection audioSection, String recordingFilename, CPUClock cpuClock, EventScheduler context) {
        this.context = context;
        AudioConfig cfg = new AudioConfig(audioSection);
        sampleRate = cfg.getFrameRate();
        timing = ByteBuffer.allocate(32 + 130 * 16);

        sampleBuffer = importedApi.initSampleBuffer(cfg.getChunkFrames(), cfg.getChannels());

        if (usb) {
            context.schedule(
                    Event.of("USB Regular Delay",
                            event -> context.schedule(event, eventuallyDelay(), Event.Phase.PHI2)),
                    0, Event.Phase.PHI2);
        }
    }

    @Override
    public boolean supportsWarp() {
        return !usb && importedApi.supportsWarp();
    }

    @Override
    public void setWarp(boolean enabled) {
        if (enabled && !supportsWarp()) {
            throw new UnsupportedOperationException("This output does not support WARP");
        }
        warp = enabled;
        nextWarpFrameNanos = 0;
        lastSIDWriteTime = context.getTime(Event.Phase.PHI2);
    }

    @Override
    public void write() {
        if (warp) {
            return;
        }
        final long now = context.getTime(Event.Phase.PHI2);
        importedApi.processSamples(now, sampleBuffer, lookupTable);
    }

    @Override
    public void write(long first, long last, long offset, int frames) {
        if (warp) {
            return;
        }
        mixer.getPlaybackTimeline().write(timing, offset, offset + frames, sampleRate);
        importedApi.processAudioTiming(timing);
        write();
    }

    @Override
    public void close() {
    }

    @Override
    public ByteBuffer buffer() {
        return sampleBuffer;
    }

    @Override
    public boolean isRecording() {
        return false;
    }

    //
    // implements VideoDriver
    //

    @Override
    public void accept(VIC vic) {
        if (warp) {
            long now = System.nanoTime();
            if (nextWarpFrameNanos == 0 || now - nextWarpFrameNanos >= 0) {
                nextWarpFrameNanos = now + 100_000_000L;
                importedApi.processFrame(context.getTime(Event.Phase.PHI2), vic.getPalEmulation().getPixels());
            }
            return;
        }
        int fastForwardBitMask = mixer.getFastForwardBitMask();
        if ((fastForwardVICFrames++ & fastForwardBitMask) == fastForwardBitMask) {
            if (++n == nthFrame) {
                n = 0;
                final long now = context.getTime(Event.Phase.PHI2);
                importedApi.processFrame(now, vic.getPalEmulation().getPixels());
            }
        }
    }

    //
    // implements SIDListener
    //

    @Override
    public void write(int sidNum, int addr, byte data) {
        if (warp) {
            return;
        }
        if (sidNum < MAX_SID_WRITE_SIDS) {
            final long now = context.getTime(Event.Phase.PHI2);
            importedApi.processSidWrite(sidNum, now, clocksSinceLastAccess(now), addr, data & 0xff);
        }
    }

    //
    // private methods
    //

    private int clocksSinceLastAccess(long now) {
        int diff = (int) (now - lastSIDWriteTime);
        lastSIDWriteTime = now;
        return diff >> mixer.getFastForwardBitMask();
    }

    private long eventuallyDelay() {
        final long now = context.getTime(Event.Phase.PHI2);
        int diff = (int) (now - lastSIDWriteTime);
        if (diff > REGULAR_DELAY) {
            lastSIDWriteTime += REGULAR_DELAY;
            importedApi.processSidWrite(0, now, (short) (REGULAR_DELAY >> mixer.getFastForwardBitMask()), -1, 0);
        }
        return REGULAR_DELAY;
    }

}