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