diff options
| author | Mitja Felicijan <mitja.felicijan@gmail.com> | 2024-10-07 05:03:43 +0200 |
|---|---|---|
| committer | Mitja Felicijan <mitja.felicijan@gmail.com> | 2024-10-07 05:03:43 +0200 |
| commit | 9b5839c58a2e1df8bddf6b98805998508ea417d5 (patch) | |
| tree | a01b4a54361e07d4a65b4189f44161f9397e934c /tsf.h | |
| download | ttdaw-9b5839c58a2e1df8bddf6b98805998508ea417d5.tar.gz | |
Engage!
Just some testing if this is even viable
Diffstat (limited to 'tsf.h')
| -rw-r--r-- | tsf.h | 2044 |
1 files changed, 2044 insertions, 0 deletions
@@ -0,0 +1,2044 @@ +/* TinySoundFont - v0.9 - 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-2023 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);
+
+// Copy a tsf instance from an existing one, use tsf_close to close it as well.
+// All copied tsf instances and their original instance are linked, and share the underlying soundfont.
+// This allows loading a soundfont only once, but using it for multiple independent playbacks.
+// (This function isn't thread-safe without locking.)
+TSFDEF tsf* tsf_copy(tsf* f);
+
+// Free the memory related to this tsf instance
+TSFDEF void tsf_close(tsf* f);
+
+// Stop all playing notes immediately 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:
+//
+// 1. Rendering / voices:
+//
+// 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.
+// Alternatively, you can pre-allocate a maximum number of voices that can
+// play simultaneously by calling tsf_set_max_voices after loading.
+// That way memory re-allocation will not happen during tsf_note_on and
+// TSF should become mostly thread safe.
+// There is a theoretical chance that ending notes would negatively influence
+// a voice that is rendering at the time but it is hard to say.
+// Also be aware, this has not been tested much.
+//
+// 2. Channels:
+//
+// Calls to tsf_channel_set_... functions may allocate new channels
+// if no channel with that number was previously used. Make sure to
+// create all channels at the beginning as required if you call tsf_render*
+// from a different thread.
+
+// 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);
+
+// Set the global gain as a volume factor
+// global_gain: the desired volume where 1.0 is 100%
+TSFDEF void tsf_set_volume(tsf* f, float global_gain);
+
+// Set the maximum number of voices to play simultaneously
+// Depending on the soundfond, one note can cause many new voices to be started,
+// so don't keep this number too low or otherwise sounds may not play.
+// max_voices: maximum number to pre-allocate and set the limit to
+// (tsf_set_max_voices returns 0 if allocation failed, otherwise 1)
+TSFDEF int tsf_set_max_voices(tsf* f, int max_voices);
+
+// 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)
+// (tsf_note_on returns 0 if the allocation of a new voice failed, otherwise 1)
+// (tsf_bank_note_on returns 0 if preset does not exist or allocation failed, otherwise 1)
+TSFDEF int 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)
+// (tsf_set_preset_number and set_bank_preset return 0 if preset does not exist, otherwise 1)
+// (tsf_channel_set_... return 0 if a new channel needed allocation and that failed, otherwise 1)
+TSFDEF int 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 int 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 int tsf_channel_set_pan(tsf* f, int channel, float pan);
+TSFDEF int tsf_channel_set_volume(tsf* f, int channel, float volume);
+TSFDEF int tsf_channel_set_pitchwheel(tsf* f, int channel, int pitch_wheel);
+TSFDEF int tsf_channel_set_pitchrange(tsf* f, int channel, float pitch_range);
+TSFDEF int 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)
+// (tsf_channel_note_on returns 0 on allocation failure of new voice, otherwise 1)
+TSFDEF int 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 immediately
+
+// Apply a MIDI control change to the channel (not all controllers are supported!)
+// (tsf_channel_midi_control returns 0 on allocation failure of new channel, otherwise 1)
+TSFDEF int 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
+#undef 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
+
+// When using tsf_render_short, to do the conversion a buffer of a fixed size is
+// allocated on the stack. On low memory platforms this could be made smaller.
+// Increasing this above 512 should not have a significant impact on performance.
+// The value should be a multiple of TSF_RENDER_EFFECTSAMPLEBLOCK.
+#ifndef TSF_RENDER_SHORTBUFFERBLOCK
+#define TSF_RENDER_SHORTBUFFERBLOCK 512
+#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;
+
+ int presetNum;
+ int voiceNum;
+ int maxVoiceNum;
+ unsigned int voicePlayIndex;
+
+ enum TSFOutputMode outputmode;
+ float outSampleRate;
+ float globalGainDB;
+ int* refCount;
+};
+
+#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);
+ int channelNum, activeChannel;
+ struct tsf_channel channels[1];
+};
+
+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 int 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;
+ res->presetNum = hydra->phdrNum - 1;
+ res->presets = (struct tsf_preset*)TSF_MALLOC(res->presetNum * sizeof(struct tsf_preset));
+ if (!res->presets) return 0;
+ else { int i; for (i = 0; i != res->presetNum; i++) res->presets[i].regions = TSF_NULL; }
+ 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++)
+ {
+ if (ppgen->genOper == GenKeyRange) { plokey = ppgen->genAmount.range.lo; phikey = ppgen->genAmount.range.hi; continue; }
+ if (ppgen->genOper == GenVelRange) { plovel = ppgen->genAmount.range.lo; phivel = ppgen->genAmount.range.hi; continue; }
+ if (ppgen->genOper != GenInstrument) continue;
+ if (ppgen->genAmount.wordAmount >= hydra->instNum) continue;
+ pinst = hydra->insts + ppgen->genAmount.wordAmount;
+ for (pibag = hydra->ibags + pinst->instBagNdx, pibagEnd = hydra->ibags + pinst[1].instBagNdx; pibag != pibagEnd; pibag++)
+ {
+ unsigned char ilokey = 0, ihikey = 127, ilovel = 0, ihivel = 127;
+ for (pigen = hydra->igens + pibag->instGenNdx, pigenEnd = hydra->igens + pibag[1].instGenNdx; pigen != pigenEnd; pigen++)
+ {
+ if (pigen->genOper == GenKeyRange) { ilokey = pigen->genAmount.range.lo; ihikey = pigen->genAmount.range.hi; continue; }
+ if (pigen->genOper == GenVelRange) { ilovel = pigen->genAmount.range.lo; ihivel = pigen->genAmount.range.hi; continue; }
+ if (pigen->genOper == GenSampleID && ihikey >= plokey && ilokey <= phikey && ihivel >= plovel && ilovel <= phivel) preset->regionNum++;
+ }
+ }
+ }
+ }
+
+ preset->regions = (struct tsf_region*)TSF_MALLOC(preset->regionNum * sizeof(struct tsf_region));
+ if (!preset->regions)
+ {
+ int i; for (i = 0; i != res->presetNum; i++) TSF_FREE(res->presets[i].regions);
+ TSF_FREE(res->presets);
+ return 0;
+ }
+ tsf_region_clear(&globalRegion, TSF_TRUE);
+
+ // Zones.
+ for (ppbag = hydra->pbags + pphdr->presetBagNdx, ppbagEnd = hydra->pbags + pphdr[1].presetBagNdx; ppbag != ppbagEnd; ppbag++)
+ {
+ struct tsf_hydra_pgen *ppgen, *ppgenEnd; struct tsf_hydra_inst *pinst; struct tsf_hydra_ibag *pibag, *pibagEnd; struct tsf_hydra_igen *pigen, *pigenEnd;
+ struct tsf_region presetRegion = globalRegion;
+ int hadGenInstrument = 0;
+
+ // Generators.
+ for (ppgen = hydra->pgens + ppbag->genNdx, ppgenEnd = hydra->pgens + ppbag[1].genNdx; ppgen != ppgenEnd; ppgen++)
+ {
+ // Instrument.
+ if (ppgen->genOper == GenInstrument)
+ {
+ struct tsf_region instRegion;
+ tsf_u16 whichInst = ppgen->genAmount.wordAmount;
+ if (whichInst >= hydra->instNum) continue;
+
+ tsf_region_clear(&instRegion, TSF_FALSE);
+ pinst = &hydra->insts[whichInst];
+ for (pibag = hydra->ibags + pinst->instBagNdx, pibagEnd = hydra->ibags + pinst[1].instBagNdx; pibag != pibagEnd; pibag++)
+ {
+ // Generators.
+ struct tsf_region zoneRegion = instRegion;
+ int hadSampleID = 0;
+ for (pigen = hydra->igens + pibag->instGenNdx, pigenEnd = hydra->igens + pibag[1].instGenNdx; pigen != pigenEnd; pigen++)
+ {
+ if (pigen->genOper == GenSampleID)
+ {
+ struct tsf_hydra_shdr* pshdr;
+
+ //preset region key and vel ranges are a filter for the zone regions
+ if (zoneRegion.hikey < presetRegion.lokey || zoneRegion.lokey > presetRegion.hikey) continue;
+ if (zoneRegion.hivel < presetRegion.lovel || zoneRegion.lovel > presetRegion.hivel) continue;
+ if (presetRegion.lokey > zoneRegion.lokey) zoneRegion.lokey = presetRegion.lokey;
+ if (presetRegion.hikey < zoneRegion.hikey) zoneRegion.hikey = presetRegion.hikey;
+ if (presetRegion.lovel > zoneRegion.lovel) zoneRegion.lovel = presetRegion.lovel;
+ if (presetRegion.hivel < zoneRegion.hivel) zoneRegion.hivel = presetRegion.hivel;
+
+ //sum regions
+ tsf_region_operator(&zoneRegion, 0, TSF_NULL, &presetRegion);
+
+ // EG times need to be converted from timecents to seconds.
+ tsf_region_envtosecs(&zoneRegion.ampenv, TSF_TRUE);
+ tsf_region_envtosecs(&zoneRegion.modenv, TSF_FALSE);
+
+ // LFO times need to be converted from timecents to seconds.
+ zoneRegion.delayModLFO = (zoneRegion.delayModLFO < -11950.0f ? 0.0f : tsf_timecents2Secsf(zoneRegion.delayModLFO));
+ zoneRegion.delayVibLFO = (zoneRegion.delayVibLFO < -11950.0f ? 0.0f : tsf_timecents2Secsf(zoneRegion.delayVibLFO));
+
+ // Fixup sample positions
+ pshdr = &hydra->shdrs[pigen->genAmount.wordAmount];
+ zoneRegion.offset += pshdr->start;
+ zoneRegion.end += pshdr->end;
+ zoneRegion.loop_start += pshdr->startLoop;
+ zoneRegion.loop_end += pshdr->endLoop;
+ if (pshdr->endLoop > 0) zoneRegion.loop_end -= 1;
+ if (zoneRegion.loop_end > fontSampleCount) zoneRegion.loop_end = fontSampleCount;
+ if (zoneRegion.pitch_keycenter == -1) zoneRegion.pitch_keycenter = pshdr->originalPitch;
+ zoneRegion.tune += pshdr->pitchCorrection;
+ zoneRegion.sample_rate = pshdr->sampleRate;
+ if (zoneRegion.end && zoneRegion.end < fontSampleCount) zoneRegion.end++;
+ else zoneRegion.end = fontSampleCount;
+
+ preset->regions[region_index] = zoneRegion;
+ region_index++;
+ hadSampleID = 1;
+ }
+ else tsf_region_operator(&zoneRegion, pigen->genOper, &pigen->genAmount, TSF_NULL);
+ }
+
+ // Handle instrument's global zone.
+ if (pibag == hydra->ibags + pinst->instBagNdx && !hadSampleID)
+ instRegion = zoneRegion;
+
+ // Modulators (TODO)
+ //if (ibag->instModNdx < ibag[1].instModNdx) addUnsupportedOpcode("any modulator");
+ }
+ hadGenInstrument = 1;
+ }
+ else tsf_region_operator(&presetRegion, ppgen->genOper, &ppgen->genAmount, TSF_NULL);
+ }
+
+ // Modulators (TODO)
+ //if (pbag->modNdx < pbag[1].modNdx) addUnsupportedOpcode("any modulator");
+
+ // Handle preset's global zone.
+ if (ppbag == hydra->pbags + pphdr->presetBagNdx && !hadGenInstrument)
+ globalRegion = presetRegion;
+ }
+ }
+ return 1;
+}
+
+#ifdef STB_VORBIS_INCLUDE_STB_VORBIS_H
+static int tsf_decode_ogg(const tsf_u8 *pSmpl, const tsf_u8 *pSmplEnd, float** pRes, tsf_u32* pResNum, tsf_u32* pResMax, tsf_u32 resInitial)
+{
+ float *res = *pRes, *oldres; tsf_u32 resNum = *pResNum; tsf_u32 resMax = *pResMax; stb_vorbis *v;
+
+ // Use whatever stb_vorbis API that is available (either pull or push)
+ #if !defined(STB_VORBIS_NO_PULLDATA_API) && !defined(STB_VORBIS_NO_FROMMEMORY)
+ v = stb_vorbis_open_memory(pSmpl, (int)(pSmplEnd - pSmpl), TSF_NULL, TSF_NULL);
+ #else
+ { int use, err; v = stb_vorbis_open_pushdata(pSmpl, (int)(pSmplEnd - pSmpl), &use, &err, TSF_NULL); pSmpl += use; }
+ #endif
+ if (v == TSF_NULL) return 0;
+
+ for (;;)
+ {
+ float** outputs; int n_samples;
+
+ // Decode one frame of vorbis samples with whatever stb_vorbis API that is available
+ #if !defined(STB_VORBIS_NO_PULLDATA_API) && !defined(STB_VORBIS_NO_FROMMEMORY)
+ n_samples = stb_vorbis_get_frame_float(v, TSF_NULL, &outputs);
+ if (!n_samples) break;
+ #else
+ if (pSmpl >= pSmplEnd) break;
+ { int use = stb_vorbis_decode_frame_pushdata(v, pSmpl, (int)(pSmplEnd - pSmpl), TSF_NULL, &outputs, &n_samples); pSmpl += use; }
+ if (!n_samples) continue;
+ #endif
+
+ // Expand our output buffer if necessary then copy over the decoded frame samples
+ resNum += n_samples;
+ if (resNum > resMax)
+ {
+ do { resMax += (resMax ? (resMax < 1048576 ? resMax : 1048576) : resInitial); } while (resNum > resMax);
+ res = (float*)TSF_REALLOC((oldres = res), resMax * sizeof(float));
+ if (!res) { TSF_FREE(oldres); stb_vorbis_close(v); return 0; }
+ }
+ TSF_MEMCPY(res + resNum - n_samples, outputs[0], n_samples * sizeof(float));
+ }
+ stb_vorbis_close(v);
+ *pRes = res; *pResNum = resNum; *pResMax = resMax;
+ return 1;
+}
+
+static int tsf_decode_sf3_samples(const void* rawBuffer, float** pFloatBuffer, unsigned int* pSmplCount, struct tsf_hydra *hydra)
+{
+ const tsf_u8* smplBuffer = (const tsf_u8*)rawBuffer;
+ tsf_u32 smplLength = *pSmplCount, resNum = 0, resMax = 0, resInitial = (smplLength > 0x100000 ? (smplLength & ~0xFFFFF) : 65536);
+ float *res = TSF_NULL, *oldres;
+ int i, shdrLast = hydra->shdrNum - 1, is_sf3 = 0;
+ for (i = 0; i <= shdrLast; i++)
+ {
+ struct tsf_hydra_shdr *shdr = &hydra->shdrs[i];
+ if (shdr->sampleType & 0x30) // compression flags (sometimes Vorbis flag)
+ {
+ const tsf_u8 *pSmpl = smplBuffer + shdr->start, *pSmplEnd = smplBuffer + shdr->end;
+ if (pSmpl + 4 > pSmplEnd || !TSF_FourCCEquals(pSmpl, "OggS"))
+ {
+ shdr->start = shdr->end = shdr->startLoop = shdr->endLoop = 0;
+ continue;
+ }
+
+ // Fix up sample indices in shdr (end index is set after decoding)
+ shdr->start = resNum;
+ shdr->startLoop += resNum;
+ shdr->endLoop += resNum;
+ if (!tsf_decode_ogg(pSmpl, pSmplEnd, &res, &resNum, &resMax, resInitial)) { TSF_FREE(res); return 0; }
+ shdr->end = resNum;
+ is_sf3 = 1;
+ }
+ else // raw PCM sample
+ {
+ float *out; short *in = (short*)smplBuffer + resNum, *inEnd; tsf_u32 oldResNum = resNum;
+ if (is_sf3) // Fix up sample indices in shdr
+ {
+ tsf_u32 fix_offset = resNum - shdr->start;
+ in -= fix_offset;
+ shdr->start = resNum;
+ shdr->end += fix_offset;
+ shdr->startLoop += fix_offset;
+ shdr->endLoop += fix_offset;
+ }
+ inEnd = in + ((shdr->end >= shdr->endLoop ? shdr->end : shdr->endLoop) - resNum);
+ if (i == shdrLast || (tsf_u8*)inEnd > (smplBuffer + smplLength)) inEnd = (short*)(smplBuffer + smplLength);
+ if (inEnd <= in) continue;
+
+ // expand our output buffer if necessary then convert the PCM data from short to float
+ resNum += (tsf_u32)(inEnd - in);
+ if (resNum > resMax)
+ {
+ do { resMax += (resMax ? (resMax < 1048576 ? resMax : 1048576) : resInitial); } while (resNum > resMax);
+ res = (float*)TSF_REALLOC((oldres = res), resMax * sizeof(float));
+ if (!res) { TSF_FREE(oldres); return 0; }
+ }
+
+ // Convert the samples from short to float
+ for (out = res + oldResNum; in < inEnd;)
+ *(out++) = (float)(*(in++) / 32767.0);
+ }
+ }
+
+ // Trim the sample buffer down then return success (unless out of memory)
+ if (!(*pFloatBuffer = (float*)TSF_REALLOC(res, resNum * sizeof(float)))) *pFloatBuffer = res;
+ *pSmplCount = resNum;
+ return (res ? 1 : 0);
+}
+#endif
+
+static int tsf_load_samples(void** pRawBuffer, float** pFloatBuffer, unsigned int* pSmplCount, struct tsf_riffchunk *chunkSmpl, struct tsf_stream* stream)
+{
+ #ifdef STB_VORBIS_INCLUDE_STB_VORBIS_H
+ // With OGG Vorbis support we cannot pre-allocate the memory for tsf_decode_sf3_samples
+ tsf_u32 resNum, resMax; float* oldres;
+ *pSmplCount = chunkSmpl->size;
+ *pRawBuffer = (void*)TSF_MALLOC(*pSmplCount);
+ if (!*pRawBuffer || !stream->read(stream->data, *pRawBuffer, chunkSmpl->size)) return 0;
+ if (chunkSmpl->id[3] != 'o') return 1;
+
+ // Decode custom .sfo 'smpo' format where all samples are in a single ogg stream
+ resNum = resMax = 0;
+ if (!tsf_decode_ogg((tsf_u8*)*pRawBuffer, (tsf_u8*)*pRawBuffer + chunkSmpl->size, pFloatBuffer, &resNum, &resMax, 65536)) return 0;
+ if (!(*pFloatBuffer = (float*)TSF_REALLOC((oldres = *pFloatBuffer), resNum * sizeof(float)))) *pFloatBuffer = oldres;
+ *pSmplCount = resNum;
+ return (*pFloatBuffer ? 1 : 0);
+ #else
+ // Inline convert the samples from short to float
+ float *res, *out; const short *in;
+ *pSmplCount = chunkSmpl->size / (unsigned int)sizeof(short);
+ *pFloatBuffer = (float*)TSF_MALLOC(*pSmplCount * sizeof(float));
+ if (!*pFloatBuffer || !stream->read(stream->data, *pFloatBuffer, chunkSmpl->size)) return 0;
+ for (res = *pFloatBuffer, out = res + *pSmplCount, in = (short*)res + *pSmplCount; out != res;)
+ *(--out) = (float)(*(--in) / 32767.0);
+ return 1;
+ #endif
+}
+
+static int tsf_voice_envelope_release_samples(struct tsf_voice_envelope* e, float outSampleRate)
+{
+ return (int)((e->parameters.release <= 0 ? TSF_FASTRELEASETIME : e->parameters.release) * outSampleRate);
+}
+
+static void tsf_voice_envelope_nextsegment(struct tsf_voice_envelope* e, short active_segment, float outSampleRate)
+{
+ switch (active_segment)
+ {
+ case TSF_SEGMENT_NONE:
+ e->samplesUntilNextSegment = (int)(e->parameters.delay * outSampleRate);
+ if (e->samplesUntilNextSegment > 0)
+ {
+ e->segment = TSF_SEGMENT_DELAY;
+ e->segmentIsExponential = TSF_FALSE;
+ e->level = 0.0;
+ e->slope = 0.0;
+ return;
+ }
+ /* fall through */
+ case TSF_SEGMENT_DELAY:
+ e->samplesUntilNextSegment = (int)(e->parameters.attack * outSampleRate);
+ if (e->samplesUntilNextSegment > 0)
+ {
+ if (!e->isAmpEnv)
+ {
+ //mod env attack duration scales with velocity (velocity of 1 is full duration, max velocity is 0.125 times duration)
+ e->samplesUntilNextSegment = (int)(e->parameters.attack * ((145 - e->midiVelocity) / 144.0f) * outSampleRate);
+ }
+ e->segment = TSF_SEGMENT_ATTACK;
+ e->segmentIsExponential = TSF_FALSE;
+ e->level = 0.0f;
+ e->slope = 1.0f / e->samplesUntilNextSegment;
+ return;
+ }
+ /* fall through */
+ case TSF_SEGMENT_ATTACK:
+ e->samplesUntilNextSegment = (int)(e->parameters.hold * outSampleRate);
+ if (e->samplesUntilNextSegment > 0)
+ {
+ e->segment = TSF_SEGMENT_HOLD;
+ e->segmentIsExponential = TSF_FALSE;
+ e->level = 1.0f;
+ e->slope = 0.0f;
+ return;
+ }
+ /* fall through */
+ case TSF_SEGMENT_HOLD:
+ e->samplesUntilNextSegment = (int)(e->parameters.decay * outSampleRate);
+ if (e->samplesUntilNextSegment > 0)
+ {
+ e->segment = TSF_SEGMENT_DECAY;
+ e->level = 1.0f;
+ if (e->isAmpEnv)
+ {
+ // I don't truly understand this; just following what LinuxSampler does.
+ float mysterySlope = -9.226f / e->samplesUntilNextSegment;
+ e->slope = TSF_EXPF(mysterySlope);
+ e->segmentIsExponential = TSF_TRUE;
+ if (e->parameters.sustain > 0.0f)
+ {
+ // Again, this is following LinuxSampler's example, which is similar to
+ // SF2-style decay, where "decay" specifies the time it would take to
+ // get to zero, not to the sustain level. The SFZ spec is not that
+ // specific about what "decay" means, so perhaps it's really supposed
+ // to specify the time to reach the sustain level.
+ e->samplesUntilNextSegment = (int)(TSF_LOG(e->parameters.sustain) / mysterySlope);
+ }
+ }
+ else
+ {
+ e->slope = -1.0f / e->samplesUntilNextSegment;
+ e->samplesUntilNextSegment = (int)(e->parameters.decay * (1.0f - e->parameters.sustain) * outSampleRate);
+ e->segmentIsExponential = TSF_FALSE;
+ }
+ return;
+ }
+ /* fall through */
+ case TSF_SEGMENT_DECAY:
+ e->segment = TSF_SEGMENT_SUSTAIN;
+ e->level = e->parameters.sustain;
+ e->slope = 0.0f;
+ e->samplesUntilNextSegment = 0x7FFFFFFF;
+ e->segmentIsExponential = TSF_FALSE;
+ return;
+ case TSF_SEGMENT_SUSTAIN:
+ e->segment = TSF_SEGMENT_RELEASE;
+ e->samplesUntilNextSegment = tsf_voice_envelope_release_samples(e, outSampleRate);
+ if (e->isAmpEnv)
+ {
+ // I don't truly understand this; just following what LinuxSampler does.
+ float mysterySlope = -9.226f / e->samplesUntilNextSegment;
+ e->slope = TSF_EXPF(mysterySlope);
+ e->segmentIsExponential = TSF_TRUE;
+ }
+ else
+ {
+ e->slope = -e->level / e->samplesUntilNextSegment;
+ e->segmentIsExponential = TSF_FALSE;
+ }
+ return;
+ case TSF_SEGMENT_RELEASE:
+ default:
+ e->segment = TSF_SEGMENT_DONE;
+ e->segmentIsExponential = TSF_FALSE;
+ e->level = e->slope = 0.0f;
+ e->samplesUntilNextSegment = 0x7FFFFFF;
+ }
+}
+
+static void tsf_voice_envelope_setup(struct tsf_voice_envelope* e, struct tsf_envelope* new_parameters, int midiNoteNumber, short midiVelocity, TSF_BOOL isAmpEnv, float outSampleRate)
+{
+ e->parameters = *new_parameters;
+ if (e->parameters.keynumToHold)
+ {
+ e->parameters.hold += e->parameters.keynumToHold * (60.0f - midiNoteNumber);
+ e->parameters.hold = (e->parameters.hold < -10000.0f ? 0.0f : tsf_timecents2Secsf(e->parameters.hold));
+ }
+ if (e->parameters.keynumToDecay)
+ {
+ e->parameters.decay += e->parameters.keynumToDecay * (60.0f - midiNoteNumber);
+ e->parameters.decay = (e->parameters.decay < -10000.0f ? 0.0f : tsf_timecents2Secsf(e->parameters.decay));
+ }
+ e->midiVelocity = midiVelocity;
+ e->isAmpEnv = isAmpEnv;
+ tsf_voice_envelope_nextsegment(e, TSF_SEGMENT_NONE, outSampleRate);
+}
+
+static void tsf_voice_envelope_process(struct tsf_voice_envelope* e, int numSamples, float outSampleRate)
+{
+ if (e->slope)
+ {
+ if (e->segmentIsExponential) e->level *= TSF_POWF(e->slope, (float)numSamples);
+ else e->level += (e->slope * numSamples);
+ }
+ if ((e->samplesUntilNextSegment -= numSamples) <= 0)
+ tsf_voice_envelope_nextsegment(e, e->segment, outSampleRate);
+}
+
+static void tsf_voice_lowpass_setup(struct tsf_voice_lowpass* e, float Fc)
+{
+ // Lowpass filter from http://www.earlevel.com/main/2012/11/26/biquad-c-source-code/
+ double K = TSF_TAN(TSF_PI * Fc), KK = K * K;
+ double norm = 1 / (1 + K * e->QInv + KK);
+ e->a0 = KK * norm;
+ e->a1 = 2 * e->a0;
+ e->b1 = 2 * (KK - 1) * norm;
+ e->b2 = (1 - K * e->QInv + KK) * norm;
+}
+
+static float tsf_voice_lowpass_process(struct tsf_voice_lowpass* e, double In)
+{
+ double Out = In * e->a0 + e->z1; e->z1 = In * e->a1 + e->z2 - e->b1 * Out; e->z2 = In * e->a0 - e->b2 * Out; return (float)Out;
+}
+
+static void tsf_voice_lfo_setup(struct tsf_voice_lfo* e, float delay, int freqCents, float outSampleRate)
+{
+ e->samplesUntil = (int)(delay * outSampleRate);
+ e->delta = (4.0f * tsf_cents2Hertz((float)freqCents) / outSampleRate);
+ e->level = 0;
+}
+
+static void tsf_voice_lfo_process(struct tsf_voice_lfo* e, int blockSamples)
+{
+ if (e->samplesUntil > blockSamples) { e->samplesUntil -= blockSamples; return; }
+ e->level += e->delta * blockSamples;
+ if (e->level > 1.0f) { e->delta = -e->delta; e->level = 2.0f - e->level; }
+ else if (e->level < -1.0f) { e->delta = -e->delta; e->level = -2.0f - e->level; }
+}
+
+static void tsf_voice_kill(struct tsf_voice* v)
+{
+ v->playingPreset = -1;
+}
+
+static void tsf_voice_end(tsf* f, struct tsf_voice* v)
+{
+ // if maxVoiceNum is set, assume that voice rendering and note queuing are on separate threads
+ // so to minimize the chance that voice rendering would advance the segment at the same time
+ // we just do it twice here and hope that it sticks
+ int repeats = (f->maxVoiceNum ? 2 : 1);
+ while (repeats--)
+ {
+ tsf_voice_envelope_nextsegment(&v->ampenv, TSF_SEGMENT_SUSTAIN, f->outSampleRate);
+ tsf_voice_envelope_nextsegment(&v->modenv, TSF_SEGMENT_SUSTAIN, f->outSampleRate);
+ if (v->region->loop_mode == TSF_LOOPMODE_SUSTAIN)
+ {
+ // Continue playing, but stop looping.
+ v->loopEnd = v->loopStart;
+ }
+ }
+}
+
+static void tsf_voice_endquick(tsf* f, struct tsf_voice* v)
+{
+ // if maxVoiceNum is set, assume that voice rendering and note queuing are on separate threads
+ // so to minimize the chance that voice rendering would advance the segment at the same time
+ // we just do it twice here and hope that it sticks
+ int repeats = (f->maxVoiceNum ? 2 : 1);
+ while (repeats--)
+ {
+ v->ampenv.parameters.release = 0.0f; tsf_voice_envelope_nextsegment(&v->ampenv, TSF_SEGMENT_SUSTAIN, f->outSampleRate);
+ v->modenv.parameters.release = 0.0f; tsf_voice_envelope_nextsegment(&v->modenv, TSF_SEGMENT_SUSTAIN, f->outSampleRate);
+ }
+}
+
+static void tsf_voice_calcpitchratio(struct tsf_voice* v, float pitchShift, float outSampleRate)
+{
+ double note = v->playingKey + v->region->transpose + v->region->tune / 100.0;
+ double adjustedPitch = v->region->pitch_keycenter + (note - v->region->pitch_keycenter) * (v->region->pitch_keytrack / 100.0);
+ if (pitchShift) adjustedPitch += pitchShift;
+ v->pitchInputTimecents = adjustedPitch * 100.0;
+ v->pitchOutputFactor = v->region->sample_rate / (tsf_timecents2Secsd(v->region->pitch_keycenter * 100.0) * outSampleRate);
+}
+
+static void tsf_voice_render(tsf* f, struct tsf_voice* v, float* outputBuffer, int numSamples)
+{
+ struct tsf_region* region = v->region;
+ float* input = f->fontSamples;
+ float* outL = outputBuffer;
+ float* outR = (f->outputmode == TSF_STEREO_UNWEAVED ? outL + numSamples : TSF_NULL);
+
+ // Cache some values, to give them at least some chance of ending up in registers.
+ TSF_BOOL updateModEnv = (region->modEnvToPitch || region->modEnvToFilterFc);
+ TSF_BOOL updateModLFO = (v->modlfo.delta && (region->modLfoToPitch || region->modLfoToFilterFc || region->modLfoToVolume));
+ TSF_BOOL updateVibLFO = (v->viblfo.delta && (region->vibLfoToPitch));
+ TSF_BOOL isLooping = (v->loopStart < v->loopEnd);
+ unsigned int tmpLoopStart = v->loopStart, tmpLoopEnd = v->loopEnd;
+ double tmpSampleEndDbl = (double)region->end, tmpLoopEndDbl = (double)tmpLoopEnd + 1.0;
+ double tmpSourceSamplePosition = v->sourceSamplePosition;
+ struct tsf_voice_lowpass tmpLowpass = v->lowpass;
+
+ TSF_BOOL dynamicLowpass = (region->modLfoToFilterFc || region->modEnvToFilterFc);
+ float tmpSampleRate = f->outSampleRate, tmpInitialFilterFc, tmpModLfoToFilterFc, tmpModEnvToFilterFc;
+
+ TSF_BOOL dynamicPitchRatio = (region->modLfoToPitch || region->modEnvToPitch || region->vibLfoToPitch);
+ double pitchRatio;
+ float tmpModLfoToPitch, tmpVibLfoToPitch, tmpModEnvToPitch;
+
+ TSF_BOOL dynamicGain = (region->modLfoToVolume != 0);
+ float noteGain = 0, tmpModLfoToVolume;
+
+ if (dynamicLowpass) tmpInitialFilterFc = (float)region->initialFilterFc, tmpModLfoToFilterFc = (float)region->modLfoToFilterFc, tmpModEnvToFilterFc = (float)region->modEnvToFilterFc;
+ else tmpInitialFilterFc = 0, tmpModLfoToFilterFc = 0, tmpModEnvToFilterFc = 0;
+
+ if (dynamicPitchRatio) pitchRatio = 0, tmpModLfoToPitch = (float)region->modLfoToPitch, tmpVibLfoToPitch = (float)region->vibLfoToPitch, tmpModEnvToPitch = (float)region->modEnvToPitch;
+ else pitchRatio = tsf_timecents2Secsd(v->pitchInputTimecents) * v->pitchOutputFactor, tmpModLfoToPitch = 0, tmpVibLfoToPitch = 0, tmpModEnvToPitch = 0;
+
+ if (dynamicGain) tmpModLfoToVolume = (float)region->modLfoToVolume * 0.1f;
+ else noteGain = tsf_decibelsToGain(v->noteGainDB), tmpModLfoToVolume = 0;
+
+ while (numSamples)
+ {
+ float gainMono, gainLeft, gainRight;
+ int blockSamples = (numSamples > TSF_RENDER_EFFECTSAMPLEBLOCK ? TSF_RENDER_EFFECTSAMPLEBLOCK : numSamples);
+ numSamples -= blockSamples;
+
+ if (dynamicLowpass)
+ {
+ float fres = tmpInitialFilterFc + v->modlfo.level * tmpModLfoToFilterFc + v->modenv.level * tmpModEnvToFilterFc;
+ float lowpassFc = (fres <= 13500 ? tsf_cents2Hertz(fres) / tmpSampleRate : 1.0f);
+ tmpLowpass.active = (lowpassFc < 0.499f);
+ if (tmpLowpass.active) tsf_voice_lowpass_setup(&tmpLowpass, lowpassFc);
+ }
+
+ if (dynamicPitchRatio)
+ pitchRatio = tsf_timecents2Secsd(v->pitchInputTimecents + (v->modlfo.level * tmpModLfoToPitch + v->viblfo.level * tmpVibLfoToPitch + v->modenv.level * tmpModEnvToPitch)) * v->pitchOutputFactor;
+
+ if (dynamicGain)
+ noteGain = tsf_decibelsToGain(v->noteGainDB + (v->modlfo.level * tmpModLfoToVolume));
+
+ gainMono = noteGain * v->ampenv.level;
+
+ // Update EG.
+ tsf_voice_envelope_process(&v->ampenv, blockSamples, tmpSampleRate);
+ if (updateModEnv) tsf_voice_envelope_process(&v->modenv, blockSamples, tmpSampleRate);
+
+ // Update LFOs.
+ if (updateModLFO) tsf_voice_lfo_process(&v->modlfo, blockSamples);
+ if (updateVibLFO) tsf_voice_lfo_process(&v->viblfo, blockSamples);
+
+ switch (f->outputmode)
+ {
+ case TSF_STEREO_INTERLEAVED:
+ gainLeft = gainMono * v->panFactorLeft, gainRight = gainMono * v->panFactorRight;
+ while (blockSamples-- && tmpSourceSamplePosition < tmpSampleEndDbl)
+ {
+ unsigned int pos = (unsigned int)tmpSourceSamplePosition, nextPos = (pos >= tmpLoopEnd && isLooping ? tmpLoopStart : pos + 1);
+
+ // Simple linear interpolation.
+ float alpha = (float)(tmpSourceSamplePosition - pos), val = (input[pos] * (1.0f - alpha) + input[nextPos] * alpha);
+
+ // Low-pass filter.
+ if (tmpLowpass.active) val = tsf_voice_lowpass_process(&tmpLowpass, val);
+
+ *outL++ += val * gainLeft;
+ *outL++ += val * gainRight;
+
+ // Next sample.
+ tmpSourceSamplePosition += pitchRatio;
+ if (tmpSourceSamplePosition >= tmpLoopEndDbl && isLooping) tmpSourceSamplePosition -= (tmpLoopEnd - tmpLoopStart + 1.0);
+ }
+ break;
+
+ case TSF_STEREO_UNWEAVED:
+ gainLeft = gainMono * v->panFactorLeft, gainRight = gainMono * v->panFactorRight;
+ while (blockSamples-- && tmpSourceSamplePosition < tmpSampleEndDbl)
+ {
+ unsigned int pos = (unsigned int)tmpSourceSamplePosition, nextPos = (pos >= tmpLoopEnd && isLooping ? tmpLoopStart : pos + 1);
+
+ // Simple linear interpolation.
+ float alpha = (float)(tmpSourceSamplePosition - pos), val = (input[pos] * (1.0f - alpha) + input[nextPos] * alpha);
+
+ // Low-pass filter.
+ if (tmpLowpass.active) val = tsf_voice_lowpass_process(&tmpLowpass, val);
+
+ *outL++ += val * gainLeft;
+ *outR++ += val * gainRight;
+
+ // Next sample.
+ tmpSourceSamplePosition += pitchRatio;
+ if (tmpSourceSamplePosition >= tmpLoopEndDbl && isLooping) tmpSourceSamplePosition -= (tmpLoopEnd - tmpLoopStart + 1.0);
+ }
+ break;
+
+ case TSF_MONO:
+ while (blockSamples-- && tmpSourceSamplePosition < tmpSampleEndDbl)
+ {
+ unsigned int pos = (unsigned int)tmpSourceSamplePosition, nextPos = (pos >= tmpLoopEnd && isLooping ? tmpLoopStart : pos + 1);
+
+ // Simple linear interpolation.
+ float alpha = (float)(tmpSourceSamplePosition - pos), val = (input[pos] * (1.0f - alpha) + input[nextPos] * alpha);
+
+ // Low-pass filter.
+ if (tmpLowpass.active) val = tsf_voice_lowpass_process(&tmpLowpass, val);
+
+ *outL++ += val * gainMono;
+
+ // Next sample.
+ tmpSourceSamplePosition += pitchRatio;
+ if (tmpSourceSamplePosition >= tmpLoopEndDbl && isLooping) tmpSourceSamplePosition -= (tmpLoopEnd - tmpLoopStart + 1.0);
+ }
+ break;
+ }
+
+ if (tmpSourceSamplePosition >= tmpSampleEndDbl || v->ampenv.segment == TSF_SEGMENT_DONE)
+ {
+ tsf_voice_kill(v);
+ return;
+ }
+ }
+
+ v->sourceSamplePosition = tmpSourceSamplePosition;
+ if (tmpLowpass.active || dynamicLowpass) v->lowpass = tmpLowpass;
+}
+
+TSFDEF tsf* tsf_load(struct tsf_stream* stream)
+{
+ tsf* res = TSF_NULL;
+ struct tsf_riffchunk chunkHead;
+ struct tsf_riffchunk chunkList;
+ struct tsf_hydra hydra;
+ void* rawBuffer = TSF_NULL;
+ float* floatBuffer = TSF_NULL;
+ tsf_u32 smplCount = 0;
+
+ if (!tsf_riffchunk_read(TSF_NULL, &chunkHead, stream) || !TSF_FourCCEquals(chunkHead.id, "sfbk"))
+ {
+ //if (e) *e = TSF_INVALID_NOSF2HEADER;
+ return res;
+ }
+
+ // Read hydra and locate sample data.
+ TSF_MEMSET(&hydra, 0, sizeof(hydra));
+ while (tsf_riffchunk_read(&chunkHead, &chunkList, stream))
+ {
+ struct tsf_riffchunk chunk;
+ if (TSF_FourCCEquals(chunkList.id, "pdta"))
+ {
+ while (tsf_riffchunk_read(&chunkList, &chunk, stream))
+ {
+ #define HandleChunk(chunkName) (TSF_FourCCEquals(chunk.id, #chunkName) && !(chunk.size % chunkName##SizeInFile)) \
+ { \
+ int num = chunk.size / chunkName##SizeInFile, i; \
+ hydra.chunkName##Num = num; \
+ hydra.chunkName##s = (struct tsf_hydra_##chunkName*)TSF_MALLOC(num * sizeof(struct tsf_hydra_##chunkName)); \
+ if (!hydra.chunkName##s) goto out_of_memory; \
+ for (i = 0; i < num; ++i) tsf_hydra_read_##chunkName(&hydra.chunkName##s[i], stream); \
+ }
+ enum
+ {
+ phdrSizeInFile = 38, pbagSizeInFile = 4, pmodSizeInFile = 10,
+ pgenSizeInFile = 4, instSizeInFile = 22, ibagSizeInFile = 4,
+ imodSizeInFile = 10, igenSizeInFile = 4, shdrSizeInFile = 46
+ };
+ if HandleChunk(phdr) else if HandleChunk(pbag) else if HandleChunk(pmod)
+ else if HandleChunk(pgen) else if HandleChunk(inst) else if HandleChunk(ibag)
+ else if HandleChunk(imod) else if HandleChunk(igen) else if HandleChunk(shdr)
+ else stream->skip(stream->data, chunk.size);
+ #undef HandleChunk
+ }
+ }
+ else if (TSF_FourCCEquals(chunkList.id, "sdta"))
+ {
+ while (tsf_riffchunk_read(&chunkList, &chunk, stream))
+ {
+ if ((TSF_FourCCEquals(chunk.id, "smpl")
+ #ifdef STB_VORBIS_INCLUDE_STB_VORBIS_H
+ || TSF_FourCCEquals(chunk.id, "smpo")
+ #endif
+ ) && !rawBuffer && !floatBuffer && chunk.size >= sizeof(short))
+ {
+ if (!tsf_load_samples(&rawBuffer, &floatBuffer, &smplCount, &chunk, stream)) goto out_of_memory;
+ }
+ else stream->skip(stream->data, chunk.size);
+ }
+ }
+ else stream->skip(stream->data, chunkList.size);
+ }
+ if (!hydra.phdrs || !hydra.pbags || !hydra.pmods || !hydra.pgens || !hydra.insts || !hydra.ibags || !hydra.imods || !hydra.igens || !hydra.shdrs)
+ {
+ //if (e) *e = TSF_INVALID_INCOMPLETE;
+ }
+ else if (!rawBuffer && !floatBuffer)
+ {
+ //if (e) *e = TSF_INVALID_NOSAMPLEDATA;
+ }
+ else
+ {
+ #ifdef STB_VORBIS_INCLUDE_STB_VORBIS_H
+ if (!floatBuffer && !tsf_decode_sf3_samples(rawBuffer, &floatBuffer, &smplCount, &hydra)) goto out_of_memory;
+ #endif
+ res = (tsf*)TSF_MALLOC(sizeof(tsf));
+ if (res) TSF_MEMSET(res, 0, sizeof(tsf));
+ if (!res || !tsf_load_presets(res, &hydra, smplCount)) goto out_of_memory;
+ res->outSampleRate = 44100.0f;
+ res->fontSamples = floatBuffer;
+ floatBuffer = TSF_NULL; // don't free below
+ }
+ if (0)
+ {
+ out_of_memory:
+ TSF_FREE(res);
+ res = TSF_NULL;
+ //if (e) *e = TSF_OUT_OF_MEMORY;
+ }
+ TSF_FREE(hydra.phdrs); TSF_FREE(hydra.pbags); TSF_FREE(hydra.pmods);
+ TSF_FREE(hydra.pgens); TSF_FREE(hydra.insts); TSF_FREE(hydra.ibags);
+ TSF_FREE(hydra.imods); TSF_FREE(hydra.igens); TSF_FREE(hydra.shdrs);
+ TSF_FREE(rawBuffer); TSF_FREE(floatBuffer);
+ return res;
+}
+
+TSFDEF tsf* tsf_copy(tsf* f)
+{
+ tsf* res;
+ if (!f) return TSF_NULL;
+ if (!f->refCount)
+ {
+ f->refCount = (int*)TSF_MALLOC(sizeof(int));
+ if (!f->refCount) return TSF_NULL;
+ *f->refCount = 1;
+ }
+ res = (tsf*)TSF_MALLOC(sizeof(tsf));
+ if (!res) return TSF_NULL;
+ TSF_MEMCPY(res, f, sizeof(tsf));
+ res->voices = TSF_NULL;
+ res->voiceNum = 0;
+ res->channels = TSF_NULL;
+ (*res->refCount)++;
+ return res;
+}
+
+TSFDEF void tsf_close(tsf* f)
+{
+ if (!f) return;
+ if (!f->refCount || !--(*f->refCount))
+ {
+ struct tsf_preset *preset = f->presets, *presetEnd = preset + f->presetNum;
+ for (; preset != presetEnd; preset++) TSF_FREE(preset->regions);
+ TSF_FREE(f->presets);
+ TSF_FREE(f->fontSamples);
+ TSF_FREE(f->refCount);
+ }
+ TSF_FREE(f->channels);
+ TSF_FREE(f->voices);
+ TSF_FREE(f);
+}
+
+TSFDEF void tsf_reset(tsf* f)
+{
+ struct tsf_voice *v = f->voices, *vEnd = v + f->voiceNum;
+ for (; v != vEnd; v++)
+ if (v->playingPreset != -1 && (v->ampenv.segment < TSF_SEGMENT_RELEASE || v->ampenv.parameters.release))
+ tsf_voice_endquick(f, v);
+ if (f->channels) { TSF_FREE(f->channels); f->channels = TSF_NULL; }
+}
+
+TSFDEF int tsf_get_presetindex(const tsf* f, int bank, int preset_number)
+{
+ const struct tsf_preset *presets;
+ int i, iMax;
+ for (presets = f->presets, i = 0, iMax = f->presetNum; i < iMax; i++)
+ if (presets[i].preset == preset_number && presets[i].bank == bank)
+ return i;
+ return -1;
+}
+
+TSFDEF int tsf_get_presetcount(const tsf* f)
+{
+ return f->presetNum;
+}
+
+TSFDEF const char* tsf_get_presetname(const tsf* f, int preset)
+{
+ return (preset < 0 || preset >= f->presetNum ? TSF_NULL : f->presets[preset].presetName);
+}
+
+TSFDEF const char* tsf_bank_get_presetname(const tsf* f, int bank, int preset_number)
+{
+ return tsf_get_presetname(f, tsf_get_presetindex(f, bank, preset_number));
+}
+
+TSFDEF void tsf_set_output(tsf* f, enum TSFOutputMode outputmode, int samplerate, float global_gain_db)
+{
+ f->outputmode = outputmode;
+ f->outSampleRate = (float)(samplerate >= 1 ? samplerate : 44100.0f);
+ f->globalGainDB = global_gain_db;
+}
+
+TSFDEF void tsf_set_volume(tsf* f, float global_volume)
+{
+ f->globalGainDB = (global_volume == 1.0f ? 0 : -tsf_gainToDecibels(1.0f / global_volume));
+}
+
+TSFDEF int tsf_set_max_voices(tsf* f, int max_voices)
+{
+ int i = f->voiceNum;
+ int newVoiceNum = (f->voiceNum > max_voices ? f->voiceNum : max_voices);
+ struct tsf_voice *newVoices = (struct tsf_voice*)TSF_REALLOC(f->voices, newVoiceNum * sizeof(struct tsf_voice));
+ if (!newVoices) return 0;
+ f->voices = newVoices;
+ f->voiceNum = f->maxVoiceNum = newVoiceNum;
+ for (; i < max_voices; i++)
+ f->voices[i].playingPreset = -1;
+ return 1;
+}
+
+TSFDEF int tsf_note_on(tsf* f, int preset_index, int key, float vel)
+{
+ short midiVelocity = (short)(vel * 127);
+ int voicePlayIndex;
+ struct tsf_region *region, *regionEnd;
+
+ if (preset_index < 0 || preset_index >= f->presetNum) return 1;
+ if (vel <= 0.0f) { tsf_note_off(f, preset_index, key); return 1; }
+
+ // Play all matching regions.
+ voicePlayIndex = f->voicePlayIndex++;
+ for (region = f->presets[preset_index].regions, regionEnd = region + f->presets[preset_index].regionNum; region != regionEnd; region++)
+ {
+ struct tsf_voice *voice, *v, *vEnd; TSF_BOOL doLoop; float lowpassFilterQDB, lowpassFc;
+ if (key < region->lokey || key > region->hikey || midiVelocity < region->lovel || midiVelocity > region->hivel) continue;
+
+ voice = TSF_NULL, v = f->voices, vEnd = v + f->voiceNum;
+ if (region->group)
+ {
+ for (; v != vEnd; v++)
+ if (v->playingPreset == preset_index && v->region->group == region->group) tsf_voice_endquick(f, v);
+ else if (v->playingPreset == -1 && !voice) voice = v;
+ }
+ else for (; v != vEnd; v++) if (v->playingPreset == -1) { voice = v; break; }
+
+ if (!voice)
+ {
+ if (f->maxVoiceNum)
+ {
+ // Voices have been pre-allocated and limited to a maximum, try to kill a voice off in its release envelope
+ int bestKillReleaseSamplePos = -999999999;
+ for (v = f->voices; v != vEnd; v++)
+ {
+ if (v->ampenv.segment == TSF_SEGMENT_RELEASE)
+ {
+ // We're looking for the voice furthest into its release
+ int releaseSamplesDone = tsf_voice_envelope_release_samples(&v->ampenv, f->outSampleRate) - v->ampenv.samplesUntilNextSegment;
+ if (releaseSamplesDone > bestKillReleaseSamplePos)
+ {
+ bestKillReleaseSamplePos = releaseSamplesDone;
+ voice = v;
+ }
+ }
+ }
+ if (!voice)
+ continue;
+ tsf_voice_kill(voice);
+ }
+ else
+ {
+ // Allocate more voices so we don't need to kill one off.
+ struct tsf_voice* newVoices;
+ f->voiceNum += 4;
+ newVoices = (struct tsf_voice*)TSF_REALLOC(f->voices, f->voiceNum * sizeof(struct tsf_voice));
+ if (!newVoices) return 0;
+ f->voices = newVoices;
+ voice = &f->voices[f->voiceNum - 4];
+ voice[1].playingPreset = voice[2].playingPreset = voice[3].playingPreset = -1;
+ }
+ }
+
+ voice->region = region;
+ voice->playingPreset = preset_index;
+ voice->playingKey = key;
+ voice->playIndex = voicePlayIndex;
+ voice->noteGainDB = f->globalGainDB - region->attenuation - tsf_gainToDecibels(1.0f / vel);
+
+ if (f->channels)
+ {
+ f->channels->setupVoice(f, voice);
+ }
+ else
+ {
+ tsf_voice_calcpitchratio(voice, 0, f->outSampleRate);
+ // The SFZ spec is silent about the pan curve, but a 3dB pan law seems common. This sqrt() curve matches what Dimension LE does; Alchemy Free seems closer to sin(adjustedPan * pi/2).
+ voice->panFactorLeft = TSF_SQRTF(0.5f - region->pan);
+ voice->panFactorRight = TSF_SQRTF(0.5f + region->pan);
+ }
+
+ // Offset/end.
+ voice->sourceSamplePosition = region->offset;
+
+ // Loop.
+ doLoop = (region->loop_mode != TSF_LOOPMODE_NONE && region->loop_start < region->loop_end);
+ voice->loopStart = (doLoop ? region->loop_start : 0);
+ voice->loopEnd = (doLoop ? region->loop_end : 0);
+
+ // Setup envelopes.
+ tsf_voice_envelope_setup(&voice->ampenv, ®ion->ampenv, key, midiVelocity, TSF_TRUE, f->outSampleRate);
+ tsf_voice_envelope_setup(&voice->modenv, ®ion->modenv, key, midiVelocity, TSF_FALSE, f->outSampleRate);
+
+ // Setup lowpass filter.
+ lowpassFc = (region->initialFilterFc <= 13500 ? tsf_cents2Hertz((float)region->initialFilterFc) / f->outSampleRate : 1.0f);
+ lowpassFilterQDB = region->initialFilterQ / 10.0f;
+ voice->lowpass.QInv = 1.0 / TSF_POW(10.0, (lowpassFilterQDB / 20.0));
+ voice->lowpass.z1 = voice->lowpass.z2 = 0;
+ voice->lowpass.active = (lowpassFc < 0.499f);
+ if (voice->lowpass.active) tsf_voice_lowpass_setup(&voice->lowpass, lowpassFc);
+
+ // Setup LFO filters.
+ tsf_voice_lfo_setup(&voice->modlfo, region->delayModLFO, region->freqModLFO, f->outSampleRate);
+ tsf_voice_lfo_setup(&voice->viblfo, region->delayVibLFO, region->freqVibLFO, f->outSampleRate);
+ }
+ return 1;
+}
+
+TSFDEF int tsf_bank_note_on(tsf* f, int bank, int preset_number, int key, float vel)
+{
+ int preset_index = tsf_get_presetindex(f, bank, preset_number);
+ if (preset_index == -1) return 0;
+ return tsf_note_on(f, preset_index, key, vel);
+}
+
+TSFDEF void tsf_note_off(tsf* f, int preset_index, int key)
+{
+ struct tsf_voice *v = f->voices, *vEnd = v + f->voiceNum, *vMatchFirst = TSF_NULL, *vMatchLast = TSF_NULL;
+ for (; v != vEnd; v++)
+ {
+ //Find the first and last entry in the voices list with matching preset, key and look up the smallest play index
+ if (v->playingPreset != preset_index || v->playingKey != key || v->ampenv.segment >= TSF_SEGMENT_RELEASE) continue;
+ else if (!vMatchFirst || v->playIndex < vMatchFirst->playIndex) vMatchFirst = vMatchLast = v;
+ else if (v->playIndex == vMatchFirst->playIndex) vMatchLast = v;
+ }
+ if (!vMatchFirst) return;
+ for (v = vMatchFirst; v <= vMatchLast; v++)
+ {
+ //Stop all voices with matching preset, key and the smallest play index which was enumerated above
+ if (v != vMatchFirst && v != vMatchLast &&
+ (v->playIndex != vMatchFirst->playIndex || v->playingPreset != preset_index || v->playingKey != key || v->ampenv.segment >= TSF_SEGMENT_RELEASE)) continue;
+ tsf_voice_end(f, v);
+ }
+}
+
+TSFDEF int tsf_bank_note_off(tsf* f, int bank, int preset_number, int key)
+{
+ int preset_index = tsf_get_presetindex(f, bank, preset_number);
+ if (preset_index == -1) return 0;
+ tsf_note_off(f, preset_index, key);
+ return 1;
+}
+
+TSFDEF void tsf_note_off_all(tsf* f)
+{
+ struct tsf_voice *v = f->voices, *vEnd = v + f->voiceNum;
+ for (; v != vEnd; v++) if (v->playingPreset != -1 && v->ampenv.segment < TSF_SEGMENT_RELEASE)
+ tsf_voice_end(f, v);
+}
+
+TSFDEF int tsf_active_voice_count(tsf* f)
+{
+ int count = 0;
+ struct tsf_voice *v = f->voices, *vEnd = v + f->voiceNum;
+ for (; v != vEnd; v++) if (v->playingPreset != -1) count++;
+ return count;
+}
+
+TSFDEF void tsf_render_short(tsf* f, short* buffer, int samples, int flag_mixing)
+{
+ float outputSamples[TSF_RENDER_SHORTBUFFERBLOCK];
+ int channels = (f->outputmode == TSF_MONO ? 1 : 2), maxChannelSamples = TSF_RENDER_SHORTBUFFERBLOCK / channels;
+ while (samples > 0)
+ {
+ int channelSamples = (samples > maxChannelSamples ? maxChannelSamples : samples);
+ short* bufferEnd = buffer + channelSamples * channels;
+ float *floatSamples = outputSamples;
+ tsf_render_float(f, floatSamples, channelSamples, TSF_FALSE);
+ samples -= channelSamples;
+
+ if (flag_mixing)
+ while (buffer != bufferEnd)
+ {
+ float v = *floatSamples++;
+ int vi = *buffer + (v < -1.00004566f ? (int)-32768 : (v > 1.00001514f ? (int)32767 : (int)(v * 32767.5f)));
+ *buffer++ = (vi < -32768 ? (short)-32768 : (vi > 32767 ? (short)32767 : (short)vi));
+ }
+ else
+ while (buffer != bufferEnd)
+ {
+ float v = *floatSamples++;
+ *buffer++ = (v < -1.00004566f ? (short)-32768 : (v > 1.00001514f ? (short)32767 : (short)(v * 32767.5f)));
+ }
+ }
+}
+
+TSFDEF void tsf_render_float(tsf* f, float* buffer, int samples, int flag_mixing)
+{
+ struct tsf_voice *v = f->voices, *vEnd = v + f->voiceNum;
+ if (!flag_mixing) TSF_MEMSET(buffer, 0, (f->outputmode == TSF_MONO ? 1 : 2) * sizeof(float) * samples);
+ for (; v != vEnd; v++)
+ if (v->playingPreset != -1)
+ tsf_voice_render(f, v, buffer, samples);
+}
+
+static void tsf_channel_setup_voice(tsf* f, struct tsf_voice* v)
+{
+ struct tsf_channel* c = &f->channels->channels[f->channels->activeChannel];
+ float newpan = v->region->pan + c->panOffset;
+ v->playingChannel = f->channels->activeChannel;
+ v->noteGainDB += c->gainDB;
+ tsf_voice_calcpitchratio(v, (c->pitchWheel == 8192 ? c->tuning : ((c->pitchWheel / 16383.0f * c->pitchRange * 2.0f) - c->pitchRange + c->tuning)), f->outSampleRate);
+ if (newpan <= -0.5f) { v->panFactorLeft = 1.0f; v->panFactorRight = 0.0f; }
+ else if (newpan >= 0.5f) { v->panFactorLeft = 0.0f; v->panFactorRight = 1.0f; }
+ else { v->panFactorLeft = TSF_SQRTF(0.5f - newpan); v->panFactorRight = TSF_SQRTF(0.5f + newpan); }
+}
+
+static struct tsf_channel* tsf_channel_init(tsf* f, int channel)
+{
+ int i;
+ if (f->channels && channel < f->channels->channelNum) return &f->channels->channels[channel];
+ if (!f->channels)
+ {
+ f->channels = (struct tsf_channels*)TSF_MALLOC(sizeof(struct tsf_channels) + sizeof(struct tsf_channel) * channel);
+ if (!f->channels) return TSF_NULL;
+ f->channels->setupVoice = &tsf_channel_setup_voice;
+ f->channels->channelNum = 0;
+ f->channels->activeChannel = 0;
+ }
+ else
+ {
+ struct tsf_channels *newChannels = (struct tsf_channels*)TSF_REALLOC(f->channels, sizeof(struct tsf_channels) + sizeof(struct tsf_channel) * channel);
+ if (!newChannels) return TSF_NULL;
+ f->channels = newChannels;
+ }
+ i = f->channels->channelNum;
+ f->channels->channelNum = channel + 1;
+ for (; i <= channel; i++)
+ {
+ struct tsf_channel* c = &f->channels->channels[i];
+ c->presetIndex = c->bank = 0;
+ c->pitchWheel = c->midiPan = 8192;
+ c->midiVolume = c->midiExpression = 16383;
+ c->midiRPN = 0xFFFF;
+ c->midiData = 0;
+ c->panOffset = 0.0f;
+ c->gainDB = 0.0f;
+ c->pitchRange = 2.0f;
+ c->tuning = 0.0f;
+ }
+ return &f->channels->channels[channel];
+}
+
+static void tsf_channel_applypitch(tsf* f, int channel, struct tsf_channel* c)
+{
+ struct tsf_voice *v, *vEnd;
+ float pitchShift = (c->pitchWheel == 8192 ? c->tuning : ((c->pitchWheel / 16383.0f * c->pitchRange * 2.0f) - c->pitchRange + c->tuning));
+ for (v = f->voices, vEnd = v + f->voiceNum; v != vEnd; v++)
+ if (v->playingPreset != -1 && v->playingChannel == channel)
+ tsf_voice_calcpitchratio(v, pitchShift, f->outSampleRate);
+}
+
+TSFDEF int tsf_channel_set_presetindex(tsf* f, int channel, int preset_index)
+{
+ struct tsf_channel *c = tsf_channel_init(f, channel);
+ if (!c) return 0;
+ c->presetIndex = (unsigned short)preset_index;
+ return 1;
+}
+
+TSFDEF int tsf_channel_set_presetnumber(tsf* f, int channel, int preset_number, int flag_mididrums)
+{
+ int preset_index;
+ struct tsf_channel *c = tsf_channel_init(f, channel);
+ if (!c) return 0;
+ if (flag_mididrums)
+ {
+ preset_index = tsf_get_presetindex(f, 128 | (c->bank & 0x7FFF), preset_number);
+ if (preset_index == -1) preset_index = tsf_get_presetindex(f, 128, preset_number);
+ if (preset_index == -1) preset_index = tsf_get_presetindex(f, 128, 0);
+ if (preset_index == -1) preset_index = tsf_get_presetindex(f, (c->bank & 0x7FFF), preset_number);
+ }
+ else preset_index = tsf_get_presetindex(f, (c->bank & 0x7FFF), preset_number);
+ if (preset_index == -1) preset_index = tsf_get_presetindex(f, 0, preset_number);
+ if (preset_index != -1)
+ {
+ c->presetIndex = (unsigned short)preset_index;
+ return 1;
+ }
+ return 0;
+}
+
+TSFDEF int tsf_channel_set_bank(tsf* f, int channel, int bank)
+{
+ struct tsf_channel *c = tsf_channel_init(f, channel);
+ if (!c) return 0;
+ c->bank = (unsigned short)bank;
+ return 1;
+}
+
+TSFDEF int tsf_channel_set_bank_preset(tsf* f, int channel, int bank, int preset_number)
+{
+ int preset_index;
+ struct tsf_channel *c = tsf_channel_init(f, channel);
+ if (!c) return 0;
+ preset_index = tsf_get_presetindex(f, bank, preset_number);
+ if (preset_index == -1) return 0;
+ c->presetIndex = (unsigned short)preset_index;
+ c->bank = (unsigned short)bank;
+ return 1;
+}
+
+TSFDEF int tsf_channel_set_pan(tsf* f, int channel, float pan)
+{
+ struct tsf_voice *v, *vEnd;
+ struct tsf_channel *c = tsf_channel_init(f, channel);
+ if (!c) return 0;
+ for (v = f->voices, vEnd = v + f->voiceNum; v != vEnd; v++)
+ if (v->playingChannel == channel && v->playingPreset != -1)
+ {
+ float newpan = v->region->pan + pan - 0.5f;
+ if (newpan <= -0.5f) { v->panFactorLeft = 1.0f; v->panFactorRight = 0.0f; }
+ else if (newpan >= 0.5f) { v->panFactorLeft = 0.0f; v->panFactorRight = 1.0f; }
+ else { v->panFactorLeft = TSF_SQRTF(0.5f - newpan); v->panFactorRight = TSF_SQRTF(0.5f + newpan); }
+ }
+ c->panOffset = pan - 0.5f;
+ return 1;
+}
+
+TSFDEF int tsf_channel_set_volume(tsf* f, int channel, float volume)
+{
+ float gainDB = tsf_gainToDecibels(volume), gainDBChange;
+ struct tsf_voice *v, *vEnd;
+ struct tsf_channel *c = tsf_channel_init(f, channel);
+ if (!c) return 0;
+ if (gainDB == c->gainDB) return 1;
+ for (v = f->voices, vEnd = v + f->voiceNum, gainDBChange = gainDB - c->gainDB; v != vEnd; v++)
+ if (v->playingPreset != -1 && v->playingChannel == channel)
+ v->noteGainDB += gainDBChange;
+ c->gainDB = gainDB;
+ return 1;
+}
+
+TSFDEF int tsf_channel_set_pitchwheel(tsf* f, int channel, int pitch_wheel)
+{
+ struct tsf_channel *c = tsf_channel_init(f, channel);
+ if (!c) return 0;
+ if (c->pitchWheel == pitch_wheel) return 1;
+ c->pitchWheel = (unsigned short)pitch_wheel;
+ tsf_channel_applypitch(f, channel, c);
+ return 1;
+}
+
+TSFDEF int tsf_channel_set_pitchrange(tsf* f, int channel, float pitch_range)
+{
+ struct tsf_channel *c = tsf_channel_init(f, channel);
+ if (!c) return 0;
+ if (c->pitchRange == pitch_range) return 1;
+ c->pitchRange = pitch_range;
+ if (c->pitchWheel != 8192) tsf_channel_applypitch(f, channel, c);
+ return 1;
+}
+
+TSFDEF int tsf_channel_set_tuning(tsf* f, int channel, float tuning)
+{
+ struct tsf_channel *c = tsf_channel_init(f, channel);
+ if (!c) return 0;
+ if (c->tuning == tuning) return 1;
+ c->tuning = tuning;
+ tsf_channel_applypitch(f, channel, c);
+ return 1;
+}
+
+TSFDEF int tsf_channel_note_on(tsf* f, int channel, int key, float vel)
+{
+ if (!f->channels || channel >= f->channels->channelNum) return 1;
+ f->channels->activeChannel = channel;
+ return tsf_note_on(f, f->channels->channels[channel].presetIndex, key, vel);
+}
+
+TSFDEF void tsf_channel_note_off(tsf* f, int channel, int key)
+{
+ struct tsf_voice *v = f->voices, *vEnd = v + f->voiceNum, *vMatchFirst = TSF_NULL, *vMatchLast = TSF_NULL;
+ for (; v != vEnd; v++)
+ {
+ //Find the first and last entry in the voices list with matching channel, key and look up the smallest play index
+ if (v->playingPreset == -1 || v->playingChannel != channel || v->playingKey != key || v->ampenv.segment >= TSF_SEGMENT_RELEASE) continue;
+ else if (!vMatchFirst || v->playIndex < vMatchFirst->playIndex) vMatchFirst = vMatchLast = v;
+ else if (v->playIndex == vMatchFirst->playIndex) vMatchLast = v;
+ }
+ if (!vMatchFirst) return;
+ for (v = vMatchFirst; v <= vMatchLast; v++)
+ {
+ //Stop all voices with matching channel, key and the smallest play index which was enumerated above
+ if (v != vMatchFirst && v != vMatchLast &&
+ (v->playIndex != vMatchFirst->playIndex || v->playingPreset == -1 || v->playingChannel != channel || v->playingKey != key || v->ampenv.segment >= TSF_SEGMENT_RELEASE)) continue;
+ tsf_voice_end(f, v);
+ }
+}
+
+TSFDEF void tsf_channel_note_off_all(tsf* f, int channel)
+{
+ struct tsf_voice *v = f->voices, *vEnd = v + f->voiceNum;
+ for (; v != vEnd; v++)
+ if (v->playingPreset != -1 && v->playingChannel == channel && v->ampenv.segment < TSF_SEGMENT_RELEASE)
+ tsf_voice_end(f, v);
+}
+
+TSFDEF void tsf_channel_sounds_off_all(tsf* f, int channel)
+{
+ struct tsf_voice *v = f->voices, *vEnd = v + f->voiceNum;
+ for (; v != vEnd; v++)
+ if (v->playingPreset != -1 && v->playingChannel == channel && (v->ampenv.segment < TSF_SEGMENT_RELEASE || v->ampenv.parameters.release))
+ tsf_voice_endquick(f, v);
+}
+
+TSFDEF int tsf_channel_midi_control(tsf* f, int channel, int controller, int control_value)
+{
+ struct tsf_channel* c = tsf_channel_init(f, channel);
+ if (!c) return 0;
+ switch (controller)
+ {
+ case 7 /*VOLUME_MSB*/ : c->midiVolume = (unsigned short)((c->midiVolume & 0x7F ) | (control_value << 7)); goto TCMC_SET_VOLUME;
+ case 39 /*VOLUME_LSB*/ : c->midiVolume = (unsigned short)((c->midiVolume & 0x3F80) | control_value); goto TCMC_SET_VOLUME;
+ case 11 /*EXPRESSION_MSB*/ : c->midiExpression = (unsigned short)((c->midiExpression & 0x7F ) | (control_value << 7)); goto TCMC_SET_VOLUME;
+ case 43 /*EXPRESSION_LSB*/ : c->midiExpression = (unsigned short)((c->midiExpression & 0x3F80) | control_value); goto TCMC_SET_VOLUME;
+ case 10 /*PAN_MSB*/ : c->midiPan = (unsigned short)((c->midiPan & 0x7F ) | (control_value << 7)); goto TCMC_SET_PAN;
+ case 42 /*PAN_LSB*/ : c->midiPan = (unsigned short)((c->midiPan & 0x3F80) | control_value); goto TCMC_SET_PAN;
+ case 6 /*DATA_ENTRY_MSB*/ : c->midiData = (unsigned short)((c->midiData & 0x7F) | (control_value << 7)); goto TCMC_SET_DATA;
+ case 38 /*DATA_ENTRY_LSB*/ : c->midiData = (unsigned short)((c->midiData & 0x3F80) | control_value); goto TCMC_SET_DATA;
+ case 0 /*BANK_SELECT_MSB*/ : c->bank = (unsigned short)(0x8000 | control_value); return 1; //bank select MSB alone acts like LSB
+ case 32 /*BANK_SELECT_LSB*/ : c->bank = (unsigned short)((c->bank & 0x8000 ? ((c->bank & 0x7F) << 7) : 0) | control_value); return 1;
+ case 101 /*RPN_MSB*/ : c->midiRPN = (unsigned short)(((c->midiRPN == 0xFFFF ? 0 : c->midiRPN) & 0x7F ) | (control_value << 7)); return 1;
+ case 100 /*RPN_LSB*/ : c->midiRPN = (unsigned short)(((c->midiRPN == 0xFFFF ? 0 : c->midiRPN) & 0x3F80) | control_value); return 1;
+ case 98 /*NRPN_LSB*/ : c->midiRPN = 0xFFFF; return 1;
+ case 99 /*NRPN_MSB*/ : c->midiRPN = 0xFFFF; return 1;
+ case 120 /*ALL_SOUND_OFF*/ : tsf_channel_sounds_off_all(f, channel); return 1;
+ case 123 /*ALL_NOTES_OFF*/ : tsf_channel_note_off_all(f, channel); return 1;
+ case 121 /*ALL_CTRL_OFF*/ :
+ c->midiVolume = c->midiExpression = 16383;
+ c->midiPan = 8192;
+ c->bank = 0;
+ c->midiRPN = 0xFFFF;
+ c->midiData = 0;
+ tsf_channel_set_volume(f, channel, 1.0f);
+ tsf_channel_set_pan(f, channel, 0.5f);
+ tsf_channel_set_pitchrange(f, channel, 2.0f);
+ tsf_channel_set_tuning(f, channel, 0);
+ return 1;
+ }
+ return 1;
+TCMC_SET_VOLUME:
+ //Raising to the power of 3 seems to result in a decent sounding volume curve for MIDI
+ tsf_channel_set_volume(f, channel, TSF_POWF((c->midiVolume / 16383.0f) * (c->midiExpression / 16383.0f), 3.0f));
+ return 1;
+TCMC_SET_PAN:
+ tsf_channel_set_pan(f, channel, c->midiPan / 16383.0f);
+ return 1;
+TCMC_SET_DATA:
+ if (c->midiRPN == 0) tsf_channel_set_pitchrange(f, channel, (c->midiData >> 7) + 0.01f * (c->midiData & 0x7F));
+ else if (c->midiRPN == 1) tsf_channel_set_tuning(f, channel, (int)c->tuning + ((float)c->midiData - 8192.0f) / 8192.0f); //fine tune
+ else if (c->midiRPN == 2 && controller == 6) tsf_channel_set_tuning(f, channel, ((float)control_value - 64.0f) + (c->tuning - (int)c->tuning)); //coarse tune
+ return 1;
+}
+
+TSFDEF int tsf_channel_get_preset_index(tsf* f, int channel)
+{
+ return (f->channels && channel < f->channels->channelNum ? f->channels->channels[channel].presetIndex : 0);
+}
+
+TSFDEF int tsf_channel_get_preset_bank(tsf* f, int channel)
+{
+ return (f->channels && channel < f->channels->channelNum ? (f->channels->channels[channel].bank & 0x7FFF) : 0);
+}
+
+TSFDEF int tsf_channel_get_preset_number(tsf* f, int channel)
+{
+ return (f->channels && channel < f->channels->channelNum ? f->presets[f->channels->channels[channel].presetIndex].preset : 0);
+}
+
+TSFDEF float tsf_channel_get_pan(tsf* f, int channel)
+{
+ return (f->channels && channel < f->channels->channelNum ? f->channels->channels[channel].panOffset - 0.5f : 0.5f);
+}
+
+TSFDEF float tsf_channel_get_volume(tsf* f, int channel)
+{
+ return (f->channels && channel < f->channels->channelNum ? tsf_decibelsToGain(f->channels->channels[channel].gainDB) : 1.0f);
+}
+
+TSFDEF int tsf_channel_get_pitchwheel(tsf* f, int channel)
+{
+ return (f->channels && channel < f->channels->channelNum ? f->channels->channels[channel].pitchWheel : 8192);
+}
+
+TSFDEF float tsf_channel_get_pitchrange(tsf* f, int channel)
+{
+ return (f->channels && channel < f->channels->channelNum ? f->channels->channels[channel].pitchRange : 2.0f);
+}
+
+TSFDEF float tsf_channel_get_tuning(tsf* f, int channel)
+{
+ return (f->channels && channel < f->channels->channelNum ? f->channels->channels[channel].tuning : 0.0f);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //TSF_IMPLEMENTATION
|