Alc/midi/fluidsynth.c

   1
   2 #include "config.h"
   3
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include <limits.h>
   7
   8 #include "midi/base.h"
   9
  10 #include "alMain.h"
  11 #include "alError.h"
  12 #include "alMidi.h"
  13 #include "evtqueue.h"
  14 #include "rwlock.h"
  15 #include "alu.h"
  16
  17 #ifdef HAVE_FLUIDSYNTH
  18
  19 #include <fluidsynth.h>
  20
  21
  22 /* MIDI events */
  23 #define SYSEX_EVENT  (0xF0)
  24
  25 /* MIDI controllers */
  26 #define CTRL_BANKSELECT_MSB  (0)
  27 #define CTRL_BANKSELECT_LSB  (32)
  28 #define CTRL_ALLNOTESOFF     (123)
  29
  30
  31 static int getGenInput(ALenum input)
  32 {
  33     switch(input)
  34     {
  35         case AL_ONE_SOFT: return FLUID_MOD_NONE;
  36         case AL_NOTEON_VELOCITY_SOFT: return FLUID_MOD_VELOCITY;
  37         case AL_NOTEON_KEY_SOFT: return FLUID_MOD_KEY;
  38         case AL_KEYPRESSURE_SOFT: return FLUID_MOD_KEYPRESSURE;
  39         case AL_CHANNELPRESSURE_SOFT: return FLUID_MOD_CHANNELPRESSURE;
  40         case AL_PITCHBEND_SOFT: return FLUID_MOD_PITCHWHEEL;
  41         case AL_PITCHBEND_SENSITIVITY_SOFT: return FLUID_MOD_PITCHWHEELSENS;
  42     }
  43     return input&0x7F;
  44 }
  45
  46 static int getGenFlags(ALenum input, ALenum type, ALenum form)
  47 {
  48     int ret = 0;
  49
  50     switch(type)
  51     {
  52         case AL_UNORM_SOFT: ret |= FLUID_MOD_UNIPOLAR | FLUID_MOD_POSITIVE; break;
  53         case AL_UNORM_REV_SOFT: ret |= FLUID_MOD_UNIPOLAR | FLUID_MOD_NEGATIVE; break;
  54         case AL_SNORM_SOFT: ret |= FLUID_MOD_BIPOLAR | FLUID_MOD_POSITIVE; break;
  55         case AL_SNORM_REV_SOFT: ret |= FLUID_MOD_BIPOLAR | FLUID_MOD_NEGATIVE; break;
  56     }
  57     switch(form)
  58     {
  59         case AL_LINEAR_SOFT: ret |= FLUID_MOD_LINEAR; break;
  60         case AL_CONCAVE_SOFT: ret |= FLUID_MOD_CONCAVE; break;
  61         case AL_CONVEX_SOFT: ret |= FLUID_MOD_CONVEX; break;
  62         case AL_SWITCH_SOFT: ret |= FLUID_MOD_SWITCH; break;
  63     }
  64     /* Source input values less than 128 correspond to a MIDI continuous
  65      * controller. Otherwise, it's a general controller. */
  66     if(input < 128) ret |= FLUID_MOD_CC;
  67     else ret |= FLUID_MOD_GC;
  68
  69     return ret;
  70 }
  71
  72 static enum fluid_gen_type getSf2Gen(ALenum gen)
  73 {
  74     switch(gen)
  75     {
  76         case AL_MOD_LFO_TO_PITCH_SOFT: return GEN_MODLFOTOPITCH;
  77         case AL_VIBRATO_LFO_TO_PITCH_SOFT: return GEN_VIBLFOTOPITCH;
  78         case AL_MOD_ENV_TO_PITCH_SOFT: return GEN_MODENVTOPITCH;
  79         case AL_FILTER_CUTOFF_SOFT: return GEN_FILTERFC;
  80         case AL_FILTER_RESONANCE_SOFT: return GEN_FILTERQ;
  81         case AL_MOD_LFO_TO_FILTER_CUTOFF_SOFT: return GEN_MODLFOTOFILTERFC;
  82         case AL_MOD_ENV_TO_FILTER_CUTOFF_SOFT: return GEN_MODENVTOFILTERFC;
  83         case AL_MOD_LFO_TO_VOLUME_SOFT: return GEN_MODLFOTOVOL;
  84         case AL_CHORUS_SEND_SOFT: return GEN_CHORUSSEND;
  85         case AL_REVERB_SEND_SOFT: return GEN_REVERBSEND;
  86         case AL_PAN_SOFT: return GEN_PAN;
  87         case AL_MOD_LFO_DELAY_SOFT: return GEN_MODLFODELAY;
  88         case AL_MOD_LFO_FREQUENCY_SOFT: return GEN_MODLFOFREQ;
  89         case AL_VIBRATO_LFO_DELAY_SOFT: return GEN_VIBLFODELAY;
  90         case AL_VIBRATO_LFO_FREQUENCY_SOFT: return GEN_VIBLFOFREQ;
  91         case AL_MOD_ENV_DELAYTIME_SOFT: return GEN_MODENVDELAY;
  92         case AL_MOD_ENV_ATTACKTIME_SOFT: return GEN_MODENVATTACK;
  93         case AL_MOD_ENV_HOLDTIME_SOFT: return GEN_MODENVHOLD;
  94         case AL_MOD_ENV_DECAYTIME_SOFT: return GEN_MODENVDECAY;
  95         case AL_MOD_ENV_SUSTAINVOLUME_SOFT: return GEN_MODENVSUSTAIN;
  96         case AL_MOD_ENV_RELEASETIME_SOFT: return GEN_MODENVRELEASE;
  97         case AL_MOD_ENV_KEY_TO_HOLDTIME_SOFT: return GEN_KEYTOMODENVHOLD;
  98         case AL_MOD_ENV_KEY_TO_DECAYTIME_SOFT: return GEN_KEYTOMODENVDECAY;
  99         case AL_VOLUME_ENV_DELAYTIME_SOFT: return GEN_VOLENVDELAY;
 100         case AL_VOLUME_ENV_ATTACKTIME_SOFT: return GEN_VOLENVATTACK;
 101         case AL_VOLUME_ENV_HOLDTIME_SOFT: return GEN_VOLENVHOLD;
 102         case AL_VOLUME_ENV_DECAYTIME_SOFT: return GEN_VOLENVDECAY;
 103         case AL_VOLUME_ENV_SUSTAINVOLUME_SOFT: return GEN_VOLENVSUSTAIN;
 104         case AL_VOLUME_ENV_RELEASETIME_SOFT: return GEN_VOLENVRELEASE;
 105         case AL_VOLUME_ENV_KEY_TO_HOLDTIME_SOFT: return GEN_KEYTOVOLENVHOLD;
 106         case AL_VOLUME_ENV_KEY_TO_DECAYTIME_SOFT: return GEN_KEYTOVOLENVDECAY;
 107         case AL_ATTENUATION_SOFT: return GEN_ATTENUATION;
 108         case AL_TUNING_COARSE_SOFT: return GEN_COARSETUNE;
 109         case AL_TUNING_FINE_SOFT: return GEN_FINETUNE;
 110         case AL_TUNING_SCALE_SOFT: return GEN_SCALETUNE;
 111     }
 112     ERR("Unhandled generator: 0x%04x\n", gen);
 113     return 0;
 114 }
 115
 116 static int getSf2LoopMode(ALenum mode)
 117 {
 118     switch(mode)
 119     {
 120         case AL_NONE: return 0;
 121         case AL_LOOP_CONTINUOUS_SOFT: return 1;
 122         case AL_LOOP_UNTIL_RELEASE_SOFT: return 3;
 123     }
 124     return 0;
 125 }
 126
 127 static int getSampleType(ALenum type)
 128 {
 129     switch(type)
 130     {
 131         case AL_MONO_SOFT: return FLUID_SAMPLETYPE_MONO;
 132         case AL_RIGHT_SOFT: return FLUID_SAMPLETYPE_RIGHT;
 133         case AL_LEFT_SOFT: return FLUID_SAMPLETYPE_LEFT;
 134     }
 135     return FLUID_SAMPLETYPE_MONO;
 136 }
 137
 138 typedef struct FSample {
 139     DERIVE_FROM_TYPE(fluid_sample_t);
 140
 141     ALfontsound *Sound;
 142
 143     fluid_mod_t *Mods;
 144     ALsizei NumMods;
 145 } FSample;
 146
 147 static void FSample_Construct(FSample *self, ALfontsound *sound, ALsoundfont *sfont)
 148 {
 149     fluid_sample_t *sample = STATIC_CAST(fluid_sample_t, self);
 150     memset(sample->name, 0, sizeof(sample->name));
 151     sample->start = sound->Start;
 152     sample->end = sound->End;
 153     sample->loopstart = sound->LoopStart;
 154     sample->loopend = sound->LoopEnd;
 155     sample->samplerate = sound->SampleRate;
 156     sample->origpitch = sound->PitchKey;
 157     sample->pitchadj = sound->PitchCorrection;
 158     sample->sampletype = getSampleType(sound->SampleType);
 159     sample->valid = 1;
 160     sample->data = sfont->Samples;
 161
 162     sample->amplitude_that_reaches_noise_floor_is_valid = 0;
 163     sample->amplitude_that_reaches_noise_floor = 0.0;
 164
 165     sample->refcount = 0;
 166
 167     sample->notify = NULL;
 168
 169     sample->userdata = self;
 170
 171     self->Sound = sound;
 172
 173     self->NumMods = 0;
 174     self->Mods = calloc(sound->ModulatorMap.size, sizeof(self->Mods[0]));
 175     if(self->Mods)
 176     {
 177         ALsizei i;
 178
 179         self->NumMods = sound->ModulatorMap.size;
 180         for(i = 0;i < self->NumMods;i++)
 181         {
 182             ALsfmodulator *mod = sound->ModulatorMap.array[i].value;
 183             fluid_mod_set_source1(&self->Mods[i], getGenInput(mod->Source[0].Input),
 184                                   getGenFlags(mod->Source[0].Input, mod->Source[0].Type,
 185                                               mod->Source[0].Form));
 186             fluid_mod_set_source2(&self->Mods[i], getGenInput(mod->Source[1].Input),
 187                                   getGenFlags(mod->Source[1].Input, mod->Source[1].Type,
 188                                               mod->Source[1].Form));
 189             fluid_mod_set_amount(&self->Mods[i], mod->Amount);
 190             fluid_mod_set_dest(&self->Mods[i], getSf2Gen(mod->Dest));
 191             self->Mods[i].next = NULL;
 192         }
 193     }
 194 }
 195
 196 static void FSample_Destruct(FSample *self)
 197 {
 198     free(self->Mods);
 199     self->Mods = NULL;
 200     self->NumMods = 0;
 201 }
 202
 203
 204 typedef struct FPreset {
 205     DERIVE_FROM_TYPE(fluid_preset_t);
 206
 207     char Name[16];
 208
 209     int Preset;
 210     int Bank;
 211
 212     FSample *Samples;
 213     ALsizei NumSamples;
 214 } FPreset;
 215
 216 static char* FPreset_getName(fluid_preset_t *preset);
 217 static int FPreset_getPreset(fluid_preset_t *preset);
 218 static int FPreset_getBank(fluid_preset_t *preset);
 219 static int FPreset_noteOn(fluid_preset_t *preset, fluid_synth_t *synth, int channel, int key, int velocity);
 220
 221 static void FPreset_Construct(FPreset *self, ALsfpreset *preset, fluid_sfont_t *parent, ALsoundfont *sfont)
 222 {
 223     STATIC_CAST(fluid_preset_t, self)->data = self;
 224     STATIC_CAST(fluid_preset_t, self)->sfont = parent;
 225     STATIC_CAST(fluid_preset_t, self)->free = NULL;
 226     STATIC_CAST(fluid_preset_t, self)->get_name = FPreset_getName;
 227     STATIC_CAST(fluid_preset_t, self)->get_banknum = FPreset_getBank;
 228     STATIC_CAST(fluid_preset_t, self)->get_num = FPreset_getPreset;
 229     STATIC_CAST(fluid_preset_t, self)->noteon = FPreset_noteOn;
 230     STATIC_CAST(fluid_preset_t, self)->notify = NULL;
 231
 232     memset(self->Name, 0, sizeof(self->Name));
 233     self->Preset = preset->Preset;
 234     self->Bank = preset->Bank;
 235
 236     self->NumSamples = 0;
 237     self->Samples = calloc(1, preset->NumSounds * sizeof(self->Samples[0]));
 238     if(self->Samples)
 239     {
 240         ALsizei i;
 241         self->NumSamples = preset->NumSounds;
 242         for(i = 0;i < self->NumSamples;i++)
 243             FSample_Construct(&self->Samples[i], preset->Sounds[i], sfont);
 244     }
 245 }
 246
 247 static void FPreset_Destruct(FPreset *self)
 248 {
 249     ALsizei i;
 250
 251     for(i = 0;i < self->NumSamples;i++)
 252         FSample_Destruct(&self->Samples[i]);
 253     free(self->Samples);
 254     self->Samples = NULL;
 255     self->NumSamples = 0;
 256 }
 257
 258 static ALboolean FPreset_canDelete(FPreset *self)
 259 {
 260     ALsizei i;
 261
 262     for(i = 0;i < self->NumSamples;i++)
 263     {
 264         if(fluid_sample_refcount(STATIC_CAST(fluid_sample_t, &self->Samples[i])) != 0)
 265             return AL_FALSE;
 266     }
 267     return AL_TRUE;
 268 }
 269
 270 static char* FPreset_getName(fluid_preset_t *preset)
 271 {
 272     return ((FPreset*)preset->data)->Name;
 273 }
 274
 275 static int FPreset_getPreset(fluid_preset_t *preset)
 276 {
 277     return ((FPreset*)preset->data)->Preset;
 278 }
 279
 280 static int FPreset_getBank(fluid_preset_t *preset)
 281 {
 282     return ((FPreset*)preset->data)->Bank;
 283 }
 284
 285 static int FPreset_noteOn(fluid_preset_t *preset, fluid_synth_t *synth, int channel, int key, int vel)
 286 {
 287     FPreset *self = ((FPreset*)preset->data);
 288     ALsizei i;
 289
 290     for(i = 0;i < self->NumSamples;i++)
 291     {
 292         FSample *sample = &self->Samples[i];
 293         ALfontsound *sound = sample->Sound;
 294         fluid_voice_t *voice;
 295         ALsizei m;
 296
 297         if(!(key >= sound->MinKey && key <= sound->MaxKey && vel >= sound->MinVelocity && vel <= sound->MaxVelocity))
 298             continue;
 299
 300         voice = fluid_synth_alloc_voice(synth, STATIC_CAST(fluid_sample_t, sample), channel, key, vel);
 301         if(voice == NULL)
 302             return FLUID_FAILED;
 303
 304         fluid_voice_gen_set(voice, GEN_MODLFOTOPITCH, sound->ModLfoToPitch);
 305         fluid_voice_gen_set(voice, GEN_VIBLFOTOPITCH, sound->VibratoLfoToPitch);
 306         fluid_voice_gen_set(voice, GEN_MODENVTOPITCH, sound->ModEnvToPitch);
 307         fluid_voice_gen_set(voice, GEN_FILTERFC, sound->FilterCutoff);
 308         fluid_voice_gen_set(voice, GEN_FILTERQ, sound->FilterQ);
 309         fluid_voice_gen_set(voice, GEN_MODLFOTOFILTERFC, sound->ModLfoToFilterCutoff);
 310         fluid_voice_gen_set(voice, GEN_MODENVTOFILTERFC, sound->ModEnvToFilterCutoff);
 311         fluid_voice_gen_set(voice, GEN_MODLFOTOVOL, sound->ModLfoToVolume);
 312         fluid_voice_gen_set(voice, GEN_CHORUSSEND, sound->ChorusSend);
 313         fluid_voice_gen_set(voice, GEN_REVERBSEND, sound->ReverbSend);
 314         fluid_voice_gen_set(voice, GEN_PAN, sound->Pan);
 315         fluid_voice_gen_set(voice, GEN_MODLFODELAY, sound->ModLfo.Delay);
 316         fluid_voice_gen_set(voice, GEN_MODLFOFREQ, sound->ModLfo.Frequency);
 317         fluid_voice_gen_set(voice, GEN_VIBLFODELAY, sound->VibratoLfo.Delay);
 318         fluid_voice_gen_set(voice, GEN_VIBLFOFREQ, sound->VibratoLfo.Frequency);
 319         fluid_voice_gen_set(voice, GEN_MODENVDELAY, sound->ModEnv.DelayTime);
 320         fluid_voice_gen_set(voice, GEN_MODENVATTACK, sound->ModEnv.AttackTime);
 321         fluid_voice_gen_set(voice, GEN_MODENVHOLD, sound->ModEnv.HoldTime);
 322         fluid_voice_gen_set(voice, GEN_MODENVDECAY, sound->ModEnv.DecayTime);
 323         fluid_voice_gen_set(voice, GEN_MODENVSUSTAIN, sound->ModEnv.SustainAttn);
 324         fluid_voice_gen_set(voice, GEN_MODENVRELEASE, sound->ModEnv.ReleaseTime);
 325         fluid_voice_gen_set(voice, GEN_KEYTOMODENVHOLD, sound->ModEnv.KeyToHoldTime);
 326         fluid_voice_gen_set(voice, GEN_KEYTOMODENVDECAY, sound->ModEnv.KeyToDecayTime);
 327         fluid_voice_gen_set(voice, GEN_VOLENVDELAY, sound->VolEnv.DelayTime);
 328         fluid_voice_gen_set(voice, GEN_VOLENVATTACK, sound->VolEnv.AttackTime);
 329         fluid_voice_gen_set(voice, GEN_VOLENVHOLD, sound->VolEnv.HoldTime);
 330         fluid_voice_gen_set(voice, GEN_VOLENVDECAY, sound->VolEnv.DecayTime);
 331         fluid_voice_gen_set(voice, GEN_VOLENVSUSTAIN, sound->VolEnv.SustainAttn);
 332         fluid_voice_gen_set(voice, GEN_VOLENVRELEASE, sound->VolEnv.ReleaseTime);
 333         fluid_voice_gen_set(voice, GEN_KEYTOVOLENVHOLD, sound->VolEnv.KeyToHoldTime);
 334         fluid_voice_gen_set(voice, GEN_KEYTOVOLENVDECAY, sound->VolEnv.KeyToDecayTime);
 335         fluid_voice_gen_set(voice, GEN_ATTENUATION, sound->Attenuation);
 336         fluid_voice_gen_set(voice, GEN_COARSETUNE, sound->CoarseTuning);
 337         fluid_voice_gen_set(voice, GEN_FINETUNE, sound->FineTuning);
 338         fluid_voice_gen_set(voice, GEN_SAMPLEMODE, getSf2LoopMode(sound->LoopMode));
 339         fluid_voice_gen_set(voice, GEN_SCALETUNE, sound->TuningScale);
 340         fluid_voice_gen_set(voice, GEN_EXCLUSIVECLASS, sound->ExclusiveClass);
 341         for(m = 0;m < sample->NumMods;m++)
 342             fluid_voice_add_mod(voice, &sample->Mods[m], FLUID_VOICE_OVERWRITE);
 343
 344         fluid_synth_start_voice(synth, voice);
 345     }
 346
 347     return FLUID_OK;
 348 }
 349
 350
 351 typedef struct FSfont {
 352     DERIVE_FROM_TYPE(fluid_sfont_t);
 353
 354     char Name[16];
 355
 356     FPreset *Presets;
 357     ALsizei NumPresets;
 358
 359     ALsizei CurrentPos;
 360 } FSfont;
 361
 362 static int FSfont_free(fluid_sfont_t *sfont);
 363 static char* FSfont_getName(fluid_sfont_t *sfont);
 364 static fluid_preset_t* FSfont_getPreset(fluid_sfont_t *sfont, unsigned int bank, unsigned int prenum);
 365 static void FSfont_iterStart(fluid_sfont_t *sfont);
 366 static int FSfont_iterNext(fluid_sfont_t *sfont, fluid_preset_t *preset);
 367
 368 static void FSfont_Construct(FSfont *self, ALsoundfont *sfont)
 369 {
 370     STATIC_CAST(fluid_sfont_t, self)->data = self;
 371     STATIC_CAST(fluid_sfont_t, self)->id = FLUID_FAILED;
 372     STATIC_CAST(fluid_sfont_t, self)->free = FSfont_free;
 373     STATIC_CAST(fluid_sfont_t, self)->get_name = FSfont_getName;
 374     STATIC_CAST(fluid_sfont_t, self)->get_preset = FSfont_getPreset;
 375     STATIC_CAST(fluid_sfont_t, self)->iteration_start = FSfont_iterStart;
 376     STATIC_CAST(fluid_sfont_t, self)->iteration_next = FSfont_iterNext;
 377
 378     memset(self->Name, 0, sizeof(self->Name));
 379     self->CurrentPos = 0;
 380     self->NumPresets = 0;
 381     self->Presets = calloc(1, sfont->NumPresets * sizeof(self->Presets[0]));
 382     if(self->Presets)
 383     {
 384         ALsizei i;
 385         self->NumPresets = sfont->NumPresets;
 386         for(i = 0;i < self->NumPresets;i++)
 387             FPreset_Construct(&self->Presets[i], sfont->Presets[i], STATIC_CAST(fluid_sfont_t, self), sfont);
 388     }
 389 }
 390
 391 static void FSfont_Destruct(FSfont *self)
 392 {
 393     ALsizei i;
 394
 395     for(i = 0;i < self->NumPresets;i++)
 396         FPreset_Destruct(&self->Presets[i]);
 397     free(self->Presets);
 398     self->Presets = NULL;
 399     self->NumPresets = 0;
 400     self->CurrentPos = 0;
 401 }
 402
 403 static int FSfont_free(fluid_sfont_t *sfont)
 404 {
 405     FSfont *self = STATIC_UPCAST(FSfont, fluid_sfont_t, sfont);
 406     ALsizei i;
 407
 408     for(i = 0;i < self->NumPresets;i++)
 409     {
 410         if(!FPreset_canDelete(&self->Presets[i]))
 411             return 1;
 412     }
 413
 414     FSfont_Destruct(self);
 415     free(self);
 416     return 0;
 417 }
 418
 419 static char* FSfont_getName(fluid_sfont_t *sfont)
 420 {
 421     return STATIC_UPCAST(FSfont, fluid_sfont_t, sfont)->Name;
 422 }
 423
 424 static fluid_preset_t *FSfont_getPreset(fluid_sfont_t *sfont, unsigned int bank, unsigned int prenum)
 425 {
 426     FSfont *self = STATIC_UPCAST(FSfont, fluid_sfont_t, sfont);
 427     ALsizei i;
 428
 429     for(i = 0;i < self->NumPresets;i++)
 430     {
 431         FPreset *preset = &self->Presets[i];
 432         if(preset->Bank == (int)bank && preset->Preset == (int)prenum)
 433             return STATIC_CAST(fluid_preset_t, preset);
 434     }
 435
 436     return NULL;
 437 }
 438
 439 static void FSfont_iterStart(fluid_sfont_t *sfont)
 440 {
 441     STATIC_UPCAST(FSfont, fluid_sfont_t, sfont)->CurrentPos = 0;
 442 }
 443
 444 static int FSfont_iterNext(fluid_sfont_t *sfont, fluid_preset_t *preset)
 445 {
 446     FSfont *self = STATIC_UPCAST(FSfont, fluid_sfont_t, sfont);
 447     if(self->CurrentPos >= self->NumPresets)
 448         return 0;
 449     *preset = *STATIC_CAST(fluid_preset_t, &self->Presets[self->CurrentPos++]);
 450     preset->free = NULL;
 451     return 1;
 452 }
 453
 454
 455 typedef struct FSynth {
 456     DERIVE_FROM_TYPE(MidiSynth);
 457     DERIVE_FROM_TYPE(fluid_sfloader_t);
 458
 459     fluid_settings_t *Settings;
 460     fluid_synth_t *Synth;
 461     int *FontIDs;
 462     ALsizei NumFontIDs;
 463
 464     ALboolean ForceGM2BankSelect;
 465     ALfloat GainScale;
 466 } FSynth;
 467
 468 static void FSynth_Construct(FSynth *self, ALCdevice *device);
 469 static void FSynth_Destruct(FSynth *self);
 470 static ALboolean FSynth_init(FSynth *self, ALCdevice *device);
 471 static ALenum FSynth_selectSoundfonts(FSynth *self, ALCcontext *context, ALsizei count, const ALuint *ids);
 472 static void FSynth_setGain(FSynth *self, ALfloat gain);
 473 static void FSynth_setState(FSynth *self, ALenum state);
 474 static void FSynth_stop(FSynth *self);
 475 static void FSynth_reset(FSynth *self);
 476 static void FSynth_update(FSynth *self, ALCdevice *device);
 477 static void FSynth_processQueue(FSynth *self, ALuint64 time);
 478 static void FSynth_process(FSynth *self, ALuint SamplesToDo, ALfloat (*restrict DryBuffer)[BUFFERSIZE]);
 479 static void FSynth_Delete(FSynth *self);
 480 DEFINE_MIDISYNTH_VTABLE(FSynth);
 481
 482 static fluid_sfont_t *FSynth_loadSfont(fluid_sfloader_t *loader, const char *filename);
 483
 484
 485 static void FSynth_Construct(FSynth *self, ALCdevice *device)
 486 {
 487     MidiSynth_Construct(STATIC_CAST(MidiSynth, self), device);
 488     SET_VTABLE2(FSynth, MidiSynth, self);
 489
 490     STATIC_CAST(fluid_sfloader_t, self)->data = self;
 491     STATIC_CAST(fluid_sfloader_t, self)->free = NULL;
 492     STATIC_CAST(fluid_sfloader_t, self)->load = FSynth_loadSfont;
 493
 494     self->Settings = NULL;
 495     self->Synth = NULL;
 496     self->FontIDs = NULL;
 497     self->NumFontIDs = 0;
 498     self->ForceGM2BankSelect = AL_FALSE;
 499     self->GainScale = 0.2f;
 500 }
 501
 502 static void FSynth_Destruct(FSynth *self)
 503 {
 504     ALsizei i;
 505
 506     for(i = 0;i < self->NumFontIDs;i++)
 507         fluid_synth_sfunload(self->Synth, self->FontIDs[i], 0);
 508     free(self->FontIDs);
 509     self->FontIDs = NULL;
 510     self->NumFontIDs = 0;
 511
 512     if(self->Synth != NULL)
 513         delete_fluid_synth(self->Synth);
 514     self->Synth = NULL;
 515
 516     if(self->Settings != NULL)
 517         delete_fluid_settings(self->Settings);
 518     self->Settings = NULL;
 519
 520     MidiSynth_Destruct(STATIC_CAST(MidiSynth, self));
 521 }
 522
 523 static ALboolean FSynth_init(FSynth *self, ALCdevice *device)
 524 {
 525     ALfloat vol;
 526
 527     if(ConfigValueFloat("midi", "volume", &vol))
 528     {
 529         if(!(vol <= 0.0f))
 530         {
 531             ERR("MIDI volume %f clamped to 0\n", vol);
 532             vol = 0.0f;
 533         }
 534         self->GainScale = powf(10.0f, vol / 20.0f);
 535     }
 536
 537     self->Settings = new_fluid_settings();
 538     if(!self->Settings)
 539     {
 540         ERR("Failed to create FluidSettings\n");
 541         return AL_FALSE;
 542     }
 543
 544     fluid_settings_setint(self->Settings, "synth.polyphony", 256);
 545     fluid_settings_setnum(self->Settings, "synth.gain", self->GainScale);
 546     fluid_settings_setnum(self->Settings, "synth.sample-rate", device->Frequency);
 547
 548     self->Synth = new_fluid_synth(self->Settings);
 549     if(!self->Synth)
 550     {
 551         ERR("Failed to create FluidSynth\n");
 552         return AL_FALSE;
 553     }
 554
 555     fluid_synth_add_sfloader(self->Synth, STATIC_CAST(fluid_sfloader_t, self));
 556
 557     return AL_TRUE;
 558 }
 559
 560
 561 static fluid_sfont_t *FSynth_loadSfont(fluid_sfloader_t *loader, const char *filename)
 562 {
 563     FSynth *self = STATIC_UPCAST(FSynth, fluid_sfloader_t, loader);
 564     FSfont *sfont;
 565     int idx;
 566
 567     if(!filename || sscanf(filename, "_al_internal %d", &idx) != 1)
 568         return NULL;
 569     if(idx < 0 || idx >= STATIC_CAST(MidiSynth, self)->NumSoundfonts)
 570     {
 571         ERR("Received invalid soundfont index %d (max: %d)\n", idx, STATIC_CAST(MidiSynth, self)->NumSoundfonts);
 572         return NULL;
 573     }
 574
 575     sfont = calloc(1, sizeof(sfont[0]));
 576     if(!sfont) return NULL;
 577
 578     FSfont_Construct(sfont, STATIC_CAST(MidiSynth, self)->Soundfonts[idx]);
 579     return STATIC_CAST(fluid_sfont_t, sfont);
 580 }
 581
 582 static ALenum FSynth_selectSoundfonts(FSynth *self, ALCcontext *context, ALsizei count, const ALuint *ids)
 583 {
 584     int *fontid;
 585     ALenum ret;
 586     ALsizei i;
 587
 588     ret = MidiSynth_selectSoundfonts(STATIC_CAST(MidiSynth, self), context, count, ids);
 589     if(ret != AL_NO_ERROR) return ret;
 590
 591     ALCdevice_Lock(context->Device);
 592     for(i = 0;i < 16;i++)
 593         fluid_synth_all_sounds_off(self->Synth, i);
 594     ALCdevice_Unlock(context->Device);
 595
 596     fontid = malloc(count * sizeof(fontid[0]));
 597     if(fontid)
 598     {
 599         for(i = 0;i < STATIC_CAST(MidiSynth, self)->NumSoundfonts;i++)
 600         {
 601             char name[16];
 602             snprintf(name, sizeof(name), "_al_internal %d", i);
 603
 604             fontid[i] = fluid_synth_sfload(self->Synth, name, 0);
 605             if(fontid[i] == FLUID_FAILED)
 606                 ERR("Failed to load selected soundfont %d\n", i);
 607         }
 608
 609         fontid = ExchangePtr((XchgPtr*)&self->FontIDs, fontid);
 610         count = ExchangeInt(&self->NumFontIDs, count);
 611     }
 612     else
 613     {
 614         ERR("Failed to allocate space for %d font IDs!\n", count);
 615         fontid = ExchangePtr((XchgPtr*)&self->FontIDs, NULL);
 616         count = ExchangeInt(&self->NumFontIDs, 0);
 617     }
 618
 619     for(i = 0;i < count;i++)
 620         fluid_synth_sfunload(self->Synth, fontid[i], 0);
 621     free(fontid);
 622
 623     return ret;
 624 }
 625
 626
 627 static void FSynth_setGain(FSynth *self, ALfloat gain)
 628 {
 629     fluid_settings_setnum(self->Settings, "synth.gain", self->GainScale * gain);
 630     fluid_synth_set_gain(self->Synth, self->GainScale * gain);
 631     MidiSynth_setGain(STATIC_CAST(MidiSynth, self), gain);
 632 }
 633
 634
 635 static void FSynth_setState(FSynth *self, ALenum state)
 636 {
 637     MidiSynth_setState(STATIC_CAST(MidiSynth, self), state);
 638 }
 639
 640 static void FSynth_stop(FSynth *self)
 641 {
 642     MidiSynth *synth = STATIC_CAST(MidiSynth, self);
 643     ALuint64 curtime;
 644     ALsizei chan;
 645
 646     /* Make sure all pending events are processed. */
 647     curtime = MidiSynth_getTime(synth);
 648     FSynth_processQueue(self, curtime);
 649
 650     /* All notes off */
 651     for(chan = 0;chan < 16;chan++)
 652         fluid_synth_cc(self->Synth, chan, CTRL_ALLNOTESOFF, 0);
 653
 654     MidiSynth_stop(STATIC_CAST(MidiSynth, self));
 655 }
 656
 657 static void FSynth_reset(FSynth *self)
 658 {
 659     /* Reset to power-up status. */
 660     fluid_synth_system_reset(self->Synth);
 661
 662     MidiSynth_reset(STATIC_CAST(MidiSynth, self));
 663 }
 664
 665
 666 static void FSynth_update(FSynth *self, ALCdevice *device)
 667 {
 668     fluid_settings_setnum(self->Settings, "synth.sample-rate", device->Frequency);
 669     fluid_synth_set_sample_rate(self->Synth, device->Frequency);
 670     MidiSynth_update(STATIC_CAST(MidiSynth, self), device);
 671 }
 672
 673
 674 static void FSynth_processQueue(FSynth *self, ALuint64 time)
 675 {
 676     EvtQueue *queue = &STATIC_CAST(MidiSynth, self)->EventQueue;
 677
 678     while(queue->pos < queue->size && queue->events[queue->pos].time <= time)
 679     {
 680         const MidiEvent *evt = &queue->events[queue->pos];
 681
 682         if(evt->event == SYSEX_EVENT)
 683         {
 684             static const ALbyte gm2_on[] = { 0x7E, 0x7F, 0x09, 0x03 };
 685             static const ALbyte gm2_off[] = { 0x7E, 0x7F, 0x09, 0x02 };
 686             int handled = 0;
 687
 688             fluid_synth_sysex(self->Synth, evt->param.sysex.data, evt->param.sysex.size, NULL, NULL, &handled, 0);
 689             if(!handled && evt->param.sysex.size >= (ALsizei)sizeof(gm2_on))
 690             {
 691                 if(memcmp(evt->param.sysex.data, gm2_on, sizeof(gm2_on)) == 0)
 692                     self->ForceGM2BankSelect = AL_TRUE;
 693                 else if(memcmp(evt->param.sysex.data, gm2_off, sizeof(gm2_off)) == 0)
 694                     self->ForceGM2BankSelect = AL_FALSE;
 695             }
 696         }
 697         else switch((evt->event&0xF0))
 698         {
 699             case AL_NOTEOFF_SOFT:
 700                 fluid_synth_noteoff(self->Synth, (evt->event&0x0F), evt->param.val[0]);
 701                 break;
 702             case AL_NOTEON_SOFT:
 703                 fluid_synth_noteon(self->Synth, (evt->event&0x0F), evt->param.val[0], evt->param.val[1]);
 704                 break;
 705             case AL_KEYPRESSURE_SOFT:
 706                 break;
 707
 708             case AL_CONTROLLERCHANGE_SOFT:
 709                 if(self->ForceGM2BankSelect)
 710                 {
 711                     int chan = (evt->event&0x0F);
 712                     if(evt->param.val[0] == CTRL_BANKSELECT_MSB)
 713                     {
 714                         if(evt->param.val[1] == 120 && (chan == 9 || chan == 10))
 715                             fluid_synth_set_channel_type(self->Synth, chan, CHANNEL_TYPE_DRUM);
 716                         else if(evt->param.val[1] == 121)
 717                             fluid_synth_set_channel_type(self->Synth, chan, CHANNEL_TYPE_MELODIC);
 718                         break;
 719                     }
 720                     if(evt->param.val[0] == CTRL_BANKSELECT_LSB)
 721                     {
 722                         fluid_synth_bank_select(self->Synth, chan, evt->param.val[1]);
 723                         break;
 724                     }
 725                 }
 726                 fluid_synth_cc(self->Synth, (evt->event&0x0F), evt->param.val[0], evt->param.val[1]);
 727                 break;
 728             case AL_PROGRAMCHANGE_SOFT:
 729                 fluid_synth_program_change(self->Synth, (evt->event&0x0F), evt->param.val[0]);
 730                 break;
 731
 732             case AL_CHANNELPRESSURE_SOFT:
 733                 fluid_synth_channel_pressure(self->Synth, (evt->event&0x0F), evt->param.val[0]);
 734                 break;
 735
 736             case AL_PITCHBEND_SOFT:
 737                 fluid_synth_pitch_bend(self->Synth, (evt->event&0x0F), (evt->param.val[0]&0x7F) |
 738                                                                        ((evt->param.val[1]&0x7F)<<7));
 739                 break;
 740         }
 741
 742         queue->pos++;
 743     }
 744 }
 745
 746 static void FSynth_process(FSynth *self, ALuint SamplesToDo, ALfloat (*restrict DryBuffer)[BUFFERSIZE])
 747 {
 748     MidiSynth *synth = STATIC_CAST(MidiSynth, self);
 749     ALenum state = synth->State;
 750     ALuint64 curtime;
 751     ALuint total = 0;
 752
 753     if(state == AL_INITIAL)
 754         return;
 755     if(state != AL_PLAYING)
 756     {
 757         fluid_synth_write_float(self->Synth, SamplesToDo, DryBuffer[FrontLeft], 0, 1,
 758                                                           DryBuffer[FrontRight], 0, 1);
 759         return;
 760     }
 761
 762     curtime = MidiSynth_getTime(synth);
 763     while(total < SamplesToDo)
 764     {
 765         ALuint64 time, diff;
 766         ALint tonext;
 767
 768         time = MidiSynth_getNextEvtTime(synth);
 769         diff = maxu64(time, curtime) - curtime;
 770         if(diff >= MIDI_CLOCK_RES || time == UINT64_MAX)
 771         {
 772             /* If there's no pending event, or if it's more than 1 second
 773              * away, do as many samples as we can. */
 774             tonext = INT_MAX;
 775         }
 776         else
 777         {
 778             /* Figure out how many samples until the next event. */
 779             tonext  = (ALint)((diff*synth->SampleRate + (MIDI_CLOCK_RES-1)) / MIDI_CLOCK_RES);
 780             tonext -= total;
 781         }
 782
 783         if(tonext > 0)
 784         {
 785             ALuint todo = mini(tonext, SamplesToDo-total);
 786             fluid_synth_write_float(self->Synth, todo, DryBuffer[FrontLeft], total, 1,
 787                                                        DryBuffer[FrontRight], total, 1);
 788             total += todo;
 789             tonext -= todo;
 790         }
 791         if(total < SamplesToDo && tonext == 0)
 792             FSynth_processQueue(self, time);
 793     }
 794
 795     synth->SamplesDone += SamplesToDo;
 796     synth->ClockBase += (synth->SamplesDone/synth->SampleRate) * MIDI_CLOCK_RES;
 797     synth->SamplesDone %= synth->SampleRate;
 798 }
 799
 800
 801 static void FSynth_Delete(FSynth *self)
 802 {
 803     free(self);
 804 }
 805
 806
 807 MidiSynth *FSynth_create(ALCdevice *device)
 808 {
 809     FSynth *synth = calloc(1, sizeof(*synth));
 810     if(!synth)
 811     {
 812         ERR("Failed to allocate FSynth\n");
 813         return NULL;
 814     }
 815     FSynth_Construct(synth, device);
 816
 817     if(FSynth_init(synth, device) == AL_FALSE)
 818     {
 819         DELETE_OBJ(STATIC_CAST(MidiSynth, synth));
 820         return NULL;
 821     }
 822
 823     return STATIC_CAST(MidiSynth, synth);
 824 }
 825
 826 #else
 827
 828 MidiSynth *FSynth_create(ALCdevice* UNUSED(device))
 829 {
 830     return NULL;
 831 }
 832
 833 #endif