mirror of
https://github.com/curioustorvald/tsvm.git
synced 2026-06-20 19:24:04 +09:00
380 lines
16 KiB
JavaScript
380 lines
16 KiB
JavaScript
// monplay.js -- Monotone (.mon) music player for the built-in beeper.
|
|
//
|
|
// Reads a MONOTONE module and renders it, on the fly, to the beeper
|
|
// (IOSpace MMIO 93..97). All eight Monotone note effects are supported.
|
|
// The module's simultaneous voices are multiplexed onto the beeper's
|
|
// hardware arpeggio; when the notes fall outside what the hardware
|
|
// arpeggiator can express, the multiplex is done in software instead.
|
|
//
|
|
// usage: monplay <file.mon> (Ctrl+Shift+T+R or the Stop key to stop)
|
|
//
|
|
// Engine ported from reference_materials/MONOTONE/MTSRC/MT_PLAY.PAS;
|
|
// format from reference_materials/monotone-tracker-parser-lua/ .
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Beeper hardware (IOSpace). MMIO byte m is reached at JS address -(m+1):
|
|
// 93 RO -> reading uploads the staged command (the strobe)
|
|
// 94..97 -> PPPPPPPP / pppppp_QQ / AAAAAAAA / BBBBBBBB
|
|
// The square wave is f = (3579545/16) / (2 * divider); divider 0 = silence.
|
|
// ---------------------------------------------------------------------------
|
|
const BEEP_UPLOAD = -94 // read MMIO 93 to upload
|
|
const BEEP_P_HI = -95 // MMIO 94: PPPPPPPP
|
|
const BEEP_P_LO = -96 // MMIO 95: pppppp_QQ
|
|
const BEEP_A = -97 // MMIO 96: A
|
|
const BEEP_B = -98 // MMIO 97: B
|
|
|
|
const BEEP_HALFCLOCK = 3579545 / 16 / 2 // f = BEEP_HALFCLOCK / divider
|
|
const DIVIDER_MAX = 0x3FFF // 14-bit
|
|
|
|
const QQ_NONE = 0, QQ_TWO = 2, QQ_THREE = 3 // beeper note-effect (QQ field)
|
|
|
|
function uploadBeeper(divider, effect, a, b) {
|
|
if (divider < 0) divider = 0
|
|
if (divider > DIVIDER_MAX) divider = DIVIDER_MAX
|
|
sys.poke(BEEP_P_HI, (divider >> 6) & 0xFF)
|
|
sys.poke(BEEP_P_LO, ((divider & 0x3F) << 2) | (effect & 3))
|
|
sys.poke(BEEP_A, a & 0xFF)
|
|
sys.poke(BEEP_B, b & 0xFF)
|
|
sys.peek(BEEP_UPLOAD) // strobe: commit the staged command
|
|
}
|
|
function silenceBeeper() { uploadBeeper(0, QQ_NONE, 0, 0) }
|
|
|
|
// Hz -> beeper frequency divider.
|
|
function freqToDivider(hz) {
|
|
if (hz <= 0) return 0
|
|
let d = Math.round(BEEP_HALFCLOCK / hz)
|
|
if (d < 1) d = 1
|
|
if (d > DIVIDER_MAX) d = DIVIDER_MAX
|
|
return d
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// MONOTONE pitch tables (MT_PLAY.PAS constants)
|
|
// ---------------------------------------------------------------------------
|
|
const IBO = 12 // intervals between octaves (semitones)
|
|
const IBN = 8 // sub-intervals between notes (for vibrato/porta)
|
|
const MAX_NOTE = 100 // 3 + numOctaves(8)*12 + 1
|
|
const MAX_INTERVAL = MAX_NOTE * IBN
|
|
const NOTE_OFF = 127 // noteEnd
|
|
const MIN_HZ = 20 // slide-down floor (20 + MTV1MinParmxx)
|
|
const MAX_HZ = 65472 // slide-up ceiling (65535 - MTV1MaxParmxx)
|
|
const VIB_SIZE = 32 // MTV1VibTableSize
|
|
const VIB_DEPTH = 64 // MTV1VibTableDepth = IBN*(MTV1MaxParmxy+1)
|
|
|
|
// notesHz[interval] -- the exact integer-Hz table MT_PLAY.PAS builds (A0 == 27.5 Hz
|
|
// at interval IBN), so slides/porta operate on the same rounded Hz values.
|
|
const NOTESHZ = (() => {
|
|
const t = new Array(MAX_INTERVAL + 1)
|
|
const mult = Math.pow(2, 1 / (IBO * IBN)) // 2^(1/96)
|
|
t[0] = 440
|
|
let hz = 27.5; t[IBN] = Math.round(hz)
|
|
for (let i = IBN - 1; i >= 1; i--) { hz /= mult; if (hz < 19) hz = 19; t[i] = Math.round(hz) }
|
|
hz = 27.5; t[IBN] = Math.round(hz)
|
|
for (let i = IBN + 1; i <= MAX_INTERVAL; i++) { hz *= mult; t[i] = Math.round(hz) }
|
|
return t
|
|
})()
|
|
|
|
// 32-entry signed sine, amplitude VIB_DEPTH, one full cycle (sinPeriod == 1).
|
|
const VIBTABLE = (() => {
|
|
const v = new Array(VIB_SIZE)
|
|
for (let b = 0; b < VIB_SIZE; b++) v[b] = Math.round(VIB_DEPTH * Math.sin(b * Math.PI / VIB_SIZE * 2))
|
|
return v
|
|
})()
|
|
|
|
const clampInterval = (i) => (i < 0) ? 0 : (i > MAX_INTERVAL) ? MAX_INTERVAL : i
|
|
const noteHz = (note) => NOTESHZ[clampInterval(note * IBN)]
|
|
const intervalHz = (interval) => NOTESHZ[clampInterval(interval)]
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Voice multiplexing
|
|
//
|
|
// The hardware arpeggio plays note0 then note0 minus a positive offset, so the
|
|
// base divider must be the LARGEST (lowest pitch) and the others are reached by
|
|
// subtraction. Returns either a single hardware command {sw:false, cmd:[...]}
|
|
// or, when the notes don't fit, a software-arpeggio plan {sw:true, dividers:[...]}.
|
|
// 1 note -> effect 0
|
|
// 2 notes -> effect 2 (16-bit delta: always expressible)
|
|
// 3 notes -> effect 3 (two 8-bit deltas: only when both <= 255)
|
|
// otherwise (3 wide / 4+ voices) -> software arpeggio over ALL the notes
|
|
// ---------------------------------------------------------------------------
|
|
function planMultiplex(dividers) {
|
|
const ds = Array.from(new Set(dividers)).sort((x, y) => y - x) // descending
|
|
|
|
if (ds.length === 0) return { sw: false, cmd: [0, QQ_NONE, 0, 0] }
|
|
if (ds.length === 1) return { sw: false, cmd: [ds[0], QQ_NONE, 0, 0] }
|
|
if (ds.length === 2) {
|
|
const diff = ds[0] - ds[1]
|
|
return { sw: false, cmd: [ds[0], QQ_TWO, diff & 0xFF, (diff >> 8) & 0xFF] }
|
|
}
|
|
if (ds.length === 3) {
|
|
const a = ds[0] - ds[1], b = ds[1] - ds[2]
|
|
if (a <= 0xFF && b <= 0xFF) return { sw: false, cmd: [ds[0], QQ_THREE, a, b] }
|
|
}
|
|
return { sw: true, dividers: ds } // out of hardware range -> software
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Human-readable trace (one beeper command per tick)
|
|
// ---------------------------------------------------------------------------
|
|
const NOTE_NAMES = ["A", "A#", "B", "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#"]
|
|
function freqToNote(hz) {
|
|
if (hz <= 0) return "---"
|
|
const n = Math.round(12 * Math.log2(hz / 27.5)) // semitones above A0 (27.5 Hz)
|
|
return NOTE_NAMES[((n % 12) + 12) % 12] + Math.floor((n + 9) / 12)
|
|
}
|
|
const fmtNote = (div) => {
|
|
// const hz = (div > 0) ? Math.round(BEEP_HALFCLOCK / div) : 0
|
|
// return `${freqToNote(hz)}(${hz}Hz)`
|
|
return ' ' + (''+div).padStart(5) + ' '
|
|
}
|
|
|
|
// The notes a (hardware) beeper command actually cycles through.
|
|
function playedDividers(div, effect, a, b) {
|
|
if (div === 0) return []
|
|
if (effect === QQ_TWO) return [div, div - ((b << 8) | a)]
|
|
if (effect === QQ_THREE) return [div, div - a, div - a - b]
|
|
return [div]
|
|
}
|
|
|
|
// One human-readable line for the command uploaded this tick. swInfo, when set,
|
|
// describes the software-arpeggio rotation: {idx, n, all:[dividers]}.
|
|
function describeCommand(cmd, swInfo) {
|
|
const div = cmd[0], eff = cmd[1], a = cmd[2], b = cmd[3]
|
|
if (swInfo) {
|
|
const notes = swInfo.all.map((d, i) => (i === swInfo.idx) ? `[${fmtNote(d).substring(1,6)}]` : fmtNote(d)).join(" ")
|
|
return `sw${swInfo.idx + 1}/${swInfo.n}`.padEnd(6) + " " + notes
|
|
}
|
|
if (div === 0) return "silent"
|
|
const label = (eff === QQ_THREE) ? "arp3" : (eff === QQ_TWO) ? "arp2" : "tone"
|
|
return label.padEnd(6) + " " + playedDividers(div, eff, a, b).map(fmtNote).join(" ")
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Load and parse the .mon file
|
|
// ---------------------------------------------------------------------------
|
|
const pathArg = exec_args[1]
|
|
if (!pathArg) {
|
|
println("usage: monplay <file.mon>")
|
|
return 1
|
|
}
|
|
|
|
const full = _G.shell.resolvePathInput(pathArg).full
|
|
const FILE_LENGTH = files.open(full).size
|
|
|
|
const seqread = require("seqread")
|
|
seqread.prepare(full)
|
|
const buf = seqread.readBytes(FILE_LENGTH)
|
|
const B = (off) => sys.peek(buf + off) & 255 // byte at file offset
|
|
|
|
// magic: 0x08 "MONOTONE"
|
|
const MAGIC = [0x08, 0x4D, 0x4F, 0x4E, 0x4F, 0x54, 0x4F, 0x4E, 0x45]
|
|
if (!MAGIC.every((m, i) => B(i) === m)) {
|
|
println("Not a MONOTONE file: " + full)
|
|
sys.free(buf)
|
|
return 1
|
|
}
|
|
|
|
const SONG_LEN = B(0x5C) // number of orders (informational)
|
|
const VOICES = B(0x5D)
|
|
if (VOICES < 1 || VOICES > 12) {
|
|
println("Bad voice count: " + VOICES)
|
|
sys.free(buf)
|
|
return 1
|
|
}
|
|
|
|
// Order list: 0x5F.. , 0xFF-terminated (max 256 entries).
|
|
const orders = []
|
|
for (let i = 0; i < 256; i++) {
|
|
const p = B(0x5F + i)
|
|
if (p === 0xFF) break
|
|
orders.push(p)
|
|
}
|
|
|
|
// Pattern data: 64 rows x VOICES x 2 bytes, voice-interleaved, little-endian,
|
|
// stored sequentially from 0x15F regardless of the order list.
|
|
const PATTERN_ROWS = 0x40
|
|
const PATTERN_BASE = 0x15F
|
|
const PATTERN_SIZE = PATTERN_ROWS * 2 * VOICES
|
|
const cellWord = (pattern, row, voice) => {
|
|
const off = PATTERN_BASE + pattern * PATTERN_SIZE + (row * VOICES + voice) * 2
|
|
return B(off) | (B(off + 1) << 8)
|
|
}
|
|
|
|
// MT_PLAY.PAS: 60 Hz tick, default tempo (ticks/row) = max(voices, 4).
|
|
const TICK_HZ = 60
|
|
const TICK_NANO = 1e9 / TICK_HZ
|
|
const DEFAULT_TEMPO = Math.max(VOICES, 4)
|
|
|
|
println(`MONOTONE: ${full}`)
|
|
println(` voices ${VOICES}, orders ${orders.length} (songlen ${SONG_LEN}), ` +
|
|
`${DEFAULT_TEMPO} ticks/row @ ${TICK_HZ}Hz`)
|
|
println(" (Hold backspace to stop)")
|
|
println(" tick pos beeper command (one tick per line)")
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Per-voice playback state
|
|
// ---------------------------------------------------------------------------
|
|
const voiceOn = new Array(VOICES).fill(false) // is the voice sounding?
|
|
const voiceNote = new Array(VOICES).fill(0) // held note index (1..MAX_NOTE)
|
|
const voiceFreq = new Array(VOICES).fill(0) // current frequency (integer Hz)
|
|
const voiceEff = new Array(VOICES).fill(0) // effect type 0..7
|
|
const voiceP1 = new Array(VOICES).fill(0) // first effect arg
|
|
const voiceP2 = new Array(VOICES).fill(0) // second effect arg (two-arg effects)
|
|
const portaTarget = new Array(VOICES).fill(0) // 3xx: frequency to slide toward
|
|
const portaDelta = new Array(VOICES).fill(0) // 3xx: Hz per tick
|
|
const vibSpeed = new Array(VOICES).fill(0) // 4xy: oscillation speed
|
|
const vibDepth = new Array(VOICES).fill(0) // 4xy: depth (intervals)
|
|
const vibIndex = new Array(VOICES).fill(0) // 4xy: vibrato table position
|
|
|
|
// Effect indices (eff>>6): 0=Arp 1=SlideUp 2=SlideDown 3=Porta 4=Vibrato
|
|
// 5=PosJump(B) 6=PatBreak(D) 7=SetSpeed(F)
|
|
const EFF_ARP = 0, EFF_UP = 1, EFF_DOWN = 2, EFF_PORTA = 3, EFF_VIB = 4
|
|
const EFF_JUMP = 5, EFF_BREAK = 6, EFF_SPEED = 7
|
|
|
|
// Latch a new row of cells (the "tick 0" pass). Sets the per-voice note/effect and
|
|
// returns the row's global control: tempo (Fxx), jumpOrder (Bxx), breakRow (Dxx).
|
|
function applyRow(pattern, row) {
|
|
const ctrl = { tempo: -1, jumpOrder: -1, breakRow: -1 }
|
|
|
|
for (let v = 0; v < VOICES; v++) {
|
|
const w = cellWord(pattern, row, v)
|
|
const note = w >> 9
|
|
const effWord = w & 0x1FF
|
|
const eff = effWord >> 6
|
|
|
|
// two-arg effects (Arp, Vibrato) carry x=(bits5..3), y=(bits2..0);
|
|
// all others carry one 6-bit arg.
|
|
let p1, p2
|
|
if (eff === EFF_ARP || eff === EFF_VIB) { p1 = (effWord >> 3) & 7; p2 = effWord & 7 }
|
|
else { p1 = effWord & 0x3F; p2 = 0 }
|
|
voiceEff[v] = eff; voiceP1[v] = p1; voiceP2[v] = p2
|
|
|
|
// Note handling. Porta (3xx) keeps the old frequency: the note only sets
|
|
// the slide target, it doesn't jump the pitch.
|
|
if (note === NOTE_OFF) voiceOn[v] = false
|
|
else if (note >= 1 && note <= MAX_NOTE && eff !== EFF_PORTA) {
|
|
voiceOn[v] = true; voiceNote[v] = note; voiceFreq[v] = noteHz(note); vibIndex[v] = 0
|
|
}
|
|
// note === 0 (or out-of-range) -> continue holding
|
|
|
|
// Tick-0 effect setup
|
|
switch (eff) {
|
|
case EFF_PORTA:
|
|
if (note >= 1 && note <= MAX_NOTE) portaTarget[v] = noteHz(note)
|
|
if (p1 !== 0) portaDelta[v] = p1
|
|
break
|
|
case EFF_VIB:
|
|
if (p1 !== 0) vibSpeed[v] = p1
|
|
if (p2 !== 0) vibDepth[v] = p2
|
|
vibIndex[v] = (vibIndex[v] + vibSpeed[v]) & (VIB_SIZE - 1)
|
|
break
|
|
case EFF_JUMP: ctrl.jumpOrder = p1; break
|
|
case EFF_BREAK: ctrl.breakRow = p1; break
|
|
case EFF_SPEED: ctrl.tempo = p1; break
|
|
}
|
|
}
|
|
return ctrl
|
|
}
|
|
|
|
// Apply a voice's effect for tick t (t >= 1; tick 0 is the note load above).
|
|
function applyTickEffects(v, t) {
|
|
switch (voiceEff[v]) {
|
|
case EFF_ARP:
|
|
if (voiceP1[v] !== 0 || voiceP2[v] !== 0) {
|
|
const phase = t % 3
|
|
const off = (phase === 1) ? voiceP1[v] : (phase === 2) ? voiceP2[v] : 0
|
|
voiceFreq[v] = noteHz(voiceNote[v] + off)
|
|
}
|
|
break
|
|
case EFF_UP:
|
|
voiceFreq[v] = Math.min(MAX_HZ, voiceFreq[v] + voiceP1[v])
|
|
break
|
|
case EFF_DOWN:
|
|
voiceFreq[v] = Math.max(MIN_HZ, voiceFreq[v] - voiceP1[v])
|
|
break
|
|
case EFF_PORTA:
|
|
if (voiceFreq[v] < portaTarget[v]) voiceFreq[v] = Math.min(portaTarget[v], voiceFreq[v] + portaDelta[v])
|
|
else if (voiceFreq[v] > portaTarget[v]) voiceFreq[v] = Math.max(portaTarget[v], voiceFreq[v] - portaDelta[v])
|
|
break
|
|
case EFF_VIB: {
|
|
vibIndex[v] = (vibIndex[v] + vibSpeed[v]) & (VIB_SIZE - 1)
|
|
const off = Math.trunc(VIBTABLE[vibIndex[v]] * vibDepth[v] / VIB_DEPTH)
|
|
voiceFreq[v] = intervalHz(voiceNote[v] * IBN + off)
|
|
break
|
|
}
|
|
// EFF_JUMP / EFF_BREAK / EFF_SPEED are tick-0 only
|
|
}
|
|
}
|
|
|
|
const sleepUntil = (nano) => { const ms = (nano - sys.nanoTime()) / 1e6; if (ms >= 1) sys.sleep(Math.floor(ms)) }
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Render loop
|
|
// ---------------------------------------------------------------------------
|
|
let nextTick = sys.nanoTime()
|
|
let swPhase = 0 // software-arpeggio rotation (persists across ticks)
|
|
let globalTick = 0 // running tick counter (for the trace)
|
|
let ticksPerRow = DEFAULT_TEMPO
|
|
let stopReq = false
|
|
const checkStop = () => {
|
|
if ((sys.peek(-49) & 1) !== 0) stopReq = true // MMIO 48 bit0 = SIGTERM
|
|
else if (con.poll_keys()[0] === 67) stopReq = true // Stop key
|
|
return stopReq
|
|
}
|
|
|
|
try {
|
|
let o = 0
|
|
let startRow = 0
|
|
while (o < orders.length && !stopReq) {
|
|
const pattern = orders[o]
|
|
let nextOrder = o + 1, nextStartRow = 0, branched = false
|
|
|
|
for (let row = startRow; row < PATTERN_ROWS && !stopReq; row++) {
|
|
const ctrl = applyRow(pattern, row)
|
|
if (ctrl.tempo >= 0) ticksPerRow = Math.max(ctrl.tempo, 1) // Fxx
|
|
|
|
for (let t = 0; t < ticksPerRow; t++) {
|
|
if (checkStop()) break
|
|
if (t > 0) for (let v = 0; v < VOICES; v++) applyTickEffects(v, t)
|
|
|
|
const dividers = []
|
|
for (let v = 0; v < VOICES; v++) if (voiceOn[v]) dividers.push(freqToDivider(voiceFreq[v]))
|
|
|
|
const plan = planMultiplex(dividers)
|
|
let cmd, swInfo = null
|
|
if (plan.sw) {
|
|
const idx = swPhase % plan.dividers.length
|
|
cmd = [plan.dividers[idx], QQ_NONE, 0, 0]
|
|
swInfo = { idx: idx, n: plan.dividers.length, all: plan.dividers }
|
|
swPhase++
|
|
} else {
|
|
cmd = plan.cmd
|
|
}
|
|
uploadBeeper(cmd[0], cmd[1], cmd[2], cmd[3])
|
|
|
|
println(`${String(globalTick).padStart(6, '0')} ` +
|
|
`c${String(o).padStart(2)} r${String(row).padStart(2)} t${String(t).padStart(2)} ` +
|
|
describeCommand(cmd, swInfo))
|
|
globalTick++
|
|
|
|
nextTick += TICK_NANO
|
|
sleepUntil(nextTick)
|
|
}
|
|
|
|
if (ctrl.jumpOrder >= 0) { nextOrder = ctrl.jumpOrder; nextStartRow = 0; branched = true; break } // Bxx
|
|
if (ctrl.breakRow >= 0) { nextOrder = o + 1; nextStartRow = ctrl.breakRow; branched = true; break } // Dxx
|
|
}
|
|
|
|
// Bxx/Dxx wrap past the end of the order list (looping); a natural fall-off ends the song.
|
|
if (nextOrder >= orders.length) { if (!branched) break; nextOrder = 0 }
|
|
o = nextOrder
|
|
startRow = (nextStartRow >= PATTERN_ROWS) ? 0 : nextStartRow
|
|
}
|
|
}
|
|
finally {
|
|
silenceBeeper()
|
|
sys.free(buf)
|
|
}
|
|
|
|
return 0
|