spessasynth_core 1.1.3 → 1.1.4

package/src/soundfont/basic_soundfont/basic_soundfont.js

@@ -0,0 +1,565 @@
+import {
+    SpessaSynthGroup,
+    SpessaSynthGroupCollapsed,
+    SpessaSynthGroupEnd,
+    SpessaSynthInfo,
+    SpessaSynthWarn
+} from "../../utils/loggin.js";
+import { consoleColors } from "../../utils/other.js";
+import { write } from "./write_sf2/write.js";
+import { defaultModulators, Modulator } from "./modulator.js";
+import { writeDLS } from "./write_dls/write_dls.js";
+import { BasicSample } from "./basic_sample.js";
+import { BasicInstrumentZone, BasicPresetZone } from "./basic_zones.js";
+import { Generator, generatorTypes } from "./generator.js";
+import { BasicInstrument } from "./basic_instrument.js";
+import { BasicPreset } from "./basic_preset.js";
+import { isXGDrums } from "../../utils/xg_hacks.js";
+
+class BasicSoundBank
+{
+    
+    /**
+     * Soundfont's info stored as name: value. ifil and iver are stored as string representation of float (e.g., 2.1)
+     * @type {Object<string, string|IndexedByteArray>}
+     */
+    soundFontInfo = {};
+    
+    /**
+     * The soundfont's presets
+     * @type {BasicPreset[]}
+     */
+    presets = [];
+    
+    /**
+     * The soundfont's samples
+     * @type {BasicSample[]}
+     */
+    samples = [];
+    
+    /**
+     * The soundfont's instruments
+     * @type {BasicInstrument[]}
+     */
+    instruments = [];
+    
+    /**
+     * Soundfont's default modulatorss
+     * @type {Modulator[]}
+     */
+    defaultModulators = defaultModulators.map(m => Modulator.copy(m));
+    
+    /**
+     * Checks for XG drumsets and considers if this soundfont is XG.
+     * @type {boolean}
+     */
+    isXGBank = false;
+    
+    /**
+     * Creates a new basic soundfont template
+     * @param data {undefined|{presets: BasicPreset[], info: Object<string, string>}}
+     */
+    constructor(data = undefined)
+    {
+        if (data?.presets)
+        {
+            this.presets.push(...data.presets);
+            this.soundFontInfo = data.info;
+        }
+    }
+    
+    /**
+     * Merges soundfonts with the given order. Keep in mind that the info read is copied from the first one
+     * @param soundfonts {...BasicSoundBank} the soundfonts to merge, the first overwrites the last
+     * @returns {BasicSoundBank}
+     */
+    static mergeSoundBanks(...soundfonts)
+    {
+        const mainSf = soundfonts.shift();
+        const presets = mainSf.presets;
+        while (soundfonts.length)
+        {
+            const newPresets = soundfonts.shift().presets;
+            newPresets.forEach(newPreset =>
+            {
+                if (
+                    presets.find(existingPreset => existingPreset.bank === newPreset.bank && existingPreset.program === newPreset.program) === undefined
+                )
+                {
+                    presets.push(newPreset);
+                }
+            });
+        }
+        
+        return new BasicSoundBank({ presets: presets, info: mainSf.soundFontInfo });
+    }
+    
+    /**
+     * Creates a simple soundfont with one saw wave preset.
+     * @returns {ArrayBufferLike}
+     */
+    static getDummySoundfontFile()
+    {
+        const font = new BasicSoundBank();
+        const sample = new BasicSample(
+            "Saw",
+            44100,
+            65,
+            20,
+            0,
+            0,
+            0,
+            127
+        );
+        sample.sampleData = new Float32Array(128);
+        for (let i = 0; i < 128; i++)
+        {
+            sample.sampleData[i] = (i / 128) * 2 - 1;
+        }
+        font.samples.push(sample);
+        
+        const gZone = new BasicInstrumentZone();
+        gZone.isGlobal = true;
+        gZone.generators.push(new Generator(generatorTypes.initialAttenuation, 375));
+        gZone.generators.push(new Generator(generatorTypes.releaseVolEnv, -1000));
+        gZone.generators.push(new Generator(generatorTypes.sampleModes, 1));
+        
+        const zone1 = new BasicInstrumentZone();
+        zone1.sample = sample;
+        
+        const zone2 = new BasicInstrumentZone();
+        zone2.sample = sample;
+        zone2.generators.push(new Generator(generatorTypes.fineTune, -9));
+        
+        
+        const inst = new BasicInstrument();
+        inst.instrumentName = "Saw Wave";
+        inst.instrumentZones.push(gZone);
+        inst.instrumentZones.push(zone1);
+        inst.instrumentZones.push(zone2);
+        font.instruments.push(inst);
+        
+        const pZone = new BasicPresetZone();
+        pZone.instrument = inst;
+        
+        const preset = new BasicPreset(font);
+        preset.presetName = "Saw Wave";
+        preset.presetZones.push(pZone);
+        font.presets.push(preset);
+        
+        font.soundFontInfo["ifil"] = "2.1";
+        font.soundFontInfo["isng"] = "EMU8000";
+        font.soundFontInfo["INAM"] = "Dummy";
+        font._parseInternal();
+        return font.write().buffer;
+    }
+    
+    /**
+     * parses the bank after loading is done
+     * @protected
+     */
+    _parseInternal()
+    {
+        this.isXGBank = false;
+        // definitions for XG:
+        // at least one preset with bank 127, 126 or 120
+        // MUST be a valid XG bank.
+        // allowed banks: (see XG specification)
+        // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 24,
+        // 25, 27, 28, 29, 30, 31, 32, 33, 40, 41, 48, 56, 57, 58,
+        // 64, 65, 66, 126, 127
+        const allowedPrograms = new Set([
+            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 24,
+            25, 27, 28, 29, 30, 31, 32, 33, 40, 41, 48, 56, 57, 58,
+            64, 65, 66, 126, 127
+        ]);
+        for (const preset of this.presets)
+        {
+            if (isXGDrums(preset.bank))
+            {
+                this.isXGBank = true;
+                if (!allowedPrograms.has(preset.program))
+                {
+                    // not valid!
+                    this.isXGBank = false;
+                    SpessaSynthInfo(
+                        `%cThis bank is not valid XG. Preset %c${preset.bank}:${preset.program}%c is not a valid XG drum. XG mode will use presets on bank 128.`,
+                        consoleColors.info,
+                        consoleColors.value,
+                        consoleColors.info
+                    );
+                    break;
+                }
+            }
+        }
+    }
+    
+    /**
+     * Trims a sound bank to only contain samples in a given MIDI file
+     * @param mid {BasicMIDI} - the MIDI file
+     */
+    trimSoundBank(mid)
+    {
+        const soundfont = this;
+        
+        /**
+         * @param instrument {Instrument}
+         * @param combos {{key: number, velocity: number}[]}
+         * @returns {number}
+         */
+        function trimInstrumentZones(instrument, combos)
+        {
+            let trimmedIZones = 0;
+            for (let iZoneIndex = 0; iZoneIndex < instrument.instrumentZones.length; iZoneIndex++)
+            {
+                const iZone = instrument.instrumentZones[iZoneIndex];
+                if (iZone.isGlobal)
+                {
+                    continue;
+                }
+                const iKeyRange = iZone.keyRange;
+                const iVelRange = iZone.velRange;
+                let isIZoneUsed = false;
+                for (const iCombo of combos)
+                {
+                    if (
+                        (iCombo.key >= iKeyRange.min && iCombo.key <= iKeyRange.max) &&
+                        (iCombo.velocity >= iVelRange.min && iCombo.velocity <= iVelRange.max)
+                    )
+                    {
+                        isIZoneUsed = true;
+                        break;
+                    }
+                }
+                if (!isIZoneUsed)
+                {
+                    SpessaSynthInfo(
+                        `%c${iZone.sample.sampleName} %cremoved from %c${instrument.instrumentName}%c. Use count: %c${iZone.useCount - 1}`,
+                        consoleColors.recognized,
+                        consoleColors.info,
+                        consoleColors.recognized,
+                        consoleColors.info,
+                        consoleColors.recognized
+                    );
+                    if (instrument.safeDeleteZone(iZoneIndex))
+                    {
+                        trimmedIZones++;
+                        iZoneIndex--;
+                        SpessaSynthInfo(
+                            `%c${iZone.sample.sampleName} %cdeleted`,
+                            consoleColors.recognized,
+                            consoleColors.info
+                        );
+                    }
+                    if (iZone.sample.useCount < 1)
+                    {
+                        soundfont.deleteSample(iZone.sample);
+                    }
+                }
+                
+            }
+            return trimmedIZones;
+        }
+        
+        SpessaSynthGroup(
+            "%cTrimming soundfont...",
+            consoleColors.info
+        );
+        const usedProgramsAndKeys = mid.getUsedProgramsAndKeys(soundfont);
+        
+        SpessaSynthGroupCollapsed(
+            "%cModifying soundfont...",
+            consoleColors.info
+        );
+        SpessaSynthInfo("Detected keys for midi:", usedProgramsAndKeys);
+        // modify the soundfont to only include programs and samples that are used
+        for (let presetIndex = 0; presetIndex < soundfont.presets.length; presetIndex++)
+        {
+            const p = soundfont.presets[presetIndex];
+            const string = p.bank + ":" + p.program;
+            const used = usedProgramsAndKeys[string];
+            if (used === undefined)
+            {
+                SpessaSynthInfo(
+                    `%cDeleting preset %c${p.presetName}%c and its zones`,
+                    consoleColors.info,
+                    consoleColors.recognized,
+                    consoleColors.info
+                );
+                soundfont.deletePreset(p);
+                presetIndex--;
+            }
+            else
+            {
+                const combos = [...used].map(s =>
+                {
+                    const split = s.split("-");
+                    return {
+                        key: parseInt(split[0]),
+                        velocity: parseInt(split[1])
+                    };
+                });
+                SpessaSynthGroupCollapsed(
+                    `%cTrimming %c${p.presetName}`,
+                    consoleColors.info,
+                    consoleColors.recognized
+                );
+                SpessaSynthInfo(`Keys for ${p.presetName}:`, combos);
+                let trimmedZones = 0;
+                // clean the preset to only use zones that are used
+                for (let zoneIndex = 0; zoneIndex < p.presetZones.length; zoneIndex++)
+                {
+                    const zone = p.presetZones[zoneIndex];
+                    if (zone.isGlobal)
+                    {
+                        continue;
+                    }
+                    const keyRange = zone.keyRange;
+                    const velRange = zone.velRange;
+                    // check if any of the combos matches the zone
+                    let isZoneUsed = false;
+                    for (const combo of combos)
+                    {
+                        if (
+                            (combo.key >= keyRange.min && combo.key <= keyRange.max) &&
+                            (combo.velocity >= velRange.min && combo.velocity <= velRange.max)
+                        )
+                        {
+                            // zone is used, trim the instrument zones
+                            isZoneUsed = true;
+                            const trimmedIZones = trimInstrumentZones(zone.instrument, combos);
+                            SpessaSynthInfo(
+                                `%cTrimmed off %c${trimmedIZones}%c zones from %c${zone.instrument.instrumentName}`,
+                                consoleColors.info,
+                                consoleColors.recognized,
+                                consoleColors.info,
+                                consoleColors.recognized
+                            );
+                            break;
+                        }
+                    }
+                    if (!isZoneUsed)
+                    {
+                        trimmedZones++;
+                        p.deleteZone(zoneIndex);
+                        if (zone.instrument.useCount < 1)
+                        {
+                            soundfont.deleteInstrument(zone.instrument);
+                        }
+                        zoneIndex--;
+                    }
+                }
+                SpessaSynthInfo(
+                    `%cTrimmed off %c${trimmedZones}%c zones from %c${p.presetName}`,
+                    consoleColors.info,
+                    consoleColors.recognized,
+                    consoleColors.info,
+                    consoleColors.recognized
+                );
+                SpessaSynthGroupEnd();
+            }
+        }
+        soundfont.removeUnusedElements();
+        
+        soundfont.soundFontInfo["ICMT"] = `NOTE: This soundfont was trimmed by SpessaSynth to only contain presets used in "${mid.midiName}"\n\n`
+            + soundfont.soundFontInfo["ICMT"];
+        
+        SpessaSynthInfo(
+            "%cSoundfont modified!",
+            consoleColors.recognized
+        );
+        SpessaSynthGroupEnd();
+        SpessaSynthGroupEnd();
+    }
+    
+    removeUnusedElements()
+    {
+        this.instruments.forEach(i =>
+        {
+            if (i.useCount < 1)
+            {
+                i.instrumentZones.forEach(z =>
+                {
+                    if (!z.isGlobal)
+                    {
+                        z.sample.useCount--;
+                    }
+                });
+            }
+        });
+        this.instruments = this.instruments.filter(i => i.useCount > 0);
+        this.samples = this.samples.filter(s => s.useCount > 0);
+    }
+    
+    /**
+     * @param instrument {BasicInstrument}
+     */
+    deleteInstrument(instrument)
+    {
+        if (instrument.useCount > 0)
+        {
+            throw new Error(`Cannot delete an instrument that has ${instrument.useCount} usages.`);
+        }
+        this.instruments.splice(this.instruments.indexOf(instrument), 1);
+        instrument.deleteInstrument();
+        this.removeUnusedElements();
+    }
+    
+    /**
+     * @param preset {BasicPreset}
+     */
+    deletePreset(preset)
+    {
+        preset.deletePreset();
+        this.presets.splice(this.presets.indexOf(preset), 1);
+        this.removeUnusedElements();
+    }
+    
+    /**
+     * @param sample {BasicSample}
+     */
+    deleteSample(sample)
+    {
+        if (sample.useCount > 0)
+        {
+            throw new Error(`Cannot delete sample that has ${sample.useCount} usages.`);
+        }
+        this.samples.splice(this.samples.indexOf(sample), 1);
+        this.removeUnusedElements();
+    }
+    
+    /**
+     * Get the appropriate preset, undefined if not found
+     * @param bankNr {number}
+     * @param programNr {number}
+     * @param allowXGDrums {boolean} if true, allows XG drum banks (120, 126 and 127) as drum preset
+     * @return {BasicPreset}
+     */
+    getPresetNoFallback(bankNr, programNr, allowXGDrums = false)
+    {
+        const isDrum = bankNr === 128 || (allowXGDrums && isXGDrums(bankNr));
+        // check for exact match
+        let p;
+        if (isDrum)
+        {
+            p = this.presets.find(p => p.bank === bankNr && p.isDrumPreset(allowXGDrums) && p.program === programNr);
+        }
+        else
+        {
+            p = this.presets.find(p => p.bank === bankNr && p.program === programNr);
+        }
+        if (p)
+        {
+            return p;
+        }
+        // no match...
+        if (isDrum)
+        {
+            if (allowXGDrums)
+            {
+                // try any drum preset with matching program?
+                const p = this.presets.find(p => p.isDrumPreset(allowXGDrums) && p.program === programNr);
+                if (p)
+                {
+                    return p;
+                }
+            }
+        }
+        return undefined;
+    }
+    
+    /**
+     * Get the appropriate preset
+     * @param bankNr {number}
+     * @param programNr {number}
+     * @param allowXGDrums {boolean} if true, allows XG drum banks (120, 126 and 127) as drum preset
+     * @returns {BasicPreset}
+     */
+    getPreset(bankNr, programNr, allowXGDrums = false)
+    {
+        const isDrums = bankNr === 128 || (allowXGDrums && isXGDrums(bankNr));
+        // check for exact match
+        let preset;
+        // only allow drums if the preset is considered to be a drum preset
+        if (isDrums)
+        {
+            preset = this.presets.find(p => p.bank === bankNr && p.isDrumPreset(allowXGDrums) && p.program === programNr);
+        }
+        else
+        {
+            preset = this.presets.find(p => p.bank === bankNr && p.program === programNr);
+        }
+        if (preset)
+        {
+            return preset;
+        }
+        // no match...
+        if (isDrums)
+        {
+            // drum preset: find any preset with bank 128
+            preset = this.presets.find(p => p.isDrumPreset(allowXGDrums) && p.program === programNr);
+            if (!preset)
+            {
+                // only allow 128, otherwise it would default to XG SFX
+                preset = this.presets.find(p => p.isDrumPreset(allowXGDrums));
+            }
+        }
+        else
+        {
+            // non-drum preset: find any preset with the given program that is not a drum preset
+            preset = this.presets.find(p => p.program === programNr && !p.isDrumPreset(allowXGDrums));
+        }
+        if (preset)
+        {
+            SpessaSynthWarn(
+                `%cPreset ${bankNr}.${programNr} not found. Replaced with %c${preset.presetName} (${preset.bank}.${preset.program})`,
+                consoleColors.warn,
+                consoleColors.recognized
+            );
+        }
+        
+        // no preset, use the first one available
+        if (!preset)
+        {
+            SpessaSynthWarn(`Preset ${programNr} not found. Defaulting to`, this.presets[0].presetName);
+            preset = this.presets[0];
+        }
+        return preset;
+    }
+    
+    /**
+     * gets preset by name
+     * @param presetName {string}
+     * @returns {BasicPreset}
+     */
+    getPresetByName(presetName)
+    {
+        let preset = this.presets.find(p => p.presetName === presetName);
+        if (!preset)
+        {
+            SpessaSynthWarn("Preset not found. Defaulting to:", this.presets[0].presetName);
+            preset = this.presets[0];
+        }
+        return preset;
+    }
+    
+    /**
+     * @param error {string}
+     */
+    parsingError(error)
+    {
+        throw new Error(`SF parsing error: ${error} The file may be corrupted.`);
+    }
+    
+    destroySoundBank()
+    {
+        delete this.presets;
+        delete this.instruments;
+        delete this.samples;
+    }
+}
+
+BasicSoundBank.prototype.write = write;
+BasicSoundBank.prototype.writeDLS = writeDLS;
+
+export { BasicSoundBank };

package/src/soundfont/basic_soundfont/basic_zone.js

@@ -0,0 +1,64 @@
+/**
+ * @typedef {Object} SoundFontRange
+ * @property {number} min - the minimum midi note
+ * @property {number} max - the maximum midi note
+ */
+
+export class BasicZone
+{
+    /**
+     * The zone's velocity range
+     * min -1 means that it is a default value
+     * @type {SoundFontRange}
+     */
+    velRange = { min: -1, max: 127 };
+    
+    /**
+     * The zone's key range
+     * min -1 means that it is a default value
+     * @type {SoundFontRange}
+     */
+    keyRange = { min: -1, max: 127 };
+    /**
+     * Indicates if the zone is global
+     * @type {boolean}
+     */
+    isGlobal = false;
+    /**
+     * The zone's generators
+     * @type {Generator[]}
+     */
+    generators = [];
+    /**
+     * The zone's modulators
+     * @type {Modulator[]}
+     */
+    modulators = [];
+    
+    /**
+     * @returns {boolean}
+     */
+    get hasKeyRange()
+    {
+        return this.keyRange.min !== -1;
+    }
+    
+    /**
+     * @returns {boolean}
+     */
+    get hasVelRange()
+    {
+        return this.velRange.min !== -1;
+    }
+    
+    /**
+     * @param generatorType {generatorTypes}
+     * @param notFoundValue {number}
+     * @returns {number}
+     */
+    getGeneratorValue(generatorType, notFoundValue)
+    {
+        return this.generators.find(g => g.generatorType === generatorType)?.generatorValue ?? notFoundValue;
+    }
+}
+

package/src/soundfont/basic_soundfont/basic_zones.js

@@ -0,0 +1,43 @@
+import { BasicZone } from "./basic_zone.js";
+
+export class BasicInstrumentZone extends BasicZone
+{
+    /**
+     * Zone's sample. Undefined if global
+     * @type {BasicSample|undefined}
+     */
+    sample = undefined;
+    /**
+     * The zone's use count
+     * @type {number}
+     */
+    useCount = 0;
+    
+    deleteZone()
+    {
+        this.useCount--;
+        if (this.isGlobal)
+        {
+            return;
+        }
+        this.sample.useCount--;
+    }
+}
+
+export class BasicPresetZone extends BasicZone
+{
+    /**
+     * Zone's instrument. Undefined if global
+     * @type {BasicInstrument|undefined}
+     */
+    instrument = undefined;
+    
+    deleteZone()
+    {
+        if (this.isGlobal)
+        {
+            return;
+        }
+        this.instrument.removeUseCount();
+    }
+}