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
  25 #include "AL/al.h"
  26 #include "AL/alc.h"
  27 #include "alMain.h"
  28 #include "alAuxEffectSlot.h"
  29 #include "alThunk.h"
  30 #include "alError.h"
  31
  32
  33 AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
  34 {
  35     ALCcontext *Context;
  36     ALsizei i;
  37
  38     Context = alcGetCurrentContext();
  39     if(!Context)
  40     {
  41         alSetError(AL_INVALID_OPERATION);
  42         return;
  43     }
  44     SuspendContext(Context);
  45
  46     if (n > 0)
  47     {
  48         /* NOTE: We only support one slot currently */
  49         if(n == 1 && Context->AuxiliaryEffectSlotCount == 0)
  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                     (*list)->refcount = 0;
  73
  74                     effectslots[i] = (ALuint)ALTHUNK_ADDENTRY(*list);
  75                     (*list)->effectslot = effectslots[i];
  76
  77                     Context->AuxiliaryEffectSlotCount++;
  78                     i++;
  79
  80                     list = &(*list)->next;
  81                 }
  82             }
  83         }
  84         else
  85             alSetError(AL_INVALID_OPERATION);
  86     }
  87
  88     ProcessContext(Context);
  89 }
  90
  91 AL_API ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
  92 {
  93     ALCcontext *Context;
  94     ALeffectslot *ALAuxiliaryEffectSlot;
  95     ALsizei i;
  96
  97     Context = alcGetCurrentContext();
  98     if(!Context)
  99     {
 100         alSetError(AL_INVALID_OPERATION);
 101         return;
 102     }
 103     SuspendContext(Context);
 104
 105     if (n >= 0)
 106     {
 107         // Check that all effectslots are valid
 108         for (i = 0; i < n; i++)
 109         {
 110             if (!alIsAuxiliaryEffectSlot(effectslots[i]))
 111             {
 112                 alSetError(AL_INVALID_NAME);
 113                 break;
 114             }
 115             else
 116             {
 117                 ALAuxiliaryEffectSlot = (ALeffectslot*)ALTHUNK_LOOKUPENTRY(effectslots[i]);
 118                 if(ALAuxiliaryEffectSlot->refcount > 0)
 119                 {
 120                     alSetError(AL_INVALID_NAME);
 121                     break;
 122                 }
 123             }
 124         }
 125
 126         if (i == n)
 127         {
 128             // All effectslots are valid
 129             for (i = 0; i < n; i++)
 130             {
 131                 // Recheck that the effectslot is valid, because there could be duplicated names
 132                 if (alIsAuxiliaryEffectSlot(effectslots[i]))
 133                 {
 134                     ALeffectslot **list;
 135
 136                     ALAuxiliaryEffectSlot = ((ALeffectslot*)ALTHUNK_LOOKUPENTRY(effectslots[i]));
 137
 138                     // Remove Source from list of Sources
 139                     list = &Context->AuxiliaryEffectSlot;
 140                     while(*list && *list != ALAuxiliaryEffectSlot)
 141                          list = &(*list)->next;
 142
 143                     if(*list)
 144                         *list = (*list)->next;
 145                     ALTHUNK_REMOVEENTRY(ALAuxiliaryEffectSlot->effectslot);
 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 AL_API ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot)
 162 {
 163     ALCcontext *Context;
 164     ALeffectslot **list;
 165
 166     Context = alcGetCurrentContext();
 167     if(!Context)
 168     {
 169         alSetError(AL_INVALID_OPERATION);
 170         return AL_FALSE;
 171     }
 172     SuspendContext(Context);
 173
 174     list = &Context->AuxiliaryEffectSlot;
 175     while(*list && (*list)->effectslot != effectslot)
 176         list = &(*list)->next;
 177
 178     ProcessContext(Context);
 179
 180     return (*list ? AL_TRUE : AL_FALSE);
 181 }
 182
 183 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue)
 184 {
 185     ALCcontext *Context;
 186
 187     Context = alcGetCurrentContext();
 188     if(!Context)
 189     {
 190         alSetError(AL_INVALID_OPERATION);
 191         return;
 192     }
 193     SuspendContext(Context);
 194
 195     if (alIsAuxiliaryEffectSlot(effectslot))
 196     {
 197         ALeffectslot *ALEffectSlot = (ALeffectslot*)ALTHUNK_LOOKUPENTRY(effectslot);
 198
 199         switch(param)
 200         {
 201         case AL_EFFECTSLOT_EFFECT:
 202             if(alIsEffect(iValue))
 203             {
 204                 ALeffect *effect = (ALeffect*)ALTHUNK_LOOKUPENTRY(iValue);
 205                 if(!effect)
 206                 {
 207                     ALEffectSlot->effect.type = AL_EFFECT_NULL;
 208                     ALEffectSlot->effect.effect = 0;
 209                 }
 210                 else
 211                     memcpy(&ALEffectSlot->effect, effect, sizeof(*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 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues)
 236 {
 237     ALCcontext *Context;
 238
 239     Context = alcGetCurrentContext();
 240     if(!Context)
 241     {
 242         alSetError(AL_INVALID_OPERATION);
 243         return;
 244     }
 245     SuspendContext(Context);
 246
 247     if (alIsAuxiliaryEffectSlot(effectslot))
 248     {
 249         switch(param)
 250         {
 251         case AL_EFFECTSLOT_EFFECT:
 252         case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 253             alAuxiliaryEffectSloti(effectslot, param, piValues[0]);
 254             break;
 255
 256         default:
 257             alSetError(AL_INVALID_ENUM);
 258             break;
 259         }
 260     }
 261     else
 262         alSetError(AL_INVALID_NAME);
 263
 264     ProcessContext(Context);
 265 }
 266
 267 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat flValue)
 268 {
 269     ALCcontext *Context;
 270
 271     Context = alcGetCurrentContext();
 272     if(!Context)
 273     {
 274         alSetError(AL_INVALID_OPERATION);
 275         return;
 276     }
 277     SuspendContext(Context);
 278
 279     if (alIsAuxiliaryEffectSlot(effectslot))
 280     {
 281         ALeffectslot *ALEffectSlot = (ALeffectslot*)ALTHUNK_LOOKUPENTRY(effectslot);
 282
 283         switch(param)
 284         {
 285         case AL_EFFECTSLOT_GAIN:
 286             if(flValue >= 0.0f && flValue <= 1.0f)
 287                 ALEffectSlot->Gain = flValue;
 288             else
 289                 alSetError(AL_INVALID_VALUE);
 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 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues)
 304 {
 305     ALCcontext *Context;
 306
 307     Context = alcGetCurrentContext();
 308     if(!Context)
 309     {
 310         alSetError(AL_INVALID_OPERATION);
 311         return;
 312     }
 313     SuspendContext(Context);
 314
 315     if (alIsAuxiliaryEffectSlot(effectslot))
 316     {
 317         switch(param)
 318         {
 319         case AL_EFFECTSLOT_GAIN:
 320             alAuxiliaryEffectSlotf(effectslot, param, pflValues[0]);
 321             break;
 322
 323         default:
 324             alSetError(AL_INVALID_ENUM);
 325             break;
 326         }
 327     }
 328     else
 329         alSetError(AL_INVALID_NAME);
 330
 331     ProcessContext(Context);
 332 }
 333
 334 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *piValue)
 335 {
 336     ALCcontext *Context;
 337
 338     Context = alcGetCurrentContext();
 339     if(!Context)
 340     {
 341         alSetError(AL_INVALID_OPERATION);
 342         return;
 343     }
 344     SuspendContext(Context);
 345
 346     if (alIsAuxiliaryEffectSlot(effectslot))
 347     {
 348         ALeffectslot *ALEffectSlot = (ALeffectslot*)ALTHUNK_LOOKUPENTRY(effectslot);
 349
 350         switch(param)
 351         {
 352         case AL_EFFECTSLOT_EFFECT:
 353             *piValue = ALEffectSlot->effect.effect;
 354             break;
 355
 356         case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 357             *piValue = ALEffectSlot->AuxSendAuto;
 358             break;
 359
 360         default:
 361             alSetError(AL_INVALID_ENUM);
 362             break;
 363         }
 364     }
 365     else
 366         alSetError(AL_INVALID_NAME);
 367
 368     ProcessContext(Context);
 369 }
 370
 371 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues)
 372 {
 373     ALCcontext *Context;
 374
 375     Context = alcGetCurrentContext();
 376     if(!Context)
 377     {
 378         alSetError(AL_INVALID_OPERATION);
 379         return;
 380     }
 381     SuspendContext(Context);
 382
 383     if (alIsAuxiliaryEffectSlot(effectslot))
 384     {
 385         switch(param)
 386         {
 387         case AL_EFFECTSLOT_EFFECT:
 388         case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 389             alGetAuxiliaryEffectSloti(effectslot, param, piValues);
 390             break;
 391
 392         default:
 393             alSetError(AL_INVALID_ENUM);
 394             break;
 395         }
 396     }
 397     else
 398         alSetError(AL_INVALID_NAME);
 399
 400     ProcessContext(Context);
 401 }
 402
 403 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *pflValue)
 404 {
 405     ALCcontext *Context;
 406
 407     Context = alcGetCurrentContext();
 408     if(!Context)
 409     {
 410         alSetError(AL_INVALID_OPERATION);
 411         return;
 412     }
 413     SuspendContext(Context);
 414
 415     if (alIsAuxiliaryEffectSlot(effectslot))
 416     {
 417         ALeffectslot *ALEffectSlot = (ALeffectslot*)ALTHUNK_LOOKUPENTRY(effectslot);
 418
 419         switch(param)
 420         {
 421         case AL_EFFECTSLOT_GAIN:
 422             *pflValue = ALEffectSlot->Gain;
 423             break;
 424
 425         default:
 426             alSetError(AL_INVALID_ENUM);
 427             break;
 428         }
 429     }
 430     else
 431         alSetError(AL_INVALID_NAME);
 432
 433     ProcessContext(Context);
 434 }
 435
 436 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues)
 437 {
 438     ALCcontext *Context;
 439
 440     Context = alcGetCurrentContext();
 441     if(!Context)
 442     {
 443         alSetError(AL_INVALID_OPERATION);
 444         return;
 445     }
 446     SuspendContext(Context);
 447
 448     if (alIsAuxiliaryEffectSlot(effectslot))
 449     {
 450         switch(param)
 451         {
 452         case AL_EFFECTSLOT_GAIN:
 453             alGetAuxiliaryEffectSlotf(effectslot, param, pflValues);
 454             break;
 455
 456         default:
 457             alSetError(AL_INVALID_ENUM);
 458             break;
 459         }
 460     }
 461     else
 462         alSetError(AL_INVALID_NAME);
 463
 464     ProcessContext(Context);
 465 }
 466
 467
 468 ALvoid ReleaseALAuxiliaryEffectSlots(ALCcontext *Context)
 469 {
 470 #ifdef _DEBUG
 471     if(Context->AuxiliaryEffectSlotCount > 0)
 472         AL_PRINT("destroycontext: %d AuxiliaryEffectSlot(s) NOT deleted\n", Context->AuxiliaryEffectSlotCount);
 473 #endif
 474
 475     while(Context->AuxiliaryEffectSlot)
 476     {
 477         ALeffectslot *temp = Context->AuxiliaryEffectSlot;
 478         Context->AuxiliaryEffectSlot = Context->AuxiliaryEffectSlot->next;
 479
 480         // Release effectslot structure
 481         memset(temp, 0, sizeof(ALeffectslot));
 482         free(temp);
 483     }
 484     Context->AuxiliaryEffectSlotCount = 0;
 485 }