Subversion Repositories eduke32

/* TinySoundFont - v0.8 - SoundFont2 synthesizer - https://github.com/schellingb/TinySoundFont

                                     no warranty implied; use at your own risk

   Do this:

      #define TSF_IMPLEMENTATION

   before you include this file in *one* C or C++ file to create the implementation.

   // i.e. it should look like this:

   #include ...

   #include ...

   #define TSF_IMPLEMENTATION

   #include "tsf.h"

   [OPTIONAL] #define TSF_NO_STDIO to remove stdio dependency

   [OPTIONAL] #define TSF_MALLOC, TSF_REALLOC, and TSF_FREE to avoid stdlib.h

   [OPTIONAL] #define TSF_MEMCPY, TSF_MEMSET to avoid string.h

   [OPTIONAL] #define TSF_POW, TSF_POWF, TSF_EXPF, TSF_LOG, TSF_TAN, TSF_LOG10, TSF_SQRT to avoid math.h

   NOT YET IMPLEMENTED

     - Support for ChorusEffectsSend and ReverbEffectsSend generators

     - Better low-pass filter without lowering performance too much

     - Support for modulators

   LICENSE (MIT)

   Copyright (C) 2017, 2018 Bernhard Schelling

   Based on SFZero, Copyright (C) 2012 Steve Folta (https://github.com/stevefolta/SFZero)

   Permission is hereby granted, free of charge, to any person obtaining a copy of this

   software and associated documentation files (the "Software"), to deal in the Software

   without restriction, including without limitation the rights to use, copy, modify, merge,

   publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons

   to whom the Software is furnished to do so, subject to the following conditions:

   The above copyright notice and this permission notice shall be included in all

   copies or substantial portions of the Software.

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,

   INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

   PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

   LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

   TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

   USE OR OTHER DEALINGS IN THE SOFTWARE.

*/

#ifndef TSF_INCLUDE_TSF_INL

#define TSF_INCLUDE_TSF_INL

#ifdef __cplusplus

extern "C" {

#  define CPP_DEFAULT0 = 0

#else

#  define CPP_DEFAULT0

#endif

//define this if you want the API functions to be static

#ifdef TSF_STATIC

#define TSFDEF static

#else

#define TSFDEF extern

#endif

// The load functions will return a pointer to a struct tsf which all functions

// thereafter take as the first parameter.

// On error the tsf_load* functions will return NULL most likely due to invalid

// data (or if the file did not exist in tsf_load_filename).

typedef struct tsf tsf;

#ifndef TSF_NO_STDIO

// Directly load a SoundFont from a .sf2 file path

TSFDEF tsf* tsf_load_filename(const char* filename);

#endif

// Load a SoundFont from a block of memory

TSFDEF tsf* tsf_load_memory(const void* buffer, int size);

// Stream structure for the generic loading

struct tsf_stream

{

        // Custom data given to the functions as the first parameter

        void* data;

        // Function pointer will be called to read 'size' bytes into ptr (returns number of read bytes)

        int (*read)(void* data, void* ptr, unsigned int size);

        // Function pointer will be called to skip ahead over 'count' bytes (returns 1 on success, 0 on error)

        int (*skip)(void* data, unsigned int count);

};

// Generic SoundFont loading method using the stream structure above

TSFDEF tsf* tsf_load(struct tsf_stream* stream);

// Free the memory related to this tsf instance

TSFDEF void tsf_close(tsf* f);

// Stop all playing notes immediatly and reset all channel parameters

TSFDEF void tsf_reset(tsf* f);

// Returns the preset index from a bank and preset number, or -1 if it does not exist in the loaded SoundFont

TSFDEF int tsf_get_presetindex(const tsf* f, int bank, int preset_number);

// Returns the number of presets in the loaded SoundFont

TSFDEF int tsf_get_presetcount(const tsf* f);

// Returns the name of a preset index >= 0 and < tsf_get_presetcount()

TSFDEF const char* tsf_get_presetname(const tsf* f, int preset_index);

// Returns the name of a preset by bank and preset number

TSFDEF const char* tsf_bank_get_presetname(const tsf* f, int bank, int preset_number);

// Supported output modes by the render methods

enum TSFOutputMode

{

        // Two channels with single left/right samples one after another

        TSF_STEREO_INTERLEAVED,

        // Two channels with all samples for the left channel first then right

        TSF_STEREO_UNWEAVED,

        // A single channel (stereo instruments are mixed into center)

        TSF_MONO,

};

// Thread safety:

// Your audio output which calls the tsf_render* functions will most likely

// run on a different thread than where the playback tsf_note* functions

// are called. In which case some sort of concurrency control like a

// mutex needs to be used so they are not called at the same time.

// Setup the parameters for the voice render methods

//   outputmode: if mono or stereo and how stereo channel data is ordered

//   samplerate: the number of samples per second (output frequency)

//   global_gain_db: volume gain in decibels (>0 means higher, <0 means lower)

TSFDEF void tsf_set_output(tsf* f, enum TSFOutputMode outputmode, int samplerate, float global_gain_db CPP_DEFAULT0);

// Start playing a note

//   preset_index: preset index >= 0 and < tsf_get_presetcount()

//   key: note value between 0 and 127 (60 being middle C)

//   vel: velocity as a float between 0.0 (equal to note off) and 1.0 (full)

//   bank: instrument bank number (alternative to preset_index)

//   preset_number: preset number (alternative to preset_index)

//   (bank_note_on returns 0 if preset does not exist, otherwise 1)

TSFDEF void tsf_note_on(tsf* f, int preset_index, int key, float vel);

TSFDEF int  tsf_bank_note_on(tsf* f, int bank, int preset_number, int key, float vel);

// Stop playing a note

//   (bank_note_off returns 0 if preset does not exist, otherwise 1)

TSFDEF void tsf_note_off(tsf* f, int preset_index, int key);

TSFDEF int  tsf_bank_note_off(tsf* f, int bank, int preset_number, int key);

// Stop playing all notes (end with sustain and release)

TSFDEF void tsf_note_off_all(tsf* f);

// Returns the number of active voices

TSFDEF int tsf_active_voice_count(tsf* f);

// Render output samples into a buffer

// You can either render as signed 16-bit values (tsf_render_short) or

// as 32-bit float values (tsf_render_float)

//   buffer: target buffer of size samples * output_channels * sizeof(type)

//   samples: number of samples to render

//   flag_mixing: if 0 clear the buffer first, otherwise mix into existing data

TSFDEF void tsf_render_short(tsf* f, short* buffer, int samples, int flag_mixing CPP_DEFAULT0);

TSFDEF void tsf_render_float(tsf* f, float* buffer, int samples, int flag_mixing CPP_DEFAULT0);

// Higher level channel based functions, set up channel parameters

//   channel: channel number

//   preset_index: preset index >= 0 and < tsf_get_presetcount()

//   preset_number: preset number (alternative to preset_index)

//   flag_mididrums: 0 for normal channels, otherwise apply MIDI drum channel rules

//   bank: instrument bank number (alternative to preset_index)

//   pan: stereo panning value from 0.0 (left) to 1.0 (right) (default 0.5 center)

//   volume: linear volume scale factor (default 1.0 full)

//   pitch_wheel: pitch wheel position 0 to 16383 (default 8192 unpitched)

//   pitch_range: range of the pitch wheel in semitones (default 2.0, total +/- 2 semitones)

//   tuning: tuning of all playing voices in semitones (default 0.0, standard (A440) tuning)

//   (set_preset_number and set_bank_preset return 0 if preset does not exist, otherwise 1)

TSFDEF void tsf_channel_set_presetindex(tsf* f, int channel, int preset_index);

TSFDEF int  tsf_channel_set_presetnumber(tsf* f, int channel, int preset_number, int flag_mididrums CPP_DEFAULT0);

TSFDEF void tsf_channel_set_bank(tsf* f, int channel, int bank);

TSFDEF int  tsf_channel_set_bank_preset(tsf* f, int channel, int bank, int preset_number);

TSFDEF void tsf_channel_set_pan(tsf* f, int channel, float pan);

TSFDEF void tsf_channel_set_volume(tsf* f, int channel, float volume);

TSFDEF void tsf_channel_set_pitchwheel(tsf* f, int channel, int pitch_wheel);

TSFDEF void tsf_channel_set_pitchrange(tsf* f, int channel, float pitch_range);

TSFDEF void tsf_channel_set_tuning(tsf* f, int channel, float tuning);

// Start or stop playing notes on a channel (needs channel preset to be set)

//   channel: channel number

//   key: note value between 0 and 127 (60 being middle C)

//   vel: velocity as a float between 0.0 (equal to note off) and 1.0 (full)

TSFDEF void tsf_channel_note_on(tsf* f, int channel, int key, float vel);

TSFDEF void tsf_channel_note_off(tsf* f, int channel, int key);

TSFDEF void tsf_channel_note_off_all(tsf* f, int channel); //end with sustain and release

TSFDEF void tsf_channel_sounds_off_all(tsf* f, int channel); //end immediatly

// Apply a MIDI control change to the channel (not all controllers are supported!)

TSFDEF void tsf_channel_midi_control(tsf* f, int channel, int controller, int control_value);

// Get current values set on the channels

TSFDEF int tsf_channel_get_preset_index(tsf* f, int channel);

TSFDEF int tsf_channel_get_preset_bank(tsf* f, int channel);

TSFDEF int tsf_channel_get_preset_number(tsf* f, int channel);

TSFDEF float tsf_channel_get_pan(tsf* f, int channel);

TSFDEF float tsf_channel_get_volume(tsf* f, int channel);

TSFDEF int tsf_channel_get_pitchwheel(tsf* f, int channel);

TSFDEF float tsf_channel_get_pitchrange(tsf* f, int channel);

TSFDEF float tsf_channel_get_tuning(tsf* f, int channel);

#ifdef __cplusplus

#  undef CPP_DEFAULT0

}

#endif

// end header

// ---------------------------------------------------------------------------------------------------------

#endif //TSF_INCLUDE_TSF_INL

#ifdef TSF_IMPLEMENTATION

// The lower this block size is the more accurate the effects are.

// Increasing the value significantly lowers the CPU usage of the voice rendering.

// If LFO affects the low-pass filter it can be hearable even as low as 8.

#ifndef TSF_RENDER_EFFECTSAMPLEBLOCK

#define TSF_RENDER_EFFECTSAMPLEBLOCK 64

#endif

// Grace release time for quick voice off (avoid clicking noise)

#define TSF_FASTRELEASETIME 0.01f

#if !defined(TSF_MALLOC) || !defined(TSF_FREE) || !defined(TSF_REALLOC)

#  include <stdlib.h>

#  define TSF_MALLOC  malloc

#  define TSF_FREE    free

#  define TSF_REALLOC realloc

#endif

#if !defined(TSF_MEMCPY) || !defined(TSF_MEMSET)

#  include <string.h>

#  define TSF_MEMCPY  memcpy

#  define TSF_MEMSET  memset

#endif

#if !defined(TSF_POW) || !defined(TSF_POWF) || !defined(TSF_EXPF) || !defined(TSF_LOG) || !defined(TSF_TAN) || !defined(TSF_LOG10) || !defined(TSF_SQRT)

#  include <math.h>

#  if !defined(__cplusplus) && !defined(NAN) && !defined(powf) && !defined(expf) && !defined(sqrtf)

#    define powf (float)pow // deal with old math.h

#    define expf (float)exp // files that come without

#    define sqrtf (float)sqrt // powf, expf and sqrtf

#  endif

#  define TSF_POW     pow

#  define TSF_POWF    powf

#  define TSF_EXPF    expf

#  define TSF_LOG     log

#  define TSF_TAN     tan

#  define TSF_LOG10   log10

#  define TSF_SQRTF   sqrtf

#endif

#ifndef TSF_NO_STDIO

#  include <stdio.h>

#endif

#define TSF_TRUE 1

#define TSF_FALSE 0

#define TSF_BOOL char

#define TSF_PI 3.14159265358979323846264338327950288

#define TSF_NULL 0

#ifdef __cplusplus

extern "C" {

#endif

typedef char tsf_fourcc[4];

typedef signed char tsf_s8;

typedef unsigned char tsf_u8;

typedef unsigned short tsf_u16;

typedef signed short tsf_s16;

typedef unsigned int tsf_u32;

typedef char tsf_char20[20];

#define TSF_FourCCEquals(value1, value2) (value1[0] == value2[0] && value1[1] == value2[1] && value1[2] == value2[2] && value1[3] == value2[3])

struct tsf

{

        struct tsf_preset* presets;

        float* fontSamples;

        struct tsf_voice* voices;

        struct tsf_channels* channels;

        float* outputSamples;

        int presetNum;

        int voiceNum;

        int outputSampleSize;

        unsigned int voicePlayIndex;

        enum TSFOutputMode outputmode;

        float outSampleRate;

        float globalGainDB;

};

#ifndef TSF_NO_STDIO

static int tsf_stream_stdio_read(FILE* f, void* ptr, unsigned int size) { return (int)fread(ptr, 1, size, f); }

static int tsf_stream_stdio_skip(FILE* f, unsigned int count) { return !fseek(f, count, SEEK_CUR); }

TSFDEF tsf* tsf_load_filename(const char* filename)

{

        tsf* res;

        struct tsf_stream stream = { TSF_NULL, (int(*)(void*,void*,unsigned int))&tsf_stream_stdio_read, (int(*)(void*,unsigned int))&tsf_stream_stdio_skip };

        #if __STDC_WANT_SECURE_LIB__

        FILE* f = TSF_NULL; fopen_s(&f, filename, "rb");

        #else

        FILE* f = fopen(filename, "rb");

        #endif

        if (!f)

        {

                //if (e) *e = TSF_FILENOTFOUND;

                return TSF_NULL;

        }

        stream.data = f;

        res = tsf_load(&stream);

        fclose(f);

        return res;

}

#endif

struct tsf_stream_memory { const char* buffer; unsigned int total, pos; };

static int tsf_stream_memory_read(struct tsf_stream_memory* m, void* ptr, unsigned int size) { if (size > m->total - m->pos) size = m->total - m->pos; TSF_MEMCPY(ptr, m->buffer+m->pos, size); m->pos += size; return size; }

static int tsf_stream_memory_skip(struct tsf_stream_memory* m, unsigned int count) { if (m->pos + count > m->total) return 0; m->pos += count; return 1; }

TSFDEF tsf* tsf_load_memory(const void* buffer, int size)

{

        struct tsf_stream stream = { TSF_NULL, (int(*)(void*,void*,unsigned int))&tsf_stream_memory_read, (int(*)(void*,unsigned int))&tsf_stream_memory_skip };

        struct tsf_stream_memory f = { 0, 0, 0 };

        f.buffer = (const char*)buffer;

        f.total = size;

        stream.data = &f;

        return tsf_load(&stream);

}

enum { TSF_LOOPMODE_NONE, TSF_LOOPMODE_CONTINUOUS, TSF_LOOPMODE_SUSTAIN };

enum { TSF_SEGMENT_NONE, TSF_SEGMENT_DELAY, TSF_SEGMENT_ATTACK, TSF_SEGMENT_HOLD, TSF_SEGMENT_DECAY, TSF_SEGMENT_SUSTAIN, TSF_SEGMENT_RELEASE, TSF_SEGMENT_DONE };

struct tsf_hydra

{

        struct tsf_hydra_phdr *phdrs; struct tsf_hydra_pbag *pbags; struct tsf_hydra_pmod *pmods;

        struct tsf_hydra_pgen *pgens; struct tsf_hydra_inst *insts; struct tsf_hydra_ibag *ibags;

        struct tsf_hydra_imod *imods; struct tsf_hydra_igen *igens; struct tsf_hydra_shdr *shdrs;

        int phdrNum, pbagNum, pmodNum, pgenNum, instNum, ibagNum, imodNum, igenNum, shdrNum;

};

union tsf_hydra_genamount { struct { tsf_u8 lo, hi; } range; tsf_s16 shortAmount; tsf_u16 wordAmount; };

struct tsf_hydra_phdr { tsf_char20 presetName; tsf_u16 preset, bank, presetBagNdx; tsf_u32 library, genre, morphology; };

struct tsf_hydra_pbag { tsf_u16 genNdx, modNdx; };

struct tsf_hydra_pmod { tsf_u16 modSrcOper, modDestOper; tsf_s16 modAmount; tsf_u16 modAmtSrcOper, modTransOper; };

struct tsf_hydra_pgen { tsf_u16 genOper; union tsf_hydra_genamount genAmount; };

struct tsf_hydra_inst { tsf_char20 instName; tsf_u16 instBagNdx; };

struct tsf_hydra_ibag { tsf_u16 instGenNdx, instModNdx; };

struct tsf_hydra_imod { tsf_u16 modSrcOper, modDestOper; tsf_s16 modAmount; tsf_u16 modAmtSrcOper, modTransOper; };

struct tsf_hydra_igen { tsf_u16 genOper; union tsf_hydra_genamount genAmount; };

struct tsf_hydra_shdr { tsf_char20 sampleName; tsf_u32 start, end, startLoop, endLoop, sampleRate; tsf_u8 originalPitch; tsf_s8 pitchCorrection; tsf_u16 sampleLink, sampleType; };

#define TSFR(FIELD) stream->read(stream->data, &i->FIELD, sizeof(i->FIELD));

static void tsf_hydra_read_phdr(struct tsf_hydra_phdr* i, struct tsf_stream* stream) { TSFR(presetName) TSFR(preset) TSFR(bank) TSFR(presetBagNdx) TSFR(library) TSFR(genre) TSFR(morphology) }

static void tsf_hydra_read_pbag(struct tsf_hydra_pbag* i, struct tsf_stream* stream) { TSFR(genNdx) TSFR(modNdx) }

static void tsf_hydra_read_pmod(struct tsf_hydra_pmod* i, struct tsf_stream* stream) { TSFR(modSrcOper) TSFR(modDestOper) TSFR(modAmount) TSFR(modAmtSrcOper) TSFR(modTransOper) }

static void tsf_hydra_read_pgen(struct tsf_hydra_pgen* i, struct tsf_stream* stream) { TSFR(genOper) TSFR(genAmount) }

static void tsf_hydra_read_inst(struct tsf_hydra_inst* i, struct tsf_stream* stream) { TSFR(instName) TSFR(instBagNdx) }

static void tsf_hydra_read_ibag(struct tsf_hydra_ibag* i, struct tsf_stream* stream) { TSFR(instGenNdx) TSFR(instModNdx) }

static void tsf_hydra_read_imod(struct tsf_hydra_imod* i, struct tsf_stream* stream) { TSFR(modSrcOper) TSFR(modDestOper) TSFR(modAmount) TSFR(modAmtSrcOper) TSFR(modTransOper) }

static void tsf_hydra_read_igen(struct tsf_hydra_igen* i, struct tsf_stream* stream) { TSFR(genOper) TSFR(genAmount) }

static void tsf_hydra_read_shdr(struct tsf_hydra_shdr* i, struct tsf_stream* stream) { TSFR(sampleName) TSFR(start) TSFR(end) TSFR(startLoop) TSFR(endLoop) TSFR(sampleRate) TSFR(originalPitch) TSFR(pitchCorrection) TSFR(sampleLink) TSFR(sampleType) }

#undef TSFR

struct tsf_riffchunk { tsf_fourcc id; tsf_u32 size; };

struct tsf_envelope { float delay, attack, hold, decay, sustain, release, keynumToHold, keynumToDecay; };

struct tsf_voice_envelope { float level, slope; int samplesUntilNextSegment; short segment, midiVelocity; struct tsf_envelope parameters; TSF_BOOL segmentIsExponential, isAmpEnv; };

struct tsf_voice_lowpass { double QInv, a0, a1, b1, b2, z1, z2; TSF_BOOL active; };

struct tsf_voice_lfo { int samplesUntil; float level, delta; };

struct tsf_region

{

        int loop_mode;

        unsigned int sample_rate;

        unsigned char lokey, hikey, lovel, hivel;

        unsigned int group, offset, end, loop_start, loop_end;

        int transpose, tune, pitch_keycenter, pitch_keytrack;

        float attenuation, pan;

        struct tsf_envelope ampenv, modenv;

        int initialFilterQ, initialFilterFc;

        int modEnvToPitch, modEnvToFilterFc, modLfoToFilterFc, modLfoToVolume;

        float delayModLFO;

        int freqModLFO, modLfoToPitch;

        float delayVibLFO;

        int freqVibLFO, vibLfoToPitch;

};

struct tsf_preset

{

        tsf_char20 presetName;

        tsf_u16 preset, bank;

        struct tsf_region* regions;

        int regionNum;

};

struct tsf_voice

{

        int playingPreset, playingKey, playingChannel;

        struct tsf_region* region;

        double pitchInputTimecents, pitchOutputFactor;

        double sourceSamplePosition;

        float  noteGainDB, panFactorLeft, panFactorRight;

        unsigned int playIndex, loopStart, loopEnd;

        struct tsf_voice_envelope ampenv, modenv;

        struct tsf_voice_lowpass lowpass;

        struct tsf_voice_lfo modlfo, viblfo;

};

struct tsf_channel

{

        unsigned short presetIndex, bank, pitchWheel, midiPan, midiVolume, midiExpression, midiRPN, midiData;

        float panOffset, gainDB, pitchRange, tuning;

};

struct tsf_channels

{

        void (*setupVoice)(tsf* f, struct tsf_voice* voice);

        struct tsf_channel* channels;

        int channelNum, activeChannel;

};

static double tsf_timecents2Secsd(double timecents) { return TSF_POW(2.0, timecents / 1200.0); }

static float tsf_timecents2Secsf(float timecents) { return TSF_POWF(2.0f, timecents / 1200.0f); }

static float tsf_cents2Hertz(float cents) { return 8.176f * TSF_POWF(2.0f, cents / 1200.0f); }

static float tsf_decibelsToGain(float db) { return (db > -100.f ? TSF_POWF(10.0f, db * 0.05f) : 0); }

static float tsf_gainToDecibels(float gain) { return (gain <= .00001f ? -100.f : (float)(20.0 * TSF_LOG10(gain))); }

static TSF_BOOL tsf_riffchunk_read(struct tsf_riffchunk* parent, struct tsf_riffchunk* chunk, struct tsf_stream* stream)

{

        TSF_BOOL IsRiff, IsList;

        if (parent && sizeof(tsf_fourcc) + sizeof(tsf_u32) > parent->size) return TSF_FALSE;

        if (!stream->read(stream->data, &chunk->id, sizeof(tsf_fourcc)) || *chunk->id <= ' ' || *chunk->id >= 'z') return TSF_FALSE;

        if (!stream->read(stream->data, &chunk->size, sizeof(tsf_u32))) return TSF_FALSE;

        if (parent && sizeof(tsf_fourcc) + sizeof(tsf_u32) + chunk->size > parent->size) return TSF_FALSE;

        if (parent) parent->size -= sizeof(tsf_fourcc) + sizeof(tsf_u32) + chunk->size;

        IsRiff = TSF_FourCCEquals(chunk->id, "RIFF"), IsList = TSF_FourCCEquals(chunk->id, "LIST");

        if (IsRiff && parent) return TSF_FALSE; //not allowed

        if (!IsRiff && !IsList) return TSF_TRUE; //custom type without sub type

        if (!stream->read(stream->data, &chunk->id, sizeof(tsf_fourcc)) || *chunk->id <= ' ' || *chunk->id >= 'z') return TSF_FALSE;

        chunk->size -= sizeof(tsf_fourcc);

        return TSF_TRUE;

}

static void tsf_region_clear(struct tsf_region* i, TSF_BOOL for_relative)

{

        TSF_MEMSET(i, 0, sizeof(struct tsf_region));

        i->hikey = i->hivel = 127;

        i->pitch_keycenter = 60; // C4

        if (for_relative) return;

        i->pitch_keytrack = 100;

        i->pitch_keycenter = -1;

        // SF2 defaults in timecents.

        i->ampenv.delay = i->ampenv.attack = i->ampenv.hold = i->ampenv.decay = i->ampenv.release = -12000.0f;

        i->modenv.delay = i->modenv.attack = i->modenv.hold = i->modenv.decay = i->modenv.release = -12000.0f;

        i->initialFilterFc = 13500;

        i->delayModLFO = -12000.0f;

        i->delayVibLFO = -12000.0f;

}

static void tsf_region_operator(struct tsf_region* region, tsf_u16 genOper, union tsf_hydra_genamount* amount, struct tsf_region* merge_region)

{

        enum

        {

                _GEN_TYPE_MASK       = 0x0F,

                GEN_FLOAT            = 0x01,

                GEN_INT              = 0x02,

                GEN_UINT_ADD         = 0x03,

                GEN_UINT_ADD15       = 0x04,

                GEN_KEYRANGE         = 0x05,

                GEN_VELRANGE         = 0x06,

                GEN_LOOPMODE         = 0x07,

                GEN_GROUP            = 0x08,

                GEN_KEYCENTER        = 0x09,

                _GEN_LIMIT_MASK      = 0xF0,

                GEN_INT_LIMIT12K     = 0x10, //min -12000, max 12000

                GEN_INT_LIMITFC      = 0x20, //min 1500, max 13500

                GEN_INT_LIMITQ       = 0x30, //min 0, max 960

                GEN_INT_LIMIT960     = 0x40, //min -960, max 960

                GEN_INT_LIMIT16K4500 = 0x50, //min -16000, max 4500

                GEN_FLOAT_LIMIT12K5K = 0x60, //min -12000, max 5000

                GEN_FLOAT_LIMIT12K8K = 0x70, //min -12000, max 8000

                GEN_FLOAT_LIMIT1200  = 0x80, //min -1200, max 1200

                GEN_FLOAT_LIMITPAN   = 0x90, //* .001f, min -.5f, max .5f,

                GEN_FLOAT_LIMITATTN  = 0xA0, //* .1f, min 0, max 144.0

                GEN_FLOAT_MAX1000    = 0xB0, //min 0, max 1000

                GEN_FLOAT_MAX1440    = 0xC0, //min 0, max 1440

                _GEN_MAX = 59,

        };

        #define _TSFREGIONOFFSET(TYPE, FIELD) (unsigned char)(((TYPE*)&((struct tsf_region*)0)->FIELD) - (TYPE*)0)

        #define _TSFREGIONENVOFFSET(TYPE, ENV, FIELD) (unsigned char)(((TYPE*)&((&(((struct tsf_region*)0)->ENV))->FIELD)) - (TYPE*)0)

        static const struct { unsigned char mode, offset; } genMetas[_GEN_MAX] =

        {

                { GEN_UINT_ADD                     , _TSFREGIONOFFSET(unsigned int, offset               ) }, // 0 StartAddrsOffset

                { GEN_UINT_ADD                     , _TSFREGIONOFFSET(unsigned int, end                  ) }, // 1 EndAddrsOffset

                { GEN_UINT_ADD                     , _TSFREGIONOFFSET(unsigned int, loop_start           ) }, // 2 StartloopAddrsOffset

                { GEN_UINT_ADD                     , _TSFREGIONOFFSET(unsigned int, loop_end             ) }, // 3 EndloopAddrsOffset

                { GEN_UINT_ADD15                   , _TSFREGIONOFFSET(unsigned int, offset               ) }, // 4 StartAddrsCoarseOffset

                { GEN_INT   | GEN_INT_LIMIT12K     , _TSFREGIONOFFSET(         int, modLfoToPitch        ) }, // 5 ModLfoToPitch

                { GEN_INT   | GEN_INT_LIMIT12K     , _TSFREGIONOFFSET(         int, vibLfoToPitch        ) }, // 6 VibLfoToPitch

                { GEN_INT   | GEN_INT_LIMIT12K     , _TSFREGIONOFFSET(         int, modEnvToPitch        ) }, // 7 ModEnvToPitch

                { GEN_INT   | GEN_INT_LIMITFC      , _TSFREGIONOFFSET(         int, initialFilterFc      ) }, // 8 InitialFilterFc

                { GEN_INT   | GEN_INT_LIMITQ       , _TSFREGIONOFFSET(         int, initialFilterQ       ) }, // 9 InitialFilterQ

                { GEN_INT   | GEN_INT_LIMIT12K     , _TSFREGIONOFFSET(         int, modLfoToFilterFc     ) }, //10 ModLfoToFilterFc

                { GEN_INT   | GEN_INT_LIMIT12K     , _TSFREGIONOFFSET(         int, modEnvToFilterFc     ) }, //11 ModEnvToFilterFc

                { GEN_UINT_ADD15                   , _TSFREGIONOFFSET(unsigned int, end                  ) }, //12 EndAddrsCoarseOffset

                { GEN_INT   | GEN_INT_LIMIT960     , _TSFREGIONOFFSET(         int, modLfoToVolume       ) }, //13 ModLfoToVolume

                { 0                                , (0                                                  ) }, //   Unused

                { 0                                , (0                                                  ) }, //15 ChorusEffectsSend (unsupported)

                { 0                                , (0                                                  ) }, //16 ReverbEffectsSend (unsupported)

                { GEN_FLOAT | GEN_FLOAT_LIMITPAN   , _TSFREGIONOFFSET(       float, pan                  ) }, //17 Pan

                { 0                                , (0                                                  ) }, //   Unused

                { 0                                , (0                                                  ) }, //   Unused

                { 0                                , (0                                                  ) }, //   Unused

                { GEN_FLOAT | GEN_FLOAT_LIMIT12K5K , _TSFREGIONOFFSET(       float, delayModLFO          ) }, //21 DelayModLFO

                { GEN_INT   | GEN_INT_LIMIT16K4500 , _TSFREGIONOFFSET(         int, freqModLFO           ) }, //22 FreqModLFO

                { GEN_FLOAT | GEN_FLOAT_LIMIT12K5K , _TSFREGIONOFFSET(       float, delayVibLFO          ) }, //23 DelayVibLFO

                { GEN_INT   | GEN_INT_LIMIT16K4500 , _TSFREGIONOFFSET(         int, freqVibLFO           ) }, //24 FreqVibLFO

                { GEN_FLOAT | GEN_FLOAT_LIMIT12K5K , _TSFREGIONENVOFFSET(    float, modenv, delay        ) }, //25 DelayModEnv

                { GEN_FLOAT | GEN_FLOAT_LIMIT12K8K , _TSFREGIONENVOFFSET(    float, modenv, attack       ) }, //26 AttackModEnv

                { GEN_FLOAT | GEN_FLOAT_LIMIT12K5K , _TSFREGIONENVOFFSET(    float, modenv, hold         ) }, //27 HoldModEnv

                { GEN_FLOAT | GEN_FLOAT_LIMIT12K8K , _TSFREGIONENVOFFSET(    float, modenv, decay        ) }, //28 DecayModEnv

                { GEN_FLOAT | GEN_FLOAT_MAX1000    , _TSFREGIONENVOFFSET(    float, modenv, sustain      ) }, //29 SustainModEnv

                { GEN_FLOAT | GEN_FLOAT_LIMIT12K8K , _TSFREGIONENVOFFSET(    float, modenv, release      ) }, //30 ReleaseModEnv

                { GEN_FLOAT | GEN_FLOAT_LIMIT1200  , _TSFREGIONENVOFFSET(    float, modenv, keynumToHold ) }, //31 KeynumToModEnvHold

                { GEN_FLOAT | GEN_FLOAT_LIMIT1200  , _TSFREGIONENVOFFSET(    float, modenv, keynumToDecay) }, //32 KeynumToModEnvDecay

                { GEN_FLOAT | GEN_FLOAT_LIMIT12K5K , _TSFREGIONENVOFFSET(    float, ampenv, delay        ) }, //33 DelayVolEnv

                { GEN_FLOAT | GEN_FLOAT_LIMIT12K8K , _TSFREGIONENVOFFSET(    float, ampenv, attack       ) }, //34 AttackVolEnv

                { GEN_FLOAT | GEN_FLOAT_LIMIT12K5K , _TSFREGIONENVOFFSET(    float, ampenv, hold         ) }, //35 HoldVolEnv

                { GEN_FLOAT | GEN_FLOAT_LIMIT12K8K , _TSFREGIONENVOFFSET(    float, ampenv, decay        ) }, //36 DecayVolEnv

                { GEN_FLOAT | GEN_FLOAT_MAX1440    , _TSFREGIONENVOFFSET(    float, ampenv, sustain      ) }, //37 SustainVolEnv

                { GEN_FLOAT | GEN_FLOAT_LIMIT12K8K , _TSFREGIONENVOFFSET(    float, ampenv, release      ) }, //38 ReleaseVolEnv

                { GEN_FLOAT | GEN_FLOAT_LIMIT1200  , _TSFREGIONENVOFFSET(    float, ampenv, keynumToHold ) }, //39 KeynumToVolEnvHold

                { GEN_FLOAT | GEN_FLOAT_LIMIT1200  , _TSFREGIONENVOFFSET(    float, ampenv, keynumToDecay) }, //40 KeynumToVolEnvDecay

                { 0                                , (0                                                  ) }, //   Instrument (special)

                { 0                                , (0                                                  ) }, //   Reserved

                { GEN_KEYRANGE                     , (0                                                  ) }, //43 KeyRange

                { GEN_VELRANGE                     , (0                                                  ) }, //44 VelRange

                { GEN_UINT_ADD15                   , _TSFREGIONOFFSET(unsigned int, loop_start           ) }, //45 StartloopAddrsCoarseOffset

                { 0                                , (0                                                  ) }, //46 Keynum (special)

                { 0                                , (0                                                  ) }, //47 Velocity (special)

                { GEN_FLOAT | GEN_FLOAT_LIMITATTN  , _TSFREGIONOFFSET(       float, attenuation          ) }, //48 InitialAttenuation

                { 0                                , (0                                                  ) }, //   Reserved

                { GEN_UINT_ADD15                   , _TSFREGIONOFFSET(unsigned int, loop_end             ) }, //50 EndloopAddrsCoarseOffset

                { GEN_INT                          , _TSFREGIONOFFSET(         int, transpose            ) }, //51 CoarseTune

                { GEN_INT                          , _TSFREGIONOFFSET(         int, tune                 ) }, //52 FineTune

                { 0                                , (0                                                  ) }, //   SampleID (special)

                { GEN_LOOPMODE                     , _TSFREGIONOFFSET(         int, loop_mode            ) }, //54 SampleModes

                { 0                                , (0                                                  ) }, //   Reserved

                { GEN_INT                          , _TSFREGIONOFFSET(         int, pitch_keytrack       ) }, //56 ScaleTuning

                { GEN_GROUP                        , _TSFREGIONOFFSET(unsigned int, group                ) }, //57 ExclusiveClass

                { GEN_KEYCENTER                    , _TSFREGIONOFFSET(         int, pitch_keycenter      ) }, //58 OverridingRootKey

        };

        #undef _TSFREGIONOFFSET

        #undef _TSFREGIONENVOFFSET

        if (amount)

        {

                int offset;

                if (genOper >= _GEN_MAX) return;

                offset = genMetas[genOper].offset;

                switch (genMetas[genOper].mode & _GEN_TYPE_MASK)

                {

                        case GEN_FLOAT:      ((       float*)region)[offset]  = amount->shortAmount;     return;

                        case GEN_INT:        ((         int*)region)[offset]  = amount->shortAmount;     return;

                        case GEN_UINT_ADD:   ((unsigned int*)region)[offset] += amount->shortAmount;     return;

                        case GEN_UINT_ADD15: ((unsigned int*)region)[offset] += amount->shortAmount<<15; return;

                        case GEN_KEYRANGE:   region->lokey = amount->range.lo; region->hikey = amount->range.hi; return;

                        case GEN_VELRANGE:   region->lovel = amount->range.lo; region->hivel = amount->range.hi; return;

                        case GEN_LOOPMODE:   region->loop_mode       = ((amount->wordAmount&3) == 3 ? TSF_LOOPMODE_SUSTAIN : ((amount->wordAmount&3) == 1 ? TSF_LOOPMODE_CONTINUOUS : TSF_LOOPMODE_NONE)); return;

                        case GEN_GROUP:      region->group           = amount->wordAmount;  return;

                        case GEN_KEYCENTER:  region->pitch_keycenter = amount->shortAmount; return;

                }

        }

        else //merge regions and clamp values

        {

                for (genOper = 0; genOper != _GEN_MAX; genOper++)

                {

                        int offset = genMetas[genOper].offset;

                        switch (genMetas[genOper].mode & _GEN_TYPE_MASK)

                        {

                                case GEN_FLOAT:

                                {

                                        float *val = &((float*)region)[offset], vfactor, vmin, vmax;

                                        *val += ((float*)merge_region)[offset];

                                        switch (genMetas[genOper].mode & _GEN_LIMIT_MASK)

                                        {

                                                case GEN_FLOAT_LIMIT12K5K: vfactor =   1.0f; vmin = -12000.0f; vmax = 5000.0f; break;

                                                case GEN_FLOAT_LIMIT12K8K: vfactor =   1.0f; vmin = -12000.0f; vmax = 8000.0f; break;

                                                case GEN_FLOAT_LIMIT1200:  vfactor =   1.0f; vmin =  -1200.0f; vmax = 1200.0f; break;

                                                case GEN_FLOAT_LIMITPAN:   vfactor = 0.001f; vmin =     -0.5f; vmax =    0.5f; break;

                                                case GEN_FLOAT_LIMITATTN:  vfactor =   0.1f; vmin =      0.0f; vmax =  144.0f; break;

                                                case GEN_FLOAT_MAX1000:    vfactor =   1.0f; vmin =      0.0f; vmax = 1000.0f; break;

                                                case GEN_FLOAT_MAX1440:    vfactor =   1.0f; vmin =      0.0f; vmax = 1440.0f; break;

                                                default: continue;

                                        }

                                        *val *= vfactor;

                                        if      (*val < vmin) *val = vmin;

                                        else if (*val > vmax) *val = vmax;

                                        continue;

                                }

                                case GEN_INT:

                                {

                                        int *val = &((int*)region)[offset], vmin, vmax;

                                        *val += ((int*)merge_region)[offset];

                                        switch (genMetas[genOper].mode & _GEN_LIMIT_MASK)

                                        {

                                                case GEN_INT_LIMIT12K:     vmin = -12000; vmax = 12000; break;

                                                case GEN_INT_LIMITFC:      vmin =   1500; vmax = 13500; break;

                                                case GEN_INT_LIMITQ:       vmin =      0; vmax =   960; break;

                                                case GEN_INT_LIMIT960:     vmin =   -960; vmax =   960; break;

                                                case GEN_INT_LIMIT16K4500: vmin = -16000; vmax =  4500; break;

                                                default: continue;

                                        }

                                        if      (*val < vmin) *val = vmin;

                                        else if (*val > vmax) *val = vmax;

                                        continue;

                                }

                                case GEN_UINT_ADD:

                                {

                                        ((unsigned int*)region)[offset] += ((unsigned int*)merge_region)[offset];

                                        continue;

                                }

                        }

                }

        }

}

static void tsf_region_envtosecs(struct tsf_envelope* p, TSF_BOOL sustainIsGain)

{

        // EG times need to be converted from timecents to seconds.

        // Pin very short EG segments.  Timecents don't get to zero, and our EG is

        // happier with zero values.

        p->delay   = (p->delay   < -11950.0f ? 0.0f : tsf_timecents2Secsf(p->delay));

        p->attack  = (p->attack  < -11950.0f ? 0.0f : tsf_timecents2Secsf(p->attack));

        p->release = (p->release < -11950.0f ? 0.0f : tsf_timecents2Secsf(p->release));

        // If we have dynamic hold or decay times depending on key number we need

        // to keep the values in timecents so we can calculate it during startNote

        if (!p->keynumToHold)  p->hold  = (p->hold  < -11950.0f ? 0.0f : tsf_timecents2Secsf(p->hold));

        if (!p->keynumToDecay) p->decay = (p->decay < -11950.0f ? 0.0f : tsf_timecents2Secsf(p->decay));

        if (p->sustain < 0.0f) p->sustain = 0.0f;

        else if (sustainIsGain) p->sustain = tsf_decibelsToGain(-p->sustain / 10.0f);

        else p->sustain = 1.0f - (p->sustain / 1000.0f);

}

static void tsf_load_presets(tsf* res, struct tsf_hydra *hydra, unsigned int fontSampleCount)

{

        enum { GenInstrument = 41, GenKeyRange = 43, GenVelRange = 44, GenSampleID = 53 };

        // Read each preset.

        struct tsf_hydra_phdr *pphdr, *pphdrMax;

        for (pphdr = hydra->phdrs, pphdrMax = pphdr + hydra->phdrNum - 1; pphdr != pphdrMax; pphdr++)

        {

                int sortedIndex = 0, region_index = 0;

                struct tsf_hydra_phdr *otherphdr;

                struct tsf_preset* preset;

                struct tsf_hydra_pbag *ppbag, *ppbagEnd;

                struct tsf_region globalRegion;

                for (otherphdr = hydra->phdrs; otherphdr != pphdrMax; otherphdr++)

                {

                        if (otherphdr == pphdr || otherphdr->bank > pphdr->bank) continue;

                        else if (otherphdr->bank < pphdr->bank) sortedIndex++;

                        else if (otherphdr->preset > pphdr->preset) continue;

                        else if (otherphdr->preset < pphdr->preset) sortedIndex++;

                        else if (otherphdr < pphdr) sortedIndex++;

                }

                preset = &res->presets[sortedIndex];

                TSF_MEMCPY(preset->presetName, pphdr->presetName, sizeof(preset->presetName));

                preset->presetName[sizeof(preset->presetName)-1] = '\0'; //should be zero terminated in source file but make sure

                preset->bank = pphdr->bank;

                preset->preset = pphdr->preset;

                preset->regionNum = 0;

                //count regions covered by this preset

                for (ppbag = hydra->pbags + pphdr->presetBagNdx, ppbagEnd = hydra->pbags + pphdr[1].presetBagNdx; ppbag != ppbagEnd; ppbag++)

                {

                        unsigned char plokey = 0, phikey = 127, plovel = 0, phivel = 127;

                        struct tsf_hydra_pgen *ppgen, *ppgenEnd; struct tsf_hydra_inst *pinst; struct tsf_hydra_ibag *pibag, *pibagEnd; struct tsf_hydra_igen *pigen, *pigenEnd;

                        for (ppgen = hydra->pgens + ppbag->genNdx, ppgenEnd = hydra->pgens + ppbag[1].genNdx; ppgen != ppgenEnd; ppgen++)