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