spessasynth_lib 3.25.23 → 3.26.1

package/soundfont/basic_soundfont/basic_soundfont.js

@@ -1,565 +0,0 @@
-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/soundfont/basic_soundfont/basic_zone.js

@@ -1,64 +0,0 @@
-/**
- * @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/soundfont/basic_soundfont/basic_zones.js

@@ -1,43 +0,0 @@
-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();
-    }
-}