romdev-mcp 0.1.1

package/src/platforms/gba/lib/maxmod/include/mm_types.h

@@ -0,0 +1,333 @@
+/****************************************************************************
+ *                                                          __              *
+ *                ____ ___  ____ __  ______ ___  ____  ____/ /              *
+ *               / __ `__ \/ __ `/ |/ / __ `__ \/ __ \/ __  /               *
+ *              / / / / / / /_/ />  </ / / / / / /_/ / /_/ /                *
+ *             /_/ /_/ /_/\__,_/_/|_/_/ /_/ /_/\____/\__,_/                 *
+ *                                                                          *
+ *         Copyright (c) 2008, Mukunda Johnson (mukunda@maxmod.org)         *
+ *                                                                          *
+ * Permission to use, copy, modify, and/or distribute this software for any *
+ * purpose with or without fee is hereby granted, provided that the above   *
+ * copyright notice and this permission notice appear in all copies.        *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES *
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF         *
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR  *
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES   *
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN    *
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF  *
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.           *
+ ****************************************************************************/
+
+// TYPE DEFINITIONS
+
+#ifndef MM_TYPES_H
+#define MM_TYPES_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+typedef uint32_t		mm_word;	// 32 bits
+typedef uint16_t		mm_hword;	// 16 bits
+typedef  uint8_t		mm_byte;	// 8 bits
+
+typedef uint16_t		mm_sfxhand;	// sound effect handle
+
+typedef bool			mm_bool;	// boolean value
+
+typedef void*			mm_addr;	// pointer
+typedef void*			mm_reg;		// hardware register
+
+typedef enum
+{
+	MM_MODE_A,
+	MM_MODE_B,
+	MM_MODE_C
+} mm_mode_enum;
+
+typedef enum
+{
+	MM_STREAM_8BIT_MONO					= 0x0,	// 000b
+	MM_STREAM_8BIT_STEREO				= 0x1,	// 001b
+	
+	MM_STREAM_16BIT_MONO				= 0x2,	// 010b
+	MM_STREAM_16BIT_STEREO				= 0x3,	// 011b
+	
+//	MM_STREAM_ADPCM_MONO				= 0x4,	// 100b
+//	MM_STREAM_ADPCM_STEREO				= 0x5,	// 101b
+
+//	adpcm streaming is not supported by the ds hardware
+//	(the loop point data gets recorded so ring buffers are not possible)
+
+//-----------------------------------------------------------------------------
+} mm_stream_formats;
+//-----------------------------------------------------------------------------
+
+typedef mm_word (*mm_callback)( mm_word msg, mm_word param );
+typedef mm_word (*mm_stream_func)( mm_word length, mm_addr dest, mm_stream_formats format );
+
+typedef enum
+{
+	MMRF_MEMORY		=0x01,
+	MMRF_DELAY		=0x02,
+	MMRF_RATE		=0x04,
+	MMRF_FEEDBACK	=0x08,
+	MMRF_PANNING	=0x10,
+	MMRF_LEFT		=0x20,
+	MMRF_RIGHT		=0x40,
+	MMRF_BOTH		=0x60,
+	
+	MMRF_INVERSEPAN	=0x80,
+	MMRF_NODRYLEFT	=0x100,
+	MMRF_NODRYRIGHT	=0x200,
+	MMRF_8BITLEFT	=0x400,
+	MMRF_16BITLEFT	=0x800,
+	MMRF_8BITRIGHT	=0x1000,
+	MMRF_16BITRIGHT	=0x2000,
+	MMRF_DRYLEFT	=0x4000,
+	MMRF_DRYRIGHT	=0x8000
+//-----------------------------------------------------------------------------
+} mm_reverbflags;
+//-----------------------------------------------------------------------------
+
+typedef enum
+{
+	MMRC_LEFT = 1,
+	MMRC_RIGHT = 2,
+	MMRC_BOTH = 3
+//-----------------------------------------------------------------------------
+} mm_reverbch;
+//-----------------------------------------------------------------------------
+
+typedef struct mmreverbcfg
+{
+	mm_word				flags;
+	mm_addr				memory;
+	mm_hword			delay;
+	mm_hword			rate;
+	mm_hword			feedback;
+	mm_byte				panning;
+//-----------------------------------------------------------------------------
+} mm_reverb_cfg;
+//-----------------------------------------------------------------------------
+
+typedef enum
+{
+	MM_PLAY_LOOP,
+	MM_PLAY_ONCE
+//-----------------------------------------------------------------------------
+} mm_pmode;
+//-----------------------------------------------------------------------------
+
+typedef enum
+{
+	MM_MIX_8KHZ,
+	MM_MIX_10KHZ,
+	MM_MIX_13KHZ,
+	MM_MIX_16KHZ,
+	MM_MIX_18KHZ,
+	MM_MIX_21KHZ,
+	MM_MIX_27KHZ,
+	MM_MIX_31KHZ
+//-----------------------------------------------------------------------------
+} mm_mixmode;
+//-----------------------------------------------------------------------------
+
+typedef struct t_mmdssample
+{
+	mm_word		loop_start;
+	union {
+	mm_word		loop_length;
+	mm_word		length;
+	};
+	mm_byte		format;
+	mm_byte		repeat_mode;
+	mm_hword	base_rate;
+	mm_addr		data;
+//-----------------------------------------------------------------------------
+} mm_ds_sample;
+//-----------------------------------------------------------------------------
+
+typedef struct t_mmsoundeffect
+{
+	union {
+// sample ID (defined in soundbank header)
+	mm_word id;
+	
+// external sample address, not valid on GBA system
+	mm_ds_sample* sample;
+	};
+	
+// playback rate
+	mm_hword rate;
+	
+// sound handle
+	mm_sfxhand handle;
+	
+// volume, 0..255
+	mm_byte	volume;
+	
+// panning, 0..255
+	mm_byte	panning;
+	
+//-----------------------------------------------------------------------------
+} mm_sound_effect;
+//-----------------------------------------------------------------------------
+
+typedef struct t_mmgbasystem 
+{
+	mm_mixmode	mixing_mode;
+	mm_word		mod_channel_count;
+	mm_word		mix_channel_count;
+	mm_addr		module_channels;
+	mm_addr		active_channels;
+	mm_addr		mixing_channels;
+	mm_addr		mixing_memory;
+	mm_addr		wave_memory;
+	mm_addr		soundbank;
+//-----------------------------------------------------------------------------
+} mm_gba_system;
+//-----------------------------------------------------------------------------
+
+typedef struct t_mmdssystem
+{
+
+// give MSL_NSONGS
+	mm_word		mod_count;
+
+// pass MSL_NSAMPS
+	mm_word		samp_count;
+	
+// pass pointer to memory buffer
+// (mm_word mem_bank[MSL_BANKSIZE])
+	mm_addr		mem_bank;
+	
+// fifo channel to use (usually 7)
+	mm_word		fifo_channel;
+
+//-----------------------------------------------------------------------------	
+} mm_ds_system;
+//-----------------------------------------------------------------------------
+
+// Compatibility
+#define MM_TIMER0 0
+#define MM_TIMER1 0
+#define MM_TIMER2 0
+#define MM_TIMER3 0
+
+typedef struct t_mmstream
+{	
+// sampling rate. 1024->32768 (HZ)
+	mm_word sampling_rate;
+	
+// number of samples to buffer
+	mm_word buffer_length;
+	
+// pointer to filling routine
+	mm_stream_func callback;
+
+// stream format (mm_stream_formats)
+	mm_word format;
+
+// thread stack size (0 = default)
+union {
+	mm_word thread_stack_size;
+	mm_word timer; // for compatibility
+};
+
+// if positive, no thread is created and user must call mmStreamUpdate manually
+// if zero or negative, maxmod creates a thread that calls it automatically
+//   if zero: thread priority is default
+//   if negative: thread priority is user-specified (absolute value)
+union {
+	mm_bool manual; // for compatibility
+	int8_t minus_thread_prio;
+};
+
+//-----------------------------------------------------------------------------
+} mm_stream;
+//-----------------------------------------------------------------------------
+
+typedef struct t_mmlayer
+{
+
+// current tick count
+	mm_byte	tick;
+
+// current row being played
+	mm_byte	row;
+	
+// module sequence position
+	mm_byte	position;
+	
+// number of rows in current pattern
+	mm_byte	nrows;
+
+// global volume multiplier
+	mm_byte	global_volume;
+
+// speed of module (ticks/row)
+	mm_byte	speed;
+
+// module is active
+	mm_byte	active;
+
+// tempo of module
+	mm_byte	bpm;
+
+//-----------------------------------------------------------------------------
+} mm_modlayer;
+//-----------------------------------------------------------------------------
+
+typedef struct tmm_voice
+{
+
+// data source information
+	mm_addr		source;		// address to sample data
+	mm_word		length;		// length of sample data OR loop length (expressed in WORDS)
+	mm_hword	loop_start;	// loop start position (expressed in WORDS)
+
+// frequency divider
+	mm_hword	timer;
+
+// update flags
+	mm_byte		flags;
+
+// source format
+	mm_byte		format;		// 0: 8-bit
+							// 1: 16-bit
+							// 2: adpcm
+// repeat mode
+	mm_byte		repeat;		// 0: manual
+							// 1: forward loop
+							// 2: one shot
+
+// volume + divider setting
+	mm_byte		volume;		// 0->127
+	mm_byte		divider;	// 0->3 = /1, /2, /4, /16
+
+// panning setting
+	mm_byte		panning;	// 0->127
+
+// index of voice
+	mm_byte		index;		// 0->15
+
+// pad to 20 bytes
+	mm_byte		reserved[1];
+
+//-----------------------------------------------------------------------------
+} mm_voice;
+//-----------------------------------------------------------------------------
+
+enum {
+	MMVF_FREQ		=2,		// update frequency when this flag is set
+	MMVF_VOLUME		=4,		// update volume
+	MMVF_PANNING	=8,		// update panning
+	MMVF_SOURCE		=16,	// update source and start note
+	MMVF_STOP		=32		// stop voice (cut sound)
+};
+
+//-----------------------------------------------------------------------------
+
+#endif

package/src/platforms/gba/lib/maxmod/maxmod.seed.hash

@@ -0,0 +1 @@
+072bdc9c529f4dad1757fd849117f7cb1ea07804e72868c2a63abd00d55e0c89

package/src/platforms/gba/lib/maxmod/music/chiptune_soundbank.h

@@ -0,0 +1,4 @@
+#define MOD_CHIPTUNE	0
+#define MSL_NSONGS	1
+#define MSL_NSAMPS	1
+#define MSL_BANKSIZE	2

package/src/platforms/gba/lib/maxmod/music/make_chiptune_xm.js

@@ -0,0 +1,203 @@
+// make_chiptune_xm.js — Hand-authored CC0 chiptune XM generator.
+//
+// Produces `chiptune.xm` — a tiny Fasttracker II module with a single
+// square-wave instrument playing a four-note arpeggio loop. The
+// output is the canonical input to mmutil (Maxmod's host converter):
+//
+//   mmutil chiptune.xm -ochiptune_soundbank.bin -hchiptune_soundbank.h
+//
+// Author/license: romdev project — released CC0 / public domain.
+// No third-party tracker modules; everything in this file is generated
+// from primitives so the soundbank ships without attribution baggage.
+//
+// XM format reference: ftp://ftp.modland.com/pub/documents/format_documentation/FastTracker%202%20v2.04%20(.xm).html
+//
+// Run with: node make_chiptune_xm.js   (writes chiptune.xm next to this file)
+
+import { writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// ── Helpers ─────────────────────────────────────────────────────────
+const u8  = (n) => new Uint8Array([n & 0xff]);
+const u16 = (n) => new Uint8Array([n & 0xff, (n >> 8) & 0xff]);
+const u32 = (n) => new Uint8Array([n & 0xff, (n >> 8) & 0xff, (n >> 16) & 0xff, (n >> 24) & 0xff]);
+const padStr = (s, len) => {
+  const buf = new Uint8Array(len);
+  for (let i = 0; i < s.length && i < len; i++) buf[i] = s.charCodeAt(i);
+  return buf;
+};
+const concat = (...parts) => {
+  const total = parts.reduce((n, p) => n + p.length, 0);
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const p of parts) { out.set(p, off); off += p.length; }
+  return out;
+};
+
+// ── XM file structure ───────────────────────────────────────────────
+// Header (60 bytes — fixed)
+const id      = padStr("Extended Module: ", 17);    // 17 bytes "Extended Module: "
+const title   = padStr("romdev chiptune    ", 20);  // 20-byte title
+const marker  = u8(0x1a);                            // EOF marker
+const tracker = padStr("romdev              ", 20); // 20-byte tracker name
+const version = u16(0x0104);                         // version 1.04
+
+// Module header (starts at offset 60)
+const headerSize = u32(20 + 256);    // size of THIS struct minus its own 4-byte length = 276
+const songLength = u16(1);            // 1 entry in pattern order
+const restartPos = u16(0);
+const numChans   = u16(2);            // 2 channels (keeps things tiny)
+const numPats    = u16(1);            // 1 pattern
+const numInsts   = u16(1);            // 1 instrument
+const flags      = u16(1);            // bit 0 = linear freq table (Amiga = 0)
+const tempo      = u16(6);            // ticks per row
+const bpm        = u16(125);          // BPM
+const order      = new Uint8Array(256); // pattern order table — entry 0 = pattern 0; rest = 0 (unused but required)
+
+const moduleHeader = concat(headerSize, songLength, restartPos, numChans, numPats, numInsts, flags, tempo, bpm, order);
+
+// ── Pattern 0 ───────────────────────────────────────────────────────
+// 16 rows × 2 channels. Channel 0 plays a 4-note arpeggio every 4 rows.
+// Channel 1 plays a single sustained bass note that retriggers each loop.
+const numRows = 16;
+
+// Use packed note format (high bit set indicates packing).
+// Packing byte: bit7=1, bit0=note present, bit1=instrument, bit2=volume,
+// bit3=effect type, bit4=effect param.
+// Note values: 1..96 = C-0..B-7; XM stores note number where 49 = A-4 (440 Hz).
+// We use C-5=61, E-5=65, G-5=68, C-6=73 for ch0 melody; C-4=49 for ch1 bass.
+
+function noteCell(note, inst) {
+  // note + instrument only (no volume, no effect)
+  if (note === 0 && inst === 0) {
+    // empty cell → write packing byte 0x80 (no fields follow)
+    return u8(0x80);
+  }
+  return new Uint8Array([0x80 | 0x01 | 0x02, note, inst]);
+}
+
+const melody = [61, 0, 0, 0, 65, 0, 0, 0, 68, 0, 0, 0, 73, 0, 0, 0]; // 16 rows ch0
+const bass   = [49, 0, 0, 0,  0, 0, 0, 0,  0, 0, 0, 0,  0, 0, 0, 0]; // ch1 only retrig row 0
+
+const patternBodyParts = [];
+for (let row = 0; row < numRows; row++) {
+  patternBodyParts.push(noteCell(melody[row], melody[row] ? 1 : 0));
+  patternBodyParts.push(noteCell(bass[row],   bass[row]   ? 1 : 0));
+}
+const patternBody = concat(...patternBodyParts);
+
+const patternHeaderSize = u32(9);
+const patternPackingType = u8(0);
+const patternRowsField = u16(numRows);
+const patternDataSize = u16(patternBody.length);
+
+const pattern = concat(patternHeaderSize, patternPackingType, patternRowsField, patternDataSize, patternBody);
+
+// ── Instrument 1 ────────────────────────────────────────────────────
+// 8-bit signed square wave, 64 samples per period @ ~1 kHz at C-4.
+// Sample length 256 bytes (4 periods) — looped.
+// XM stores 8-bit signed sample data as delta-encoded.
+
+const SAMPLE_LEN = 256;
+const sampleRaw = new Int8Array(SAMPLE_LEN);
+for (let i = 0; i < SAMPLE_LEN; i++) {
+  // Square wave: 50% duty. Volume ~70/127 to avoid clipping in mixer.
+  sampleRaw[i] = (i % 64) < 32 ? 70 : -70;
+}
+// Delta encode (XM format stores deltas, not absolute values).
+const sampleDelta = new Int8Array(SAMPLE_LEN);
+let prev = 0;
+for (let i = 0; i < SAMPLE_LEN; i++) {
+  const delta = sampleRaw[i] - prev;
+  // Int8 wraparound is fine — mmutil + every XM player decodes via cumulative sum.
+  sampleDelta[i] = delta;
+  prev = sampleRaw[i];
+}
+const sampleBytes = new Uint8Array(sampleDelta.buffer, sampleDelta.byteOffset, sampleDelta.byteLength);
+
+// Instrument header — XM splits this into two parts:
+//
+//  (1) "Instrument header size" (4 bytes) + outer header (name, type,
+//      num samples). If numSamples > 0 the extended header follows.
+//  (2) Extended header (sample header size, keymap, env, volume etc.)
+//  (3) Per-sample headers (40 bytes each).
+//  (4) All sample data concatenated.
+
+// We use the modern "full" instrument header — total 263 bytes.
+const INST_HEADER_SIZE = 263;       // size of (1)+(2) together
+const SAMPLE_HEADER_SIZE = 40;
+
+const instHeaderSize  = u32(INST_HEADER_SIZE);
+const instName        = padStr("square              ", 22);
+const instType        = u8(0);
+const instNumSamples  = u16(1);
+
+// Extended part
+const sampleHeaderSizeField = u32(SAMPLE_HEADER_SIZE);
+const sampleNumForNotes = new Uint8Array(96); // all zero → all notes use sample 0
+const volEnvPoints    = new Uint8Array(48);   // empty envelope (24 points × 2 u16)
+const panEnvPoints    = new Uint8Array(48);
+const volEnvCount     = u8(0);
+const panEnvCount     = u8(0);
+const volSustain      = u8(0);
+const volLoopStart    = u8(0);
+const volLoopEnd      = u8(0);
+const panSustain      = u8(0);
+const panLoopStart    = u8(0);
+const panLoopEnd      = u8(0);
+const volType         = u8(0);  // bit0=on → off
+const panType         = u8(0);
+const vibType         = u8(0);
+const vibSweep        = u8(0);
+const vibDepth        = u8(0);
+const vibRate         = u8(0);
+const volFadeout      = u16(0);
+const reserved        = new Uint8Array(22);
+
+const instHeader = concat(
+  instHeaderSize, instName, instType, instNumSamples,
+  sampleHeaderSizeField, sampleNumForNotes,
+  volEnvPoints, panEnvPoints,
+  volEnvCount, panEnvCount,
+  volSustain, volLoopStart, volLoopEnd,
+  panSustain, panLoopStart, panLoopEnd,
+  volType, panType,
+  vibType, vibSweep, vibDepth, vibRate,
+  volFadeout, reserved,
+);
+if (instHeader.length !== INST_HEADER_SIZE) {
+  throw new Error(`instrument header size mismatch: got ${instHeader.length}, expected ${INST_HEADER_SIZE}`);
+}
+
+// Sample header (40 bytes)
+const sampleLength    = u32(SAMPLE_LEN);
+const sampleLoopStart = u32(0);
+const sampleLoopLength= u32(SAMPLE_LEN);     // forward loop the whole sample
+const sampleVolume    = u8(64);              // max
+const sampleFinetune  = u8(0);
+const sampleTypeByte  = u8(1);               // bit0-1 = loop type 01 (forward); bit4=16bit (off, we use 8-bit)
+const samplePanning   = u8(128);             // center
+const sampleRelativeNote = u8(0);            // play at default pitch
+const samplePackingByte  = u8(0);            // 0 = uncompressed delta
+const sampleName      = padStr("square              ", 22);
+
+const sampleHeader = concat(
+  sampleLength, sampleLoopStart, sampleLoopLength,
+  sampleVolume, sampleFinetune, sampleTypeByte, samplePanning,
+  sampleRelativeNote, samplePackingByte, sampleName,
+);
+if (sampleHeader.length !== SAMPLE_HEADER_SIZE) {
+  throw new Error(`sample header size mismatch: got ${sampleHeader.length}, expected ${SAMPLE_HEADER_SIZE}`);
+}
+
+const instrument = concat(instHeader, sampleHeader, sampleBytes);
+
+// ── Assemble file ───────────────────────────────────────────────────
+const xm = concat(id, title, marker, tracker, version, moduleHeader, pattern, instrument);
+
+const outPath = join(__dirname, "chiptune.xm");
+writeFileSync(outPath, xm);
+console.log(`wrote ${outPath} (${xm.length} bytes)`);