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., 59 Temple Place - Suite 330,
  17  *  Boston, MA  02111-1307, 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 static ALvoid InitializeEffect(ALCcontext *Context, ALeffectslot *EffectSlot, ALeffect *effect);
  36
  37 DECL_VERIFIER(Effect, ALeffect, effect)
  38
  39 #define LookupEffectSlot(m, k) ((ALeffectslot*)LookupUIntMapKey(&(m), (k)))
  40
  41 AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
  42 {
  43     ALCcontext *Context;
  44     ALsizei i=0, j;
  45
  46     Context = GetContextSuspended();
  47     if(!Context) return;
  48
  49     if(n > 0)
  50     {
  51         ALCdevice *Device = Context->Device;
  52
  53         if(Context->EffectSlotMap.size+n <= (ALsizei)Device->AuxiliaryEffectSlotMax)
  54         {
  55             // Check that enough memory has been allocted in the 'effectslots' array for n Effect Slots
  56             if(!IsBadWritePtr((void*)effectslots, n * sizeof(ALuint)))
  57             {
  58                 ALenum err;
  59
  60                 while(i < n)
  61                 {
  62                     ALeffectslot *slot = calloc(1, sizeof(ALeffectslot));
  63                     if(!slot || !(slot->EffectState=NoneCreate()))
  64                     {
  65                         free(slot);
  66                         // We must have run out or memory
  67                         alSetError(Context, AL_OUT_OF_MEMORY);
  68                         alDeleteAuxiliaryEffectSlots(i, effectslots);
  69                         break;
  70                     }
  71
  72                     slot->effectslot = (ALuint)ALTHUNK_ADDENTRY(slot);
  73                     err = InsertUIntMapEntry(&Context->EffectSlotMap,
  74                                              slot->effectslot, slot);
  75                     if(err != AL_NO_ERROR)
  76                     {
  77                         ALTHUNK_REMOVEENTRY(slot->effectslot);
  78                         ALEffect_Destroy(slot->EffectState);
  79                         free(slot);
  80
  81                         alSetError(Context, err);
  82                         alDeleteAuxiliaryEffectSlots(i, effectslots);
  83                         break;
  84                     }
  85
  86                     effectslots[i++] = slot->effectslot;
  87
  88                     slot->Gain = 1.0;
  89                     slot->AuxSendAuto = AL_TRUE;
  90                     for(j = 0;j < BUFFERSIZE;j++)
  91                         slot->WetBuffer[j] = 0.0f;
  92                     slot->refcount = 0;
  93                 }
  94             }
  95         }
  96         else
  97             alSetError(Context, AL_INVALID_OPERATION);
  98     }
  99
 100     ProcessContext(Context);
 101 }
 102
 103 AL_API ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
 104 {
 105     ALCcontext *Context;
 106     ALeffectslot *EffectSlot;
 107     ALsizei i;
 108
 109     Context = GetContextSuspended();
 110     if(!Context) return;
 111
 112     if (n >= 0)
 113     {
 114         // Check that all effectslots are valid
 115         for (i = 0; i < n; i++)
 116         {
 117             if((EffectSlot=LookupEffectSlot(Context->EffectSlotMap, effectslots[i])) == NULL)
 118             {
 119                 alSetError(Context, AL_INVALID_NAME);
 120                 break;
 121             }
 122             else
 123             {
 124                 if(EffectSlot->refcount > 0)
 125                 {
 126                     alSetError(Context, AL_INVALID_NAME);
 127                     break;
 128                 }
 129             }
 130         }
 131
 132         if (i == n)
 133         {
 134             // All effectslots are valid
 135             for (i = 0; i < n; i++)
 136             {
 137                 // Recheck that the effectslot is valid, because there could be duplicated names
 138                 if((EffectSlot=LookupEffectSlot(Context->EffectSlotMap, effectslots[i])) != NULL)
 139                 {
 140                     ALEffect_Destroy(EffectSlot->EffectState);
 141
 142                     RemoveUIntMapKey(&Context->EffectSlotMap, EffectSlot->effectslot);
 143                     ALTHUNK_REMOVEENTRY(EffectSlot->effectslot);
 144
 145                     memset(EffectSlot, 0, sizeof(ALeffectslot));
 146                     free(EffectSlot);
 147                 }
 148             }
 149         }
 150     }
 151     else
 152         alSetError(Context, AL_INVALID_VALUE);
 153
 154     ProcessContext(Context);
 155 }
 156
 157 AL_API ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot)
 158 {
 159     ALCcontext *Context;
 160     ALboolean  result;
 161
 162     Context = GetContextSuspended();
 163     if(!Context) return AL_FALSE;
 164
 165     result = (LookupEffectSlot(Context->EffectSlotMap, effectslot) ?
 166               AL_TRUE : AL_FALSE);
 167
 168     ProcessContext(Context);
 169
 170     return result;
 171 }
 172
 173 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue)
 174 {
 175     ALCcontext *Context;
 176     ALboolean updateSources = AL_FALSE;
 177     ALeffectslot *EffectSlot;
 178
 179     Context = GetContextSuspended();
 180     if(!Context) return;
 181
 182     if((EffectSlot=LookupEffectSlot(Context->EffectSlotMap, effectslot)) != NULL)
 183     {
 184         switch(param)
 185         {
 186         case AL_EFFECTSLOT_EFFECT: {
 187             ALeffect *effect = NULL;
 188
 189             if(iValue == 0 ||
 190                (effect=VerifyEffect(Context->Device->EffectList, iValue)) != NULL)
 191             {
 192                 InitializeEffect(Context, EffectSlot, effect);
 193                 updateSources = AL_TRUE;
 194             }
 195             else
 196                 alSetError(Context, AL_INVALID_VALUE);
 197         }   break;
 198
 199         case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 200             if(iValue == AL_TRUE || iValue == AL_FALSE)
 201             {
 202                 EffectSlot->AuxSendAuto = iValue;
 203                 updateSources = AL_TRUE;
 204             }
 205             else
 206                 alSetError(Context, AL_INVALID_VALUE);
 207             break;
 208
 209         default:
 210             alSetError(Context, AL_INVALID_ENUM);
 211             break;
 212         }
 213     }
 214     else
 215         alSetError(Context, AL_INVALID_NAME);
 216
 217     // Force updating the sources that use this slot, since it affects the
 218     // sending parameters
 219     if(updateSources)
 220     {
 221         ALsizei pos;
 222         for(pos = 0;pos < Context->SourceMap.size;pos++)
 223         {
 224             ALsource *source = Context->SourceMap.array[pos].value;
 225             ALuint i;
 226             for(i = 0;i < MAX_SENDS;i++)
 227             {
 228                 if(!source->Send[i].Slot ||
 229                    source->Send[i].Slot->effectslot != effectslot)
 230                     continue;
 231                 source->NeedsUpdate = AL_TRUE;
 232                 break;
 233             }
 234         }
 235     }
 236
 237     ProcessContext(Context);
 238 }
 239
 240 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues)
 241 {
 242     ALCcontext *Context;
 243
 244     Context = GetContextSuspended();
 245     if(!Context) return;
 246
 247     if(LookupEffectSlot(Context->EffectSlotMap, effectslot) != NULL)
 248     {
 249         switch(param)
 250         {
 251         case AL_EFFECTSLOT_EFFECT:
 252         case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 253             alAuxiliaryEffectSloti(effectslot, param, piValues[0]);
 254             break;
 255
 256         default:
 257             alSetError(Context, AL_INVALID_ENUM);
 258             break;
 259         }
 260     }
 261     else
 262         alSetError(Context, AL_INVALID_NAME);
 263
 264     ProcessContext(Context);
 265 }
 266
 267 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat flValue)
 268 {
 269     ALCcontext *Context;
 270     ALeffectslot *EffectSlot;
 271
 272     Context = GetContextSuspended();
 273     if(!Context) return;
 274
 275     if((EffectSlot=LookupEffectSlot(Context->EffectSlotMap, effectslot)) != NULL)
 276     {
 277         switch(param)
 278         {
 279         case AL_EFFECTSLOT_GAIN:
 280             if(flValue >= 0.0f && flValue <= 1.0f)
 281                 EffectSlot->Gain = flValue;
 282             else
 283                 alSetError(Context, AL_INVALID_VALUE);
 284             break;
 285
 286         default:
 287             alSetError(Context, AL_INVALID_ENUM);
 288             break;
 289         }
 290     }
 291     else
 292         alSetError(Context, AL_INVALID_NAME);
 293
 294     ProcessContext(Context);
 295 }
 296
 297 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues)
 298 {
 299     ALCcontext *Context;
 300
 301     Context = GetContextSuspended();
 302     if(!Context) return;
 303
 304     if(LookupEffectSlot(Context->EffectSlotMap, effectslot) != NULL)
 305     {
 306         switch(param)
 307         {
 308         case AL_EFFECTSLOT_GAIN:
 309             alAuxiliaryEffectSlotf(effectslot, param, pflValues[0]);
 310             break;
 311
 312         default:
 313             alSetError(Context, AL_INVALID_ENUM);
 314             break;
 315         }
 316     }
 317     else
 318         alSetError(Context, AL_INVALID_NAME);
 319
 320     ProcessContext(Context);
 321 }
 322
 323 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *piValue)
 324 {
 325     ALCcontext *Context;
 326     ALeffectslot *EffectSlot;
 327
 328     Context = GetContextSuspended();
 329     if(!Context) return;
 330
 331     if((EffectSlot=LookupEffectSlot(Context->EffectSlotMap, effectslot)) != NULL)
 332     {
 333         switch(param)
 334         {
 335         case AL_EFFECTSLOT_EFFECT:
 336             *piValue = EffectSlot->effect.effect;
 337             break;
 338
 339         case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 340             *piValue = EffectSlot->AuxSendAuto;
 341             break;
 342
 343         default:
 344             alSetError(Context, AL_INVALID_ENUM);
 345             break;
 346         }
 347     }
 348     else
 349         alSetError(Context, AL_INVALID_NAME);
 350
 351     ProcessContext(Context);
 352 }
 353
 354 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues)
 355 {
 356     ALCcontext *Context;
 357
 358     Context = GetContextSuspended();
 359     if(!Context) return;
 360
 361     if(LookupEffectSlot(Context->EffectSlotMap, effectslot) != NULL)
 362     {
 363         switch(param)
 364         {
 365         case AL_EFFECTSLOT_EFFECT:
 366         case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 367             alGetAuxiliaryEffectSloti(effectslot, param, piValues);
 368             break;
 369
 370         default:
 371             alSetError(Context, AL_INVALID_ENUM);
 372             break;
 373         }
 374     }
 375     else
 376         alSetError(Context, AL_INVALID_NAME);
 377
 378     ProcessContext(Context);
 379 }
 380
 381 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *pflValue)
 382 {
 383     ALCcontext *Context;
 384     ALeffectslot *EffectSlot;
 385
 386     Context = GetContextSuspended();
 387     if(!Context) return;
 388
 389     if((EffectSlot=LookupEffectSlot(Context->EffectSlotMap, effectslot)) != NULL)
 390     {
 391         switch(param)
 392         {
 393         case AL_EFFECTSLOT_GAIN:
 394             *pflValue = EffectSlot->Gain;
 395             break;
 396
 397         default:
 398             alSetError(Context, AL_INVALID_ENUM);
 399             break;
 400         }
 401     }
 402     else
 403         alSetError(Context, AL_INVALID_NAME);
 404
 405     ProcessContext(Context);
 406 }
 407
 408 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues)
 409 {
 410     ALCcontext *Context;
 411
 412     Context = GetContextSuspended();
 413     if(!Context) return;
 414
 415     if(LookupEffectSlot(Context->EffectSlotMap, effectslot) != NULL)
 416     {
 417         switch(param)
 418         {
 419         case AL_EFFECTSLOT_GAIN:
 420             alGetAuxiliaryEffectSlotf(effectslot, param, pflValues);
 421             break;
 422
 423         default:
 424             alSetError(Context, AL_INVALID_ENUM);
 425             break;
 426         }
 427     }
 428     else
 429         alSetError(Context, AL_INVALID_NAME);
 430
 431     ProcessContext(Context);
 432 }
 433
 434
 435 static ALvoid NoneDestroy(ALeffectState *State)
 436 { free(State); }
 437 static ALboolean NoneDeviceUpdate(ALeffectState *State, ALCdevice *Device)
 438 {
 439     return AL_TRUE;
 440     (void)State;
 441     (void)Device;
 442 }
 443 static ALvoid NoneUpdate(ALeffectState *State, ALCcontext *Context, const ALeffect *Effect)
 444 {
 445     (void)State;
 446     (void)Context;
 447     (void)Effect;
 448 }
 449 static ALvoid NoneProcess(ALeffectState *State, const ALeffectslot *Slot, ALuint SamplesToDo, const ALfloat *SamplesIn, ALfloat (*SamplesOut)[OUTPUTCHANNELS])
 450 {
 451     (void)State;
 452     (void)Slot;
 453     (void)SamplesToDo;
 454     (void)SamplesIn;
 455     (void)SamplesOut;
 456 }
 457 ALeffectState *NoneCreate(void)
 458 {
 459     ALeffectState *state;
 460
 461     state = calloc(1, sizeof(*state));
 462     if(!state)
 463         return NULL;
 464
 465     state->Destroy = NoneDestroy;
 466     state->DeviceUpdate = NoneDeviceUpdate;
 467     state->Update = NoneUpdate;
 468     state->Process = NoneProcess;
 469
 470     return state;
 471 }
 472
 473 static ALvoid InitializeEffect(ALCcontext *Context, ALeffectslot *EffectSlot, ALeffect *effect)
 474 {
 475     if(EffectSlot->effect.type != (effect?effect->type:AL_EFFECT_NULL))
 476     {
 477         ALeffectState *NewState = NULL;
 478         if(!effect || effect->type == AL_EFFECT_NULL)
 479             NewState = NoneCreate();
 480         else if(effect->type == AL_EFFECT_EAXREVERB)
 481             NewState = EAXVerbCreate();
 482         else if(effect->type == AL_EFFECT_REVERB)
 483             NewState = VerbCreate();
 484         else if(effect->type == AL_EFFECT_ECHO)
 485             NewState = EchoCreate();
 486         else if(effect->type == AL_EFFECT_RING_MODULATOR)
 487             NewState = ModulatorCreate();
 488         /* No new state? An error occured.. */
 489         if(NewState == NULL ||
 490            ALEffect_DeviceUpdate(NewState, Context->Device) == AL_FALSE)
 491         {
 492             if(NewState)
 493                 ALEffect_Destroy(NewState);
 494             alSetError(Context, AL_OUT_OF_MEMORY);
 495             return;
 496         }
 497         if(EffectSlot->EffectState)
 498             ALEffect_Destroy(EffectSlot->EffectState);
 499         EffectSlot->EffectState = NewState;
 500     }
 501     if(!effect)
 502         memset(&EffectSlot->effect, 0, sizeof(EffectSlot->effect));
 503     else
 504         memcpy(&EffectSlot->effect, effect, sizeof(*effect));
 505     ALEffect_Update(EffectSlot->EffectState, Context, effect);
 506 }
 507
 508
 509 ALvoid ReleaseALAuxiliaryEffectSlots(ALCcontext *Context)
 510 {
 511     ALsizei pos;
 512     for(pos = 0;pos < Context->EffectSlotMap.size;pos++)
 513     {
 514         ALeffectslot *temp = Context->EffectSlotMap.array[pos].value;
 515         Context->EffectSlotMap.array[pos].value = NULL;
 516
 517         // Release effectslot structure
 518         ALEffect_Destroy(temp->EffectState);
 519
 520         ALTHUNK_REMOVEENTRY(temp->effectslot);
 521         memset(temp, 0, sizeof(ALeffectslot));
 522         free(temp);
 523     }
 524 }