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