mod-player-worklet.js

const PAULA_FREQUENCY = 3546894.6;

const ARPEGGIO = 0x00;
const SLIDE_UP = 0x01;
const SLIDE_DOWN = 0x02;
const TONE_PORTAMENTO = 0x03;
const VIBRATO = 0x04;
const TONE_PORTAMENTO_WITH_VOLUME_SLIDE = 0x05;
const VIBRATO_WITH_VOLUME_SLIDE = 0x06;
const SAMPLE_OFFSET = 0x09;
const VOLUME_SLIDE = 0x0A;
const SET_VOLUME = 0x0C;
const PATTERN_BREAK = 0x0D;
const EXTENDED = 0x0e;
const SET_SPEED = 0x0f;
const RETRIGGER_NOTE = 0xe9;
const DELAY_NOTE = 0xed;

const unimplementedEffects = new Set();

class Channel {
    constructor(worklet) {
        this.worklet = worklet;
        this.instrument = null;
        this.playing = false;
        this.period = 0;
        this.currentPeriod = 0;
        this.portamentoSpeed = 0;
        this.periodDelta = 0;
        this.vibratoDepth = 0;
        this.vibratoSpeed = 0;
        this.vibratoIndex = 0;
        this.arpeggio = false;
        this.sampleSpeed = 0.0;
        this.sampleIndex = 0;
        this.volume = 64;
        this.currentVolume = 64;
    }

    nextOutput() {
        if (!this.instrument || !this.period) return 0.0;
        const sample = this.instrument.bytes[this.sampleIndex | 0];

        this.sampleIndex += this.sampleSpeed;

        if (this.instrument.isLooped) {
            if (this.sampleIndex >= this.instrument.repeatOffset + this.instrument.repeatLength) {
                this.sampleIndex = this.instrument.repeatOffset;
            }
        }
        else if (this.sampleIndex >= this.instrument.length) {
            return 0.0;
        }

        return sample / 256.0 * this.currentVolume / 64;
    }

    performTick() {
        if (this.volumeSlide && this.worklet.tick > 0) {
            this.currentVolume += this.volumeSlide;
            if (this.currentVolume < 0) this.currentVolume = 0;
            if (this.currentVolume > 64) this.currentVolume = 64;
        }

        if (this.vibrato) {
            this.vibratoIndex = (this.vibratoIndex + this.vibratoSpeed) % 64;
            this.currentPeriod = this.period + Math.sin(this.vibratoIndex / 64 * Math.PI * 2) * this.vibratoDepth;
        }
        else if (this.periodDelta) {
            if (this.portamento) {
                if (this.currentPeriod != this.period) {
                    const sign = Math.sign(this.period - this.currentPeriod);
                    const distance = Math.abs(this.currentPeriod - this.period);
                    const diff = Math.min(distance, this.periodDelta);
                    this.currentPeriod += sign * diff;
                }
            }
            else {
                this.currentPeriod += this.periodDelta;
            }
        }
        else if (this.arpeggio) {
            const index = this.worklet.tick % this.arpeggio.length;
            const halfNotes = this.arpeggio[index];
            this.currentPeriod = this.period / Math.pow(2, halfNotes / 12);
        }
        else if (this.retrigger && (this.worklet.tick % this.retrigger) == 0) {
            this.sampleIndex = 0;
        }
        else if (this.delayNote === this.worklet.tick) {
            this.instrument = this.setInstrument;
            this.volume = this.setVolume;
            this.currentVolume = this.volume;
            this.period = this.setPeriod;
            this.currentPeriod = this.period;
            this.sampleIndex = 0;
        }
        
        if (this.currentPeriod < 113) this.currentPeriod = 113;
        if (this.currentPeriod > 856) this.currentPeriod = 856;
         
        const sampleRate = PAULA_FREQUENCY / this.currentPeriod;
        this.sampleSpeed = sampleRate / this.worklet.sampleRate;
    }

    play(note) {
        this.setInstrument = false;
        this.setVolume = false;
        this.setPeriod = false;
        this.delayNote = false;

        if (note.instrument) {
            this.setInstrument = this.worklet.mod.instruments[note.instrument];
            this.setVolume = this.setInstrument.volume;
        }

        this.setSampleIndex = false;
        this.setCurrentPeriod = false;

        if (note.period) {
            const instrument = this.setInstrument || this.instrument;
            const finetune = instrument && instrument.finetune || 0;
            this.setPeriod = note.period - finetune;
            this.setCurrentPeriod = true;
            this.setSampleIndex = 0;
        }

        this.effect(note);

        if (this.delayNote) return;

        if (this.setInstrument) {
            this.instrument = this.setInstrument;
        }

        if (this.setVolume !== false) {
            this.volume = this.setVolume;
            this.currentVolume = this.volume;
        }

        if (this.setPeriod) {
            this.period = this.setPeriod;
        }

        if (this.setCurrentPeriod) {
            this.currentPeriod = this.period;
        }

        if (this.setSampleIndex !== false) {
            this.sampleIndex = this.setSampleIndex;
        }
    }

    effect({hasEffect, effectId, effectData, effectHigh, effectLow}) {
        this.volumeSlide = 0;
        this.periodDelta = 0;
        this.portamento = false;
        this.vibrato = false;
        this.arpeggio = false;
        this.retrigger = false;
        this.delayNote = false;

        if (!hasEffect) return;

        switch (effectId) {
            case ARPEGGIO:
                this.arpeggio = [0, effectHigh, effectLow];
                break;
            case SLIDE_UP:
                this.periodDelta = -effectData;
                break;
            case SLIDE_DOWN:
                this.periodDelta = effectData;
                break;
            case TONE_PORTAMENTO:
                this.portamento = true;
                if (effectData) this.portamentoSpeed = effectData;
                this.periodDelta = this.portamentoSpeed;
                this.setCurrentPeriod = false;
                this.setSampleIndex = false;
                break;
            case VIBRATO:
                if (effectHigh) this.vibratoSpeed = effectHigh;
                if (effectLow) this.vibratoDepth = effectLow;
                this.vibrato = true;
                break;
            case TONE_PORTAMENTO_WITH_VOLUME_SLIDE:
                this.portamento = true;
                this.setCurrentPeriod = false;
                this.setSampleIndex = false;
                this.periodDelta = this.portamentoSpeed;
                if (effectHigh) this.volumeSlide = effectHigh;
                else if (effectLow) this.volumeSlide = -effectLow;
                break;
            case VIBRATO_WITH_VOLUME_SLIDE:
                this.vibrato = true;
                if (effectHigh) this.volumeSlide = effectHigh;
                else if (effectLow) this.volumeSlide = -effectLow;
                break;
            case VOLUME_SLIDE:
                if (effectHigh) this.volumeSlide = effectHigh;
                else if (effectLow) this.volumeSlide = -effectLow;
                break;
            case SAMPLE_OFFSET:
                this.setSampleIndex = effectData * 256;
                break;
            case SET_VOLUME:
                this.setVolume = effectData;
                break;
            case PATTERN_BREAK:
                const row = effectHigh * 10 + effectLow;
                this.worklet.setPatternBreak(row);
                break;
            case SET_SPEED:
                if (effectData >= 1 && effectData <= 31) {
                    this.worklet.setTicksPerRow(effectData);
                }
                else {
                    this.worklet.setBpm(effectData);
                }
                break;
            case RETRIGGER_NOTE:
                this.retrigger = effectData;
                break;
            case DELAY_NOTE:
                this.delayNote = effectData;
               break;
            default:
                if (!unimplementedEffects.has(effectId)) {
                    unimplementedEffects.add(effectId);
                    console.log(`Unimplemented effect ${effectId.toString(16)}`);
                }
                break;
        }
    }
}

class ModPlayerWorklet extends AudioWorkletProcessor {
    constructor() {
        super();
        this.port.onmessage = this.onmessage.bind(this);
        this.mod = null;
        this.channels = [ new Channel(this), new Channel(this), new Channel(this), new Channel(this) ];
        this.patternBreak = false;
        this.publishRow = false;
        this.publishStop = false;
    }

    onmessage(e) {
        switch (e.data.type) {
            case 'play':
                this.play(e.data.mod, e.data.sampleRate);
                break;
            case 'stop':
                this.stop();
                break;
            case 'resume':
                this.resume();
                break;
            case 'setRow':
                this.setRow(e.data.position, e.data.row);
                break;
            case 'enableRowSubscription':
                this.publishRow = true;
                break;
            case 'disableRowSubscription':
                this.publishRow = false;
                break;
            case 'enableStopSubscription':
                this.publishStop = true;
                break;
        }
    }

    play(mod, sampleRate) {
        this.mod = mod;
        this.sampleRate = sampleRate;

        this.setBpm(125);
        this.setTicksPerRow(6);

        // Start at the last tick of the pattern "before the first pattern"
        this.position = -1;
        this.rowIndex = 63;
        this.tick = 5;
        this.ticksPerRow = 6;

        // Immediately move to the first row of the first pattern
        this.outputsUntilNextTick = 0;
        this.playing = true;
    }

    stop() {
        this.playing = false;
    }

    resume() {
        this.playing = true;
    }

    setRow(position, row) {
        this.rowIndex = row - 1;
        if (this.rowIndex == -1) {
            this.rowIndex = 63;
            this.position = position - 1;
        }
        else {
            this.position = position;
        }
        this.tick = this.ticksPerRow - 1;
        this.outputsUntilNextTick = 0;
        this.patternBreak = false;
    }

    setTicksPerRow(ticksPerRow) {
        this.ticksPerRow = ticksPerRow;
    }

    setBpm(bpm) {
        this.bpm = bpm;
        this.outputsPerTick = this.sampleRate * 60 / this.bpm / 4 / 6;
        if ((bpm === 0) && this.publishStop) {
            this.port.postMessage({ type: 'stop' });
        }
    }

    setPatternBreak(row) {
        this.patternBreak = row;
    }

    nextRow() {
        ++this.rowIndex;
        if (this.patternBreak !== false) {
            this.rowIndex = this.patternBreak;
            ++this.position;
            this.patternBreak = false;
        }
        else if (this.rowIndex == 64) {
            this.rowIndex = 0;
            ++this.position;
        }
        
        if (this.position >= this.mod.length) {
            this.position = 0;
        }

        const patternIndex = this.mod.patternTable[this.position];
        const pattern = this.mod.patterns[patternIndex];
        const row = pattern.rows[this.rowIndex];
        if (!row) debugger;

        for (let i = 0; i < 4; ++i) {
            this.channels[i].play(row.notes[i]);
        }

        if (this.publishRow) {
            this.port.postMessage({
                type: 'row',
                position: this.position,
                rowIndex: this.rowIndex
            });
        }
    }

    nextTick() {
        ++this.tick;
        if (this.tick == this.ticksPerRow) {
            this.tick = 0;
            this.nextRow();
        }

        for (let i = 0; i < 4; ++i) {
            this.channels[i].performTick();
        }
    }

    nextOutput() {
        if (!this.mod) return 0.0;
        if (!this.playing) return 0.0;

        if (this.outputsUntilNextTick <= 0) {
            this.nextTick();
            this.outputsUntilNextTick += this.outputsPerTick;
        }

        this.outputsUntilNextTick--;

        const rawOutput = this.channels.reduce((acc, channel) => acc + channel.nextOutput(), 0.0);
        return Math.tanh(rawOutput);
    }

    process(inputs, outputs) {
        const output = outputs[0];
        const channel = output[0];

        for (let i = 0; i < channel.length; ++i) {
            const value = this.nextOutput();
            channel[i] = value;
        }

        return true;
    }
}

registerProcessor('mod-player-worklet', ModPlayerWorklet);