OpenAL32/alAuxEffectSlot.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2007 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdlib.h>
  24 #include <math.h>
  25
  26 #include "AL/al.h"
  27 #include "AL/alc.h"
  28 #include "alMain.h"
  29 #include "alAuxEffectSlot.h"
  30 #include "alThunk.h"
  31 #include "alError.h"
  32 #include "alSource.h"
  33
  34
  35 extern inline struct ALeffectslot *LookupEffectSlot(ALCcontext *context, ALuint id);
  36 extern inline struct ALeffectslot *RemoveEffectSlot(ALCcontext *context, ALuint id);
  37
  38 static ALenum AddEffectSlotArray(ALCcontext *Context, ALeffectslot **start, ALsizei count);
  39 static void RemoveEffectSlotArray(ALCcontext *Context, const ALeffectslot *slot);
  40
  41
  42 static UIntMap EffectStateFactoryMap;
  43 static inline ALeffectStateFactory *getFactoryByType(ALenum type)
  44 {
  45     ALeffectStateFactory* (*getFactory)(void) = LookupUIntMapKey(&EffectStateFactoryMap, type);
  46     if(getFactory != NULL)
  47         return getFactory();
  48     return NULL;
  49 }
  50
  51
  52 AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
  53 {
  54     ALCcontext *context;
  55     VECTOR(ALeffectslot*) slotvec;
  56     ALsizei cur;
  57     ALenum err;
  58
  59     context = GetContextRef();
  60     if(!context) return;
  61
  62     VECTOR_INIT(slotvec);
  63
  64     if(!(n >= 0))
  65         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
  66     if(!VECTOR_RESERVE(slotvec, n))
  67         SET_ERROR_AND_GOTO(context, AL_OUT_OF_MEMORY, done);
  68
  69     for(cur = 0;cur < n;cur++)
  70     {
  71         ALeffectslot *slot = al_calloc(16, sizeof(ALeffectslot));
  72         err = AL_OUT_OF_MEMORY;
  73         if(!slot || (err=InitEffectSlot(slot)) != AL_NO_ERROR)
  74         {
  75             al_free(slot);
  76             alDeleteAuxiliaryEffectSlots(cur, effectslots);
  77             SET_ERROR_AND_GOTO(context, err, done);
  78         }
  79
  80         err = NewThunkEntry(&slot->id);
  81         if(err == AL_NO_ERROR)
  82             err = InsertUIntMapEntry(&context->EffectSlotMap, slot->id, slot);
  83         if(err != AL_NO_ERROR)
  84         {
  85             FreeThunkEntry(slot->id);
  86             DELETE_OBJ(slot->EffectState);
  87             al_free(slot);
  88
  89             alDeleteAuxiliaryEffectSlots(cur, effectslots);
  90             SET_ERROR_AND_GOTO(context, err, done);
  91         }
  92
  93         aluInitEffectPanning(slot);
  94
  95         VECTOR_PUSH_BACK(slotvec, slot);
  96
  97         effectslots[cur] = slot->id;
  98     }
  99     err = AddEffectSlotArray(context, VECTOR_ITER_BEGIN(slotvec), n);
 100     if(err != AL_NO_ERROR)
 101     {
 102         alDeleteAuxiliaryEffectSlots(cur, effectslots);
 103         SET_ERROR_AND_GOTO(context, err, done);
 104     }
 105
 106 done:
 107     VECTOR_DEINIT(slotvec);
 108
 109     ALCcontext_DecRef(context);
 110 }
 111
 112 AL_API ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, const ALuint *effectslots)
 113 {
 114     ALCcontext *context;
 115     ALeffectslot *slot;
 116     ALsizei i;
 117
 118     context = GetContextRef();
 119     if(!context) return;
 120
 121     if(!(n >= 0))
 122         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 123     for(i = 0;i < n;i++)
 124     {
 125         if((slot=LookupEffectSlot(context, effectslots[i])) == NULL)
 126             SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 127         if(ReadRef(&slot->ref) != 0)
 128             SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
 129     }
 130
 131     // All effectslots are valid
 132     for(i = 0;i < n;i++)
 133     {
 134         if((slot=RemoveEffectSlot(context, effectslots[i])) == NULL)
 135             continue;
 136         FreeThunkEntry(slot->id);
 137
 138         RemoveEffectSlotArray(context, slot);
 139         DELETE_OBJ(slot->EffectState);
 140
 141         memset(slot, 0, sizeof(*slot));
 142         al_free(slot);
 143     }
 144
 145 done:
 146     ALCcontext_DecRef(context);
 147 }
 148
 149 AL_API ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot)
 150 {
 151     ALCcontext *context;
 152     ALboolean  ret;
 153
 154     context = GetContextRef();
 155     if(!context) return AL_FALSE;
 156
 157     ret = (LookupEffectSlot(context, effectslot) ? AL_TRUE : AL_FALSE);
 158
 159     ALCcontext_DecRef(context);
 160
 161     return ret;
 162 }
 163
 164 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint value)
 165 {
 166     ALCdevice *device;
 167     ALCcontext *context;
 168     ALeffectslot *slot;
 169     ALeffect *effect = NULL;
 170     ALenum err;
 171
 172     context = GetContextRef();
 173     if(!context) return;
 174
 175     device = context->Device;
 176     if((slot=LookupEffectSlot(context, effectslot)) == NULL)
 177         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 178     switch(param)
 179     {
 180     case AL_EFFECTSLOT_EFFECT:
 181         effect = (value ? LookupEffect(device, value) : NULL);
 182         if(!(value == 0 || effect != NULL))
 183             SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 184
 185         err = InitializeEffect(device, slot, effect);
 186         if(err != AL_NO_ERROR)
 187             SET_ERROR_AND_GOTO(context, err, done);
 188         ATOMIC_STORE(&context->UpdateSources, AL_TRUE);
 189         break;
 190
 191     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 192         if(!(value == AL_TRUE || value == AL_FALSE))
 193             SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 194
 195         slot->AuxSendAuto = value;
 196         ATOMIC_STORE(&context->UpdateSources, AL_TRUE);
 197         break;
 198
 199     default:
 200         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 201     }
 202
 203 done:
 204     ALCcontext_DecRef(context);
 205 }
 206
 207 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, const ALint *values)
 208 {
 209     ALCcontext *context;
 210
 211     switch(param)
 212     {
 213     case AL_EFFECTSLOT_EFFECT:
 214     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 215         alAuxiliaryEffectSloti(effectslot, param, values[0]);
 216         return;
 217     }
 218
 219     context = GetContextRef();
 220     if(!context) return;
 221
 222     if(LookupEffectSlot(context, effectslot) == NULL)
 223         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 224     switch(param)
 225     {
 226     default:
 227         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 228     }
 229
 230 done:
 231     ALCcontext_DecRef(context);
 232 }
 233
 234 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat value)
 235 {
 236     ALCcontext *context;
 237     ALeffectslot *slot;
 238
 239     context = GetContextRef();
 240     if(!context) return;
 241
 242     if((slot=LookupEffectSlot(context, effectslot)) == NULL)
 243         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 244     switch(param)
 245     {
 246     case AL_EFFECTSLOT_GAIN:
 247         if(!(value >= 0.0f && value <= 1.0f))
 248             SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 249
 250         slot->Gain = value;
 251         ATOMIC_STORE(&slot->NeedsUpdate, AL_TRUE);
 252         break;
 253
 254     default:
 255         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 256     }
 257
 258 done:
 259     ALCcontext_DecRef(context);
 260 }
 261
 262 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, const ALfloat *values)
 263 {
 264     ALCcontext *context;
 265
 266     switch(param)
 267     {
 268     case AL_EFFECTSLOT_GAIN:
 269         alAuxiliaryEffectSlotf(effectslot, param, values[0]);
 270         return;
 271     }
 272
 273     context = GetContextRef();
 274     if(!context) return;
 275
 276     if(LookupEffectSlot(context, effectslot) == NULL)
 277         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 278     switch(param)
 279     {
 280     default:
 281         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 282     }
 283
 284 done:
 285     ALCcontext_DecRef(context);
 286 }
 287
 288 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *value)
 289 {
 290     ALCcontext *context;
 291     ALeffectslot *slot;
 292
 293     context = GetContextRef();
 294     if(!context) return;
 295
 296     if((slot=LookupEffectSlot(context, effectslot)) == NULL)
 297         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 298     switch(param)
 299     {
 300     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 301         *value = slot->AuxSendAuto;
 302         break;
 303
 304     default:
 305         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 306     }
 307
 308 done:
 309     ALCcontext_DecRef(context);
 310 }
 311
 312 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *values)
 313 {
 314     ALCcontext *context;
 315
 316     switch(param)
 317     {
 318     case AL_EFFECTSLOT_EFFECT:
 319     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 320         alGetAuxiliaryEffectSloti(effectslot, param, values);
 321         return;
 322     }
 323
 324     context = GetContextRef();
 325     if(!context) return;
 326
 327     if(LookupEffectSlot(context, effectslot) == NULL)
 328         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 329     switch(param)
 330     {
 331     default:
 332         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 333     }
 334
 335 done:
 336     ALCcontext_DecRef(context);
 337 }
 338
 339 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *value)
 340 {
 341     ALCcontext *context;
 342     ALeffectslot *slot;
 343
 344     context = GetContextRef();
 345     if(!context) return;
 346
 347     if((slot=LookupEffectSlot(context, effectslot)) == NULL)
 348         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 349     switch(param)
 350     {
 351     case AL_EFFECTSLOT_GAIN:
 352         *value = slot->Gain;
 353         break;
 354
 355     default:
 356         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 357     }
 358
 359 done:
 360     ALCcontext_DecRef(context);
 361 }
 362
 363 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *values)
 364 {
 365     ALCcontext *context;
 366
 367     switch(param)
 368     {
 369     case AL_EFFECTSLOT_GAIN:
 370         alGetAuxiliaryEffectSlotf(effectslot, param, values);
 371         return;
 372     }
 373
 374     context = GetContextRef();
 375     if(!context) return;
 376
 377     if(LookupEffectSlot(context, effectslot) == NULL)
 378         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 379     switch(param)
 380     {
 381     default:
 382         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 383     }
 384
 385 done:
 386     ALCcontext_DecRef(context);
 387 }
 388
 389
 390 static ALenum AddEffectSlotArray(ALCcontext *context, ALeffectslot **start, ALsizei count)
 391 {
 392     ALenum err = AL_NO_ERROR;
 393
 394     LockContext(context);
 395     if(!VECTOR_INSERT(context->ActiveAuxSlots, VECTOR_ITER_END(context->ActiveAuxSlots), start, start+count))
 396         err = AL_OUT_OF_MEMORY;
 397     UnlockContext(context);
 398
 399     return err;
 400 }
 401
 402 static void RemoveEffectSlotArray(ALCcontext *context, const ALeffectslot *slot)
 403 {
 404     ALeffectslot **iter;
 405
 406     LockContext(context);
 407 #define MATCH_SLOT(_i)  (slot == *(_i))
 408     VECTOR_FIND_IF(iter, ALeffectslot*, context->ActiveAuxSlots, MATCH_SLOT);
 409     if(iter != VECTOR_ITER_END(context->ActiveAuxSlots))
 410     {
 411         *iter = VECTOR_BACK(context->ActiveAuxSlots);
 412         VECTOR_POP_BACK(context->ActiveAuxSlots);
 413     }
 414 #undef MATCH_SLOT
 415     UnlockContext(context);
 416 }
 417
 418
 419 void InitEffectFactoryMap(void)
 420 {
 421     InitUIntMap(&EffectStateFactoryMap, ~0);
 422
 423     InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_NULL, ALnullStateFactory_getFactory);
 424     InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_EAXREVERB, ALreverbStateFactory_getFactory);
 425     InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_REVERB, ALreverbStateFactory_getFactory);
 426     InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_AUTOWAH, ALautowahStateFactory_getFactory);
 427     InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_CHORUS, ALchorusStateFactory_getFactory);
 428     InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_COMPRESSOR, ALcompressorStateFactory_getFactory);
 429     InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_DISTORTION, ALdistortionStateFactory_getFactory);
 430     InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_ECHO, ALechoStateFactory_getFactory);
 431     InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_EQUALIZER, ALequalizerStateFactory_getFactory);
 432     InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_FLANGER, ALflangerStateFactory_getFactory);
 433     InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_RING_MODULATOR, ALmodulatorStateFactory_getFactory);
 434     InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_DEDICATED_DIALOGUE, ALdedicatedStateFactory_getFactory);
 435     InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT, ALdedicatedStateFactory_getFactory);
 436 }
 437
 438 void DeinitEffectFactoryMap(void)
 439 {
 440     ResetUIntMap(&EffectStateFactoryMap);
 441 }
 442
 443
 444 ALenum InitializeEffect(ALCdevice *Device, ALeffectslot *EffectSlot, ALeffect *effect)
 445 {
 446     ALenum newtype = (effect ? effect->type : AL_EFFECT_NULL);
 447     ALeffectStateFactory *factory;
 448
 449     if(newtype != EffectSlot->EffectType)
 450     {
 451         ALeffectState *State;
 452         FPUCtl oldMode;
 453
 454         factory = getFactoryByType(newtype);
 455         if(!factory)
 456         {
 457             ERR("Failed to find factory for effect type 0x%04x\n", newtype);
 458             return AL_INVALID_ENUM;
 459         }
 460         State = V0(factory,create)();
 461         if(!State)
 462             return AL_OUT_OF_MEMORY;
 463
 464         SetMixerFPUMode(&oldMode);
 465
 466         ALCdevice_Lock(Device);
 467         if(V(State,deviceUpdate)(Device) == AL_FALSE)
 468         {
 469             ALCdevice_Unlock(Device);
 470             RestoreFPUMode(&oldMode);
 471             DELETE_OBJ(State);
 472             return AL_OUT_OF_MEMORY;
 473         }
 474
 475         State = ExchangePtr((XchgPtr*)&EffectSlot->EffectState, State);
 476         if(!effect)
 477         {
 478             memset(&EffectSlot->EffectProps, 0, sizeof(EffectSlot->EffectProps));
 479             EffectSlot->EffectType = AL_EFFECT_NULL;
 480         }
 481         else
 482         {
 483             memcpy(&EffectSlot->EffectProps, &effect->Props, sizeof(effect->Props));
 484             EffectSlot->EffectType = effect->type;
 485         }
 486
 487         /* FIXME: This should be done asynchronously, but since the EffectState
 488          * object was changed, it needs an update before its Process method can
 489          * be called. */
 490         ATOMIC_STORE(&EffectSlot->NeedsUpdate, AL_FALSE);
 491         V(EffectSlot->EffectState,update)(Device, EffectSlot);
 492         ALCdevice_Unlock(Device);
 493
 494         RestoreFPUMode(&oldMode);
 495
 496         DELETE_OBJ(State);
 497         State = NULL;
 498     }
 499     else
 500     {
 501         if(effect)
 502         {
 503             ALCdevice_Lock(Device);
 504             memcpy(&EffectSlot->EffectProps, &effect->Props, sizeof(effect->Props));
 505             ALCdevice_Unlock(Device);
 506             ATOMIC_STORE(&EffectSlot->NeedsUpdate, AL_TRUE);
 507         }
 508     }
 509
 510     return AL_NO_ERROR;
 511 }
 512
 513
 514 ALenum InitEffectSlot(ALeffectslot *slot)
 515 {
 516     ALeffectStateFactory *factory;
 517     ALuint i, c;
 518
 519     slot->EffectType = AL_EFFECT_NULL;
 520
 521     factory = getFactoryByType(AL_EFFECT_NULL);
 522     if(!(slot->EffectState=V0(factory,create)()))
 523         return AL_OUT_OF_MEMORY;
 524
 525     slot->Gain = 1.0;
 526     slot->AuxSendAuto = AL_TRUE;
 527     ATOMIC_INIT(&slot->NeedsUpdate, AL_FALSE);
 528     for(c = 0;c < 1;c++)
 529     {
 530         for(i = 0;i < BUFFERSIZE;i++)
 531             slot->WetBuffer[c][i] = 0.0f;
 532     }
 533     InitRef(&slot->ref, 0);
 534
 535     return AL_NO_ERROR;
 536 }
 537
 538 ALvoid ReleaseALAuxiliaryEffectSlots(ALCcontext *Context)
 539 {
 540     ALsizei pos;
 541     for(pos = 0;pos < Context->EffectSlotMap.size;pos++)
 542     {
 543         ALeffectslot *temp = Context->EffectSlotMap.array[pos].value;
 544         Context->EffectSlotMap.array[pos].value = NULL;
 545
 546         DELETE_OBJ(temp->EffectState);
 547
 548         FreeThunkEntry(temp->id);
 549         memset(temp, 0, sizeof(ALeffectslot));
 550         al_free(temp);
 551     }
 552 }