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