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