OpenAL32/alFontsound.c

   1
   2 #include "config.h"
   3
   4 #include <stdlib.h>
   5 #include <string.h>
   6
   7 #include "alMain.h"
   8 #include "alMidi.h"
   9 #include "alError.h"
  10 #include "alThunk.h"
  11
  12 #include "midi/base.h"
  13
  14
  15 extern inline struct ALfontsound *LookupFontsound(ALCdevice *device, ALuint id);
  16 extern inline struct ALfontsound *RemoveFontsound(ALCdevice *device, ALuint id);
  17
  18 static void ALfontsound_Construct(ALfontsound *self);
  19 void ALfontsound_Destruct(ALfontsound *self);
  20 void ALfontsound_setPropi(ALfontsound *self, ALCcontext *context, ALenum param, ALint value);
  21
  22
  23 AL_API void AL_APIENTRY alGenFontsoundsSOFT(ALsizei n, ALuint *ids)
  24 {
  25     ALCcontext *context;
  26     ALsizei cur = 0;
  27
  28     context = GetContextRef();
  29     if(!context) return;
  30
  31     if(!(n >= 0))
  32         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
  33
  34     for(cur = 0;cur < n;cur++)
  35     {
  36         ALfontsound *sound = NewFontsound(context);
  37         if(!sound)
  38         {
  39             alDeleteFontsoundsSOFT(cur, ids);
  40             break;
  41         }
  42
  43         ids[cur] = sound->id;
  44     }
  45
  46 done:
  47     ALCcontext_DecRef(context);
  48 }
  49
  50 AL_API ALvoid AL_APIENTRY alDeleteFontsoundsSOFT(ALsizei n, const ALuint *ids)
  51 {
  52     ALCdevice *device;
  53     ALCcontext *context;
  54     ALfontsound *inst;
  55     ALsizei i;
  56
  57     context = GetContextRef();
  58     if(!context) return;
  59
  60     if(!(n >= 0))
  61         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
  62
  63     device = context->Device;
  64     for(i = 0;i < n;i++)
  65     {
  66         /* Check for valid ID */
  67         if((inst=LookupFontsound(device, ids[i])) == NULL)
  68             SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
  69         if(inst->ref != 0)
  70             SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
  71     }
  72
  73     for(i = 0;i < n;i++)
  74     {
  75         if((inst=RemoveFontsound(device, ids[i])) == NULL)
  76             continue;
  77
  78         ALfontsound_Destruct(inst);
  79
  80         memset(inst, 0, sizeof(*inst));
  81         free(inst);
  82     }
  83
  84 done:
  85     ALCcontext_DecRef(context);
  86 }
  87
  88 AL_API ALboolean AL_APIENTRY alIsFontsoundSOFT(ALuint id)
  89 {
  90     ALCcontext *context;
  91     ALboolean ret;
  92
  93     context = GetContextRef();
  94     if(!context) return AL_FALSE;
  95
  96     ret = LookupFontsound(context->Device, id) ? AL_TRUE : AL_FALSE;
  97
  98     ALCcontext_DecRef(context);
  99
 100     return ret;
 101 }
 102
 103 AL_API void AL_APIENTRY alFontsoundiSOFT(ALuint id, ALenum param, ALint value)
 104 {
 105     ALCdevice *device;
 106     ALCcontext *context;
 107     ALfontsound *sound;
 108
 109     context = GetContextRef();
 110     if(!context) return;
 111
 112     device = context->Device;
 113     if(!(sound=LookupFontsound(device, id)))
 114         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 115     if(sound->ref != 0)
 116         SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
 117
 118     ALfontsound_setPropi(sound, context, param, value);
 119
 120 done:
 121     ALCcontext_DecRef(context);
 122 }
 123
 124 AL_API void AL_APIENTRY alFontsound2iSOFT(ALuint id, ALenum param, ALint value1, ALint value2)
 125 {
 126     ALCdevice *device;
 127     ALCcontext *context;
 128     ALfontsound *sound;
 129
 130     context = GetContextRef();
 131     if(!context) return;
 132
 133     device = context->Device;
 134     if(!(sound=LookupFontsound(device, id)))
 135         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 136     if(sound->ref != 0)
 137         SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
 138     switch(param)
 139     {
 140         case AL_KEY_RANGE_SOFT:
 141             if(!(value1 >= 0 && value1 <= 127 && value2 >= 0 && value2 <= 127 && value2 >= value1))
 142                 SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 143             sound->MinKey = value1;
 144             sound->MaxKey = value2;
 145             break;
 146
 147         case AL_VELOCITY_RANGE_SOFT:
 148             if(!(value1 >= 0 && value1 <= 127 && value2 >= 0 && value2 <= 127 && value2 >= value1))
 149                 SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 150             sound->MinVelocity = value1;
 151             sound->MaxVelocity = value2;
 152             break;
 153
 154         default:
 155             SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 156     }
 157
 158 done:
 159     ALCcontext_DecRef(context);
 160 }
 161
 162 AL_API void AL_APIENTRY alFontsoundivSOFT(ALuint id, ALenum param, const ALint *values)
 163 {
 164     ALCdevice *device;
 165     ALCcontext *context;
 166     ALfontsound *sound;
 167
 168     switch(param)
 169     {
 170         case AL_KEY_RANGE_SOFT:
 171         case AL_VELOCITY_RANGE_SOFT:
 172             alFontsound2iSOFT(id, param, values[0], values[1]);
 173             return;
 174
 175         case AL_MOD_LFO_TO_PITCH_SOFT:
 176         case AL_VIBRATO_LFO_TO_PITCH_SOFT:
 177         case AL_MOD_ENV_TO_PITCH_SOFT:
 178         case AL_FILTER_CUTOFF_SOFT:
 179         case AL_FILTER_RESONANCE_SOFT:
 180         case AL_MOD_LFO_TO_FILTER_CUTOFF_SOFT:
 181         case AL_MOD_ENV_TO_FILTER_CUTOFF_SOFT:
 182         case AL_MOD_LFO_TO_VOLUME_SOFT:
 183         case AL_CHORUS_SEND_SOFT:
 184         case AL_REVERB_SEND_SOFT:
 185         case AL_PAN_SOFT:
 186         case AL_MOD_LFO_DELAY_SOFT:
 187         case AL_MOD_LFO_FREQUENCY_SOFT:
 188         case AL_VIBRATO_LFO_DELAY_SOFT:
 189         case AL_VIBRATO_LFO_FREQUENCY_SOFT:
 190         case AL_MOD_ENV_DELAYTIME_SOFT:
 191         case AL_MOD_ENV_ATTACKTIME_SOFT:
 192         case AL_MOD_ENV_HOLDTIME_SOFT:
 193         case AL_MOD_ENV_DECAYTIME_SOFT:
 194         case AL_MOD_ENV_SUSTAINVOLUME_SOFT:
 195         case AL_MOD_ENV_RELEASETIME_SOFT:
 196         case AL_MOD_ENV_KEY_TO_HOLDTIME_SOFT:
 197         case AL_MOD_ENV_KEY_TO_DECAYTIME_SOFT:
 198         case AL_VOLUME_ENV_DELAYTIME_SOFT:
 199         case AL_VOLUME_ENV_ATTACKTIME_SOFT:
 200         case AL_VOLUME_ENV_HOLDTIME_SOFT:
 201         case AL_VOLUME_ENV_DECAYTIME_SOFT:
 202         case AL_VOLUME_ENV_SUSTAINVOLUME_SOFT:
 203         case AL_VOLUME_ENV_RELEASETIME_SOFT:
 204         case AL_VOLUME_ENV_KEY_TO_HOLDTIME_SOFT:
 205         case AL_VOLUME_ENV_KEY_TO_DECAYTIME_SOFT:
 206         case AL_ATTENUATION_SOFT:
 207         case AL_TUNING_COARSE_SOFT:
 208         case AL_TUNING_FINE_SOFT:
 209         case AL_LOOP_MODE_SOFT:
 210         case AL_TUNING_SCALE_SOFT:
 211         case AL_EXCLUSIVE_CLASS_SOFT:
 212         case AL_SAMPLE_START_SOFT:
 213         case AL_SAMPLE_END_SOFT:
 214         case AL_SAMPLE_LOOP_START_SOFT:
 215         case AL_SAMPLE_LOOP_END_SOFT:
 216         case AL_SAMPLE_RATE_SOFT:
 217         case AL_BASE_KEY_SOFT:
 218         case AL_KEY_CORRECTION_SOFT:
 219         case AL_SAMPLE_TYPE_SOFT:
 220         case AL_FONTSOUND_LINK_SOFT:
 221             alFontsoundiSOFT(id, param, values[0]);
 222             return;
 223     }
 224
 225     context = GetContextRef();
 226     if(!context) return;
 227
 228     device = context->Device;
 229     if(!(sound=LookupFontsound(device, id)))
 230         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 231     if(sound->ref != 0)
 232         SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
 233     switch(param)
 234     {
 235         default:
 236             SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 237     }
 238
 239 done:
 240     ALCcontext_DecRef(context);
 241 }
 242
 243 AL_API void AL_APIENTRY alGetFontsoundivSOFT(ALuint id, ALenum param, ALint *values)
 244 {
 245     ALCdevice *device;
 246     ALCcontext *context;
 247     const ALfontsound *sound;
 248
 249     context = GetContextRef();
 250     if(!context) return;
 251
 252     device = context->Device;
 253     if(!(sound=LookupFontsound(device, id)))
 254         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 255     switch(param)
 256     {
 257         case AL_MOD_LFO_TO_PITCH_SOFT:
 258             values[0] = sound->ModLfoToPitch;
 259             break;
 260
 261         case AL_VIBRATO_LFO_TO_PITCH_SOFT:
 262             values[0] = sound->VibratoLfoToPitch;
 263             break;
 264
 265         case AL_MOD_ENV_TO_PITCH_SOFT:
 266             values[0] = sound->ModEnvToPitch;
 267             break;
 268
 269         case AL_FILTER_CUTOFF_SOFT:
 270             values[0] = sound->FilterCutoff;
 271             break;
 272
 273         case AL_FILTER_RESONANCE_SOFT:
 274             values[0] = sound->FilterQ;
 275             break;
 276
 277         case AL_MOD_LFO_TO_FILTER_CUTOFF_SOFT:
 278             values[0] = sound->ModLfoToFilterCutoff;
 279             break;
 280
 281         case AL_MOD_ENV_TO_FILTER_CUTOFF_SOFT:
 282             values[0] = sound->ModEnvToFilterCutoff;
 283             break;
 284
 285         case AL_MOD_LFO_TO_VOLUME_SOFT:
 286             values[0] = sound->ModLfoToVolume;
 287             break;
 288
 289         case AL_CHORUS_SEND_SOFT:
 290             values[0] = sound->ChorusSend;
 291             break;
 292
 293         case AL_REVERB_SEND_SOFT:
 294             values[0] = sound->ReverbSend;
 295             break;
 296
 297         case AL_PAN_SOFT:
 298             values[0] = sound->Pan;
 299             break;
 300
 301         case AL_MOD_LFO_DELAY_SOFT:
 302             values[0] = sound->ModLfo.Delay;
 303             break;
 304         case AL_MOD_LFO_FREQUENCY_SOFT:
 305             values[0] = sound->ModLfo.Frequency;
 306             break;
 307
 308         case AL_VIBRATO_LFO_DELAY_SOFT:
 309             values[0] = sound->VibratoLfo.Delay;
 310             break;
 311         case AL_VIBRATO_LFO_FREQUENCY_SOFT:
 312             values[0] = sound->VibratoLfo.Frequency;
 313             break;
 314
 315         case AL_MOD_ENV_DELAYTIME_SOFT:
 316             values[0] = sound->ModEnv.DelayTime;
 317             break;
 318         case AL_MOD_ENV_ATTACKTIME_SOFT:
 319             values[0] = sound->ModEnv.AttackTime;
 320             break;
 321         case AL_MOD_ENV_HOLDTIME_SOFT:
 322             values[0] = sound->ModEnv.HoldTime;
 323             break;
 324         case AL_MOD_ENV_DECAYTIME_SOFT:
 325             values[0] = sound->ModEnv.DecayTime;
 326             break;
 327         case AL_MOD_ENV_SUSTAINVOLUME_SOFT:
 328             values[0] = sound->ModEnv.SustainVol;
 329             break;
 330         case AL_MOD_ENV_RELEASETIME_SOFT:
 331             values[0] = sound->ModEnv.ReleaseTime;
 332             break;
 333         case AL_MOD_ENV_KEY_TO_HOLDTIME_SOFT:
 334             values[0] = sound->ModEnv.KeyToHoldTime;
 335             break;
 336         case AL_MOD_ENV_KEY_TO_DECAYTIME_SOFT:
 337             values[0] = sound->ModEnv.KeyToDecayTime;
 338             break;
 339
 340         case AL_VOLUME_ENV_DELAYTIME_SOFT:
 341             values[0] = sound->VolEnv.DelayTime;
 342             break;
 343         case AL_VOLUME_ENV_ATTACKTIME_SOFT:
 344             values[0] = sound->VolEnv.AttackTime;
 345             break;
 346         case AL_VOLUME_ENV_HOLDTIME_SOFT:
 347             values[0] = sound->VolEnv.HoldTime;
 348             break;
 349         case AL_VOLUME_ENV_DECAYTIME_SOFT:
 350             values[0] = sound->VolEnv.DecayTime;
 351             break;
 352         case AL_VOLUME_ENV_SUSTAINVOLUME_SOFT:
 353             values[0] = sound->VolEnv.SustainVol;
 354             break;
 355         case AL_VOLUME_ENV_RELEASETIME_SOFT:
 356             values[0] = sound->VolEnv.ReleaseTime;
 357             break;
 358         case AL_VOLUME_ENV_KEY_TO_HOLDTIME_SOFT:
 359             values[0] = sound->VolEnv.KeyToHoldTime;
 360             break;
 361         case AL_VOLUME_ENV_KEY_TO_DECAYTIME_SOFT:
 362             values[0] = sound->VolEnv.KeyToDecayTime;
 363             break;
 364
 365         case AL_KEY_RANGE_SOFT:
 366             values[0] = sound->MinKey;
 367             values[1] = sound->MaxKey;
 368             break;
 369
 370         case AL_VELOCITY_RANGE_SOFT:
 371             values[0] = sound->MinVelocity;
 372             values[1] = sound->MaxVelocity;
 373             break;
 374
 375         case AL_ATTENUATION_SOFT:
 376             values[0] = sound->Attenuation;
 377             break;
 378
 379         case AL_TUNING_COARSE_SOFT:
 380             values[0] = sound->CoarseTuning;
 381             break;
 382         case AL_TUNING_FINE_SOFT:
 383             values[0] = sound->FineTuning;
 384             break;
 385
 386         case AL_LOOP_MODE_SOFT:
 387             values[0] = sound->LoopMode;
 388             break;
 389
 390         case AL_TUNING_SCALE_SOFT:
 391             values[0] = sound->TuningScale;
 392             break;
 393
 394         case AL_EXCLUSIVE_CLASS_SOFT:
 395             values[0] = sound->ExclusiveClass;
 396             break;
 397
 398         case AL_SAMPLE_START_SOFT:
 399             values[0] = sound->Start;
 400             break;
 401
 402         case AL_SAMPLE_END_SOFT:
 403             values[0] = sound->End;
 404             break;
 405
 406         case AL_SAMPLE_LOOP_START_SOFT:
 407             values[0] = sound->LoopStart;
 408             break;
 409
 410         case AL_SAMPLE_LOOP_END_SOFT:
 411             values[0] = sound->LoopEnd;
 412             break;
 413
 414         case AL_SAMPLE_RATE_SOFT:
 415             values[0] = sound->SampleRate;
 416             break;
 417
 418         case AL_BASE_KEY_SOFT:
 419             values[0] = sound->PitchKey;
 420             break;
 421
 422         case AL_KEY_CORRECTION_SOFT:
 423             values[0] = sound->PitchCorrection;
 424             break;
 425
 426         case AL_SAMPLE_TYPE_SOFT:
 427             values[0] = sound->SampleType;
 428             break;
 429
 430         case AL_FONTSOUND_LINK_SOFT:
 431             values[0] = (sound->Link ? sound->Link->id : 0);
 432             break;
 433
 434         default:
 435             SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 436     }
 437
 438 done:
 439     ALCcontext_DecRef(context);
 440 }
 441
 442
 443 ALfontsound *NewFontsound(ALCcontext *context)
 444 {
 445     ALCdevice *device = context->Device;
 446     ALfontsound *sound;
 447     ALenum  err;
 448
 449     sound = calloc(1, sizeof(*sound));
 450     if(!sound)
 451         SET_ERROR_AND_RETURN_VALUE(context, AL_OUT_OF_MEMORY, NULL);
 452     ALfontsound_Construct(sound);
 453
 454     err = NewThunkEntry(&sound->id);
 455     if(err == AL_NO_ERROR)
 456         err = InsertUIntMapEntry(&device->FontsoundMap, sound->id, sound);
 457     if(err != AL_NO_ERROR)
 458     {
 459         ALfontsound_Destruct(sound);
 460         memset(sound, 0, sizeof(*sound));
 461         free(sound);
 462
 463         SET_ERROR_AND_RETURN_VALUE(context, err, NULL);
 464     }
 465
 466     return sound;
 467 }
 468
 469
 470 static void ALfontsound_Construct(ALfontsound *self)
 471 {
 472     self->ref = 0;
 473
 474     self->MinKey = 0;
 475     self->MaxKey = 127;
 476     self->MinVelocity = 0;
 477     self->MaxVelocity = 127;
 478
 479     self->ModLfoToPitch = 0;
 480     self->VibratoLfoToPitch = 0;
 481     self->ModEnvToPitch = 0;
 482
 483     self->FilterCutoff = 13500;
 484     self->FilterQ = 0;
 485     self->ModLfoToFilterCutoff = 0;
 486     self->ModEnvToFilterCutoff = 0;
 487     self->ModLfoToVolume = 0;
 488
 489     self->ChorusSend = 0;
 490     self->ReverbSend = 0;
 491
 492     self->Pan = 0;
 493
 494     self->ModLfo.Delay = 0;
 495     self->ModLfo.Frequency = 0;
 496
 497     self->VibratoLfo.Delay = 0;
 498     self->VibratoLfo.Frequency = 0;
 499
 500     self->ModEnv.DelayTime = -12000;
 501     self->ModEnv.AttackTime = -12000;
 502     self->ModEnv.HoldTime = -12000;
 503     self->ModEnv.DecayTime = -12000;
 504     self->ModEnv.SustainVol = 0;
 505     self->ModEnv.ReleaseTime = -12000;
 506     self->ModEnv.KeyToHoldTime = 0;
 507     self->ModEnv.KeyToDecayTime = 0;
 508
 509     self->VolEnv.DelayTime = -12000;
 510     self->VolEnv.AttackTime = -12000;
 511     self->VolEnv.HoldTime = -12000;
 512     self->VolEnv.DecayTime = -12000;
 513     self->VolEnv.SustainVol = 0;
 514     self->VolEnv.ReleaseTime = -12000;
 515     self->VolEnv.KeyToHoldTime = 0;
 516     self->VolEnv.KeyToDecayTime = 0;
 517
 518     self->Attenuation = 0;
 519
 520     self->CoarseTuning = 0;
 521     self->FineTuning = 0;
 522
 523     self->LoopMode = AL_NONE;
 524
 525     self->TuningScale = 100;
 526
 527     self->ExclusiveClass = 0;
 528
 529     self->Start = 0;
 530     self->End = 0;
 531     self->LoopStart = 0;
 532     self->LoopEnd = 0;
 533     self->SampleRate = 0;
 534     self->PitchKey = 0;
 535     self->PitchCorrection = 0;
 536     self->SampleType = AL_NONE;
 537     self->Link = NULL;
 538
 539     InitUIntMap(&self->ModulatorMap, ~0);
 540
 541     self->id = 0;
 542 }
 543
 544 void ALfontsound_Destruct(ALfontsound *self)
 545 {
 546     ALsizei i;
 547
 548     FreeThunkEntry(self->id);
 549     self->id = 0;
 550
 551     if(self->Link)
 552         DecrementRef(&self->Link->ref);
 553     self->Link = NULL;
 554
 555     for(i = 0;i < self->ModulatorMap.size;i++)
 556     {
 557         free(self->ModulatorMap.array[i].value);
 558         self->ModulatorMap.array[i].value = NULL;
 559     }
 560     ResetUIntMap(&self->ModulatorMap);
 561 }
 562
 563 void ALfontsound_setPropi(ALfontsound *self, ALCcontext *context, ALenum param, ALint value)
 564 {
 565     ALfontsound *link;
 566
 567     switch(param)
 568     {
 569         case AL_MOD_LFO_TO_PITCH_SOFT:
 570             self->ModLfoToPitch = value;
 571             break;
 572
 573         case AL_VIBRATO_LFO_TO_PITCH_SOFT:
 574             self->VibratoLfoToPitch = value;
 575             break;
 576
 577         case AL_MOD_ENV_TO_PITCH_SOFT:
 578             self->ModEnvToPitch = value;
 579             break;
 580
 581         case AL_FILTER_CUTOFF_SOFT:
 582             self->FilterCutoff = value;
 583             break;
 584
 585         case AL_FILTER_RESONANCE_SOFT:
 586             if(!(value >= 0))
 587                 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 588             self->FilterQ = value;
 589             break;
 590
 591         case AL_MOD_LFO_TO_FILTER_CUTOFF_SOFT:
 592             self->ModLfoToFilterCutoff = value;
 593             break;
 594
 595         case AL_MOD_ENV_TO_FILTER_CUTOFF_SOFT:
 596             self->ModEnvToFilterCutoff = value;
 597             break;
 598
 599         case AL_MOD_LFO_TO_VOLUME_SOFT:
 600             self->ModLfoToVolume = value;
 601             break;
 602
 603         case AL_CHORUS_SEND_SOFT:
 604             if(!(value >= 0 && value <= 1000))
 605                 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 606             self->ChorusSend = value;
 607             break;
 608         case AL_REVERB_SEND_SOFT:
 609             if(!(value >= 0 && value <= 1000))
 610                 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 611             self->ReverbSend = value;
 612             break;
 613
 614         case AL_PAN_SOFT:
 615             self->Pan = value;
 616             break;
 617
 618         case AL_MOD_LFO_DELAY_SOFT:
 619             self->ModLfo.Delay = value;
 620             break;
 621         case AL_MOD_LFO_FREQUENCY_SOFT:
 622             self->ModLfo.Frequency = value;
 623             break;
 624
 625         case AL_VIBRATO_LFO_DELAY_SOFT:
 626             self->VibratoLfo.Delay = value;
 627             break;
 628         case AL_VIBRATO_LFO_FREQUENCY_SOFT:
 629             self->VibratoLfo.Frequency = value;
 630             break;
 631
 632         case AL_MOD_ENV_DELAYTIME_SOFT:
 633             self->ModEnv.DelayTime = value;
 634             break;
 635         case AL_MOD_ENV_ATTACKTIME_SOFT:
 636             self->ModEnv.AttackTime = value;
 637             break;
 638         case AL_MOD_ENV_HOLDTIME_SOFT:
 639             self->ModEnv.HoldTime = value;
 640             break;
 641         case AL_MOD_ENV_DECAYTIME_SOFT:
 642             self->ModEnv.DecayTime = value;
 643             break;
 644         case AL_MOD_ENV_SUSTAINVOLUME_SOFT:
 645             self->ModEnv.SustainVol = value;
 646             break;
 647         case AL_MOD_ENV_RELEASETIME_SOFT:
 648             self->ModEnv.ReleaseTime = value;
 649             break;
 650         case AL_MOD_ENV_KEY_TO_HOLDTIME_SOFT:
 651             self->ModEnv.KeyToHoldTime = value;
 652             break;
 653         case AL_MOD_ENV_KEY_TO_DECAYTIME_SOFT:
 654             self->ModEnv.KeyToDecayTime = value;
 655             break;
 656
 657         case AL_VOLUME_ENV_DELAYTIME_SOFT:
 658             self->VolEnv.DelayTime = value;
 659             break;
 660         case AL_VOLUME_ENV_ATTACKTIME_SOFT:
 661             self->VolEnv.AttackTime = value;
 662             break;
 663         case AL_VOLUME_ENV_HOLDTIME_SOFT:
 664             self->VolEnv.HoldTime = value;
 665             break;
 666         case AL_VOLUME_ENV_DECAYTIME_SOFT:
 667             self->VolEnv.DecayTime = value;
 668             break;
 669         case AL_VOLUME_ENV_SUSTAINVOLUME_SOFT:
 670             self->VolEnv.SustainVol = value;
 671             break;
 672         case AL_VOLUME_ENV_RELEASETIME_SOFT:
 673             self->VolEnv.ReleaseTime = value;
 674             break;
 675         case AL_VOLUME_ENV_KEY_TO_HOLDTIME_SOFT:
 676             self->VolEnv.KeyToHoldTime = value;
 677             break;
 678         case AL_VOLUME_ENV_KEY_TO_DECAYTIME_SOFT:
 679             self->VolEnv.KeyToDecayTime = value;
 680             break;
 681
 682         case AL_ATTENUATION_SOFT:
 683             if(!(value >= 0))
 684                 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 685             self->Attenuation = value;
 686             break;
 687
 688         case AL_TUNING_COARSE_SOFT:
 689             self->CoarseTuning = value;
 690             break;
 691         case AL_TUNING_FINE_SOFT:
 692             self->FineTuning = value;
 693             break;
 694
 695         case AL_LOOP_MODE_SOFT:
 696             if(!(value == AL_NONE || value == AL_LOOP_CONTINUOUS_SOFT ||
 697                  value == AL_LOOP_UNTIL_RELEASE_SOFT))
 698                 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 699             self->LoopMode = value;
 700             break;
 701
 702         case AL_TUNING_SCALE_SOFT:
 703             self->TuningScale = value;
 704             break;
 705
 706         case AL_EXCLUSIVE_CLASS_SOFT:
 707             self->ExclusiveClass = value;
 708             break;
 709
 710         case AL_SAMPLE_START_SOFT:
 711             self->Start = value;
 712             break;
 713
 714         case AL_SAMPLE_END_SOFT:
 715             self->End = value;
 716             break;
 717
 718         case AL_SAMPLE_LOOP_START_SOFT:
 719             self->LoopStart = value;
 720             break;
 721
 722         case AL_SAMPLE_LOOP_END_SOFT:
 723             self->LoopEnd = value;
 724             break;
 725
 726         case AL_SAMPLE_RATE_SOFT:
 727             if(!(value > 0))
 728                 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 729             self->SampleRate = value;
 730             break;
 731
 732         case AL_BASE_KEY_SOFT:
 733             if(!((value >= 0 && value <= 127) || value == 255))
 734                 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 735             self->PitchKey = value;
 736             break;
 737
 738         case AL_KEY_CORRECTION_SOFT:
 739             if(!(value >= -99 && value <= 99))
 740                 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 741             self->PitchCorrection = value;
 742             break;
 743
 744         case AL_SAMPLE_TYPE_SOFT:
 745             if(!(value >= 1 && value <= 4))
 746                 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 747             self->SampleType = value;
 748             break;
 749
 750         case AL_FONTSOUND_LINK_SOFT:
 751             if(!value)
 752                 link = NULL;
 753             else
 754             {
 755                 link = LookupFontsound(context->Device, value);
 756                 if(!link)
 757                     SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 758             }
 759             if(link) IncrementRef(&link->ref);
 760             link = ExchangePtr((XchgPtr*)&self->Link, link);
 761             if(link) DecrementRef(&link->ref);
 762             break;
 763
 764         default:
 765             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 766     }
 767 }
 768
 769
 770 /* ReleaseALFontsounds
 771  *
 772  * Called to destroy any fontsounds that still exist on the device
 773  */
 774 void ReleaseALFontsounds(ALCdevice *device)
 775 {
 776     ALsizei i;
 777     for(i = 0;i < device->FontsoundMap.size;i++)
 778     {
 779         ALfontsound *temp = device->FontsoundMap.array[i].value;
 780         device->FontsoundMap.array[i].value = NULL;
 781
 782         ALfontsound_Destruct(temp);
 783
 784         memset(temp, 0, sizeof(*temp));
 785         free(temp);
 786     }
 787 }