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