-
-
Notifications
You must be signed in to change notification settings - Fork 81
/
Copy pathtsf.h
2076 lines (1859 loc) · 90.5 KB
/
tsf.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* 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-2025 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)
// flag_sustain: 0 to end notes that were held sustained and disable holding sustain otherwise enable it
// (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);
TSFDEF int tsf_channel_set_sustain(tsf* f, int channel, int flag_sustain);
// 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 unsigned 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 { unsigned char segment, segmentIsExponential : 1, isAmpEnv : 1; short midiVelocity; float level, slope; int samplesUntilNextSegment; struct tsf_envelope parameters; };
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, heldSustain;
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 : 14, sustain : 1;
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.01f; vmin = 0.0f; vmax = 14.4f; 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;
(void)pRawBuffer;
*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
}