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 ALenum ResizeEffectSlotArray(ALCcontext *Context, ALsizei count);
  36 static ALvoid RemoveEffectSlotArray(ALCcontext *Context, ALeffectslot *val);
  37
  38
  39 AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
  40 {
  41     ALCcontext *Context;
  42
  43     Context = GetContextRef();
  44     if(!Context) return;
  45
  46     if(n < 0 || IsBadWritePtr((void*)effectslots, n * sizeof(ALuint)))
  47         alSetError(Context, AL_INVALID_VALUE);
  48     else
  49     {
  50         ALenum err;
  51         ALsizei i;
  52
  53         err = ResizeEffectSlotArray(Context, n);
  54         if(err != AL_NO_ERROR)
  55         {
  56             alSetError(Context, err);
  57             n = 0;
  58         }
  59
  60         for(i = 0;i < n;i++)
  61         {
  62             ALeffectslot *slot = calloc(1, sizeof(ALeffectslot));
  63             if(!slot || InitEffectSlot(slot) != AL_NO_ERROR)
  64             {
  65                 free(slot);
  66                 // We must have run out or memory
  67                 alSetError(Context, AL_OUT_OF_MEMORY);
  68                 alDeleteAuxiliaryEffectSlots(i, effectslots);
  69                 break;
  70             }
  71
  72             LockContext(Context);
  73             err = ResizeEffectSlotArray(Context, 1);
  74             if(err == AL_NO_ERROR)
  75                 Context->ActiveEffectSlots[Context->ActiveEffectSlotCount++] = slot;
  76             UnlockContext(Context);
  77             if(err == AL_NO_ERROR)
  78                 err = NewThunkEntry(&slot->effectslot);
  79             if(err == AL_NO_ERROR)
  80                 err = InsertUIntMapEntry(&Context->EffectSlotMap, slot->effectslot, slot);
  81             if(err != AL_NO_ERROR)
  82             {
  83                 RemoveEffectSlotArray(Context, slot);
  84                 FreeThunkEntry(slot->effectslot);
  85                 ALeffectState_Destroy(slot->EffectState);
  86                 free(slot);
  87
  88                 alSetError(Context, err);
  89                 alDeleteAuxiliaryEffectSlots(i, effectslots);
  90                 break;
  91             }
  92
  93             effectslots[i] = slot->effectslot;
  94         }
  95     }
  96
  97     ALCcontext_DecRef(Context);
  98 }
  99
 100 AL_API ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, const ALuint *effectslots)
 101 {
 102     ALCcontext *Context;
 103     ALeffectslot *EffectSlot;
 104     ALsizei i;
 105
 106     Context = GetContextRef();
 107     if(!Context) return;
 108
 109     if(n < 0)
 110         alSetError(Context, AL_INVALID_VALUE);
 111     else
 112     {
 113         // Check that all effectslots are valid
 114         for(i = 0;i < n;i++)
 115         {
 116             if((EffectSlot=LookupEffectSlot(Context, effectslots[i])) == NULL)
 117             {
 118                 alSetError(Context, AL_INVALID_NAME);
 119                 n = 0;
 120                 break;
 121             }
 122             else if(EffectSlot->ref != 0)
 123             {
 124                 alSetError(Context, AL_INVALID_OPERATION);
 125                 n = 0;
 126                 break;
 127             }
 128         }
 129
 130         // All effectslots are valid
 131         for(i = 0;i < n;i++)
 132         {
 133             // Recheck that the effectslot is valid, because there could be duplicated names
 134             if((EffectSlot=RemoveEffectSlot(Context, effectslots[i])) == NULL)
 135                 continue;
 136             FreeThunkEntry(EffectSlot->effectslot);
 137
 138             RemoveEffectSlotArray(Context, EffectSlot);
 139             ALeffectState_Destroy(EffectSlot->EffectState);
 140
 141             memset(EffectSlot, 0, sizeof(ALeffectslot));
 142             free(EffectSlot);
 143         }
 144     }
 145
 146     ALCcontext_DecRef(Context);
 147 }
 148
 149 AL_API ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot)
 150 {
 151     ALCcontext *Context;
 152     ALboolean  result;
 153
 154     Context = GetContextRef();
 155     if(!Context) return AL_FALSE;
 156
 157     result = (LookupEffectSlot(Context, effectslot) ? AL_TRUE : AL_FALSE);
 158
 159     ALCcontext_DecRef(Context);
 160
 161     return result;
 162 }
 163
 164 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue)
 165 {
 166     ALCdevice *Device;
 167     ALCcontext *Context;
 168     ALeffectslot *EffectSlot;
 169
 170     Context = GetContextRef();
 171     if(!Context) return;
 172
 173     Device = Context->Device;
 174     if((EffectSlot=LookupEffectSlot(Context, effectslot)) != NULL)
 175     {
 176         switch(param)
 177         {
 178         case AL_EFFECTSLOT_EFFECT: {
 179             ALeffect *effect = NULL;
 180
 181             if(iValue == 0 ||
 182                (effect=LookupEffect(Device, iValue)) != NULL)
 183             {
 184                 ALenum err;
 185                 err = InitializeEffect(Device, EffectSlot, effect);
 186                 if(err != AL_NO_ERROR)
 187                     alSetError(Context, err);
 188                 else
 189                     Context->UpdateSources = AL_TRUE;
 190             }
 191             else
 192                 alSetError(Context, AL_INVALID_VALUE);
 193         }   break;
 194
 195         case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 196             if(iValue == AL_TRUE || iValue == AL_FALSE)
 197             {
 198                 EffectSlot->AuxSendAuto = iValue;
 199                 Context->UpdateSources = AL_TRUE;
 200             }
 201             else
 202                 alSetError(Context, AL_INVALID_VALUE);
 203             break;
 204
 205         default:
 206             alSetError(Context, AL_INVALID_ENUM);
 207             break;
 208         }
 209     }
 210     else
 211         alSetError(Context, AL_INVALID_NAME);
 212
 213     ALCcontext_DecRef(Context);
 214 }
 215
 216 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, const ALint *piValues)
 217 {
 218     ALCcontext *Context;
 219
 220     switch(param)
 221     {
 222         case AL_EFFECTSLOT_EFFECT:
 223         case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 224             alAuxiliaryEffectSloti(effectslot, param, piValues[0]);
 225             return;
 226     }
 227
 228     Context = GetContextRef();
 229     if(!Context) return;
 230
 231     if(LookupEffectSlot(Context, effectslot) != NULL)
 232     {
 233         switch(param)
 234         {
 235         default:
 236             alSetError(Context, AL_INVALID_ENUM);
 237             break;
 238         }
 239     }
 240     else
 241         alSetError(Context, AL_INVALID_NAME);
 242
 243     ALCcontext_DecRef(Context);
 244 }
 245
 246 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat flValue)
 247 {
 248     ALCcontext *Context;
 249     ALeffectslot *EffectSlot;
 250
 251     Context = GetContextRef();
 252     if(!Context) return;
 253
 254     if((EffectSlot=LookupEffectSlot(Context, effectslot)) != NULL)
 255     {
 256         switch(param)
 257         {
 258         case AL_EFFECTSLOT_GAIN:
 259             if(flValue >= 0.0f && flValue <= 1.0f)
 260             {
 261                 EffectSlot->Gain = flValue;
 262                 EffectSlot->NeedsUpdate = AL_TRUE;
 263             }
 264             else
 265                 alSetError(Context, AL_INVALID_VALUE);
 266             break;
 267
 268         default:
 269             alSetError(Context, AL_INVALID_ENUM);
 270             break;
 271         }
 272     }
 273     else
 274         alSetError(Context, AL_INVALID_NAME);
 275
 276     ALCcontext_DecRef(Context);
 277 }
 278
 279 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, const ALfloat *pflValues)
 280 {
 281     ALCcontext *Context;
 282
 283     switch(param)
 284     {
 285         case AL_EFFECTSLOT_GAIN:
 286             alAuxiliaryEffectSlotf(effectslot, param, pflValues[0]);
 287             return;
 288     }
 289
 290     Context = GetContextRef();
 291     if(!Context) return;
 292
 293     if(LookupEffectSlot(Context, effectslot) != NULL)
 294     {
 295         switch(param)
 296         {
 297         default:
 298             alSetError(Context, AL_INVALID_ENUM);
 299             break;
 300         }
 301     }
 302     else
 303         alSetError(Context, AL_INVALID_NAME);
 304
 305     ALCcontext_DecRef(Context);
 306 }
 307
 308 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *piValue)
 309 {
 310     ALCcontext *Context;
 311     ALeffectslot *EffectSlot;
 312
 313     Context = GetContextRef();
 314     if(!Context) return;
 315
 316     if((EffectSlot=LookupEffectSlot(Context, effectslot)) != NULL)
 317     {
 318         switch(param)
 319         {
 320         case AL_EFFECTSLOT_EFFECT:
 321             *piValue = EffectSlot->effect.effect;
 322             break;
 323
 324         case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 325             *piValue = EffectSlot->AuxSendAuto;
 326             break;
 327
 328         default:
 329             alSetError(Context, AL_INVALID_ENUM);
 330             break;
 331         }
 332     }
 333     else
 334         alSetError(Context, AL_INVALID_NAME);
 335
 336     ALCcontext_DecRef(Context);
 337 }
 338
 339 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues)
 340 {
 341     ALCcontext *Context;
 342
 343     switch(param)
 344     {
 345         case AL_EFFECTSLOT_EFFECT:
 346         case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 347             alGetAuxiliaryEffectSloti(effectslot, param, piValues);
 348             return;
 349     }
 350
 351     Context = GetContextRef();
 352     if(!Context) return;
 353
 354     if(LookupEffectSlot(Context, effectslot) != NULL)
 355     {
 356         switch(param)
 357         {
 358         default:
 359             alSetError(Context, AL_INVALID_ENUM);
 360             break;
 361         }
 362     }
 363     else
 364         alSetError(Context, AL_INVALID_NAME);
 365
 366     ALCcontext_DecRef(Context);
 367 }
 368
 369 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *pflValue)
 370 {
 371     ALCcontext *Context;
 372     ALeffectslot *EffectSlot;
 373
 374     Context = GetContextRef();
 375     if(!Context) return;
 376
 377     if((EffectSlot=LookupEffectSlot(Context, effectslot)) != NULL)
 378     {
 379         switch(param)
 380         {
 381         case AL_EFFECTSLOT_GAIN:
 382             *pflValue = EffectSlot->Gain;
 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     ALCcontext_DecRef(Context);
 394 }
 395
 396 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues)
 397 {
 398     ALCcontext *Context;
 399
 400     switch(param)
 401     {
 402         case AL_EFFECTSLOT_GAIN:
 403             alGetAuxiliaryEffectSlotf(effectslot, param, pflValues);
 404             return;
 405     }
 406
 407     Context = GetContextRef();
 408     if(!Context) return;
 409
 410     if(LookupEffectSlot(Context, effectslot) != NULL)
 411     {
 412         switch(param)
 413         {
 414         default:
 415             alSetError(Context, AL_INVALID_ENUM);
 416             break;
 417         }
 418     }
 419     else
 420         alSetError(Context, AL_INVALID_NAME);
 421
 422     ALCcontext_DecRef(Context);
 423 }
 424
 425
 426 static ALvoid NoneDestroy(ALeffectState *State)
 427 { free(State); }
 428 static ALboolean NoneDeviceUpdate(ALeffectState *State, ALCdevice *Device)
 429 {
 430     return AL_TRUE;
 431     (void)State;
 432     (void)Device;
 433 }
 434 static ALvoid NoneUpdate(ALeffectState *State, ALCdevice *Device, const ALeffectslot *Slot)
 435 {
 436     (void)State;
 437     (void)Device;
 438     (void)Slot;
 439 }
 440 static ALvoid NoneProcess(ALeffectState *State, ALuint SamplesToDo, const ALfloat *SamplesIn, ALfloat (*SamplesOut)[MAXCHANNELS])
 441 {
 442     (void)State;
 443     (void)SamplesToDo;
 444     (void)SamplesIn;
 445     (void)SamplesOut;
 446 }
 447 ALeffectState *NoneCreate(void)
 448 {
 449     ALeffectState *state;
 450
 451     state = calloc(1, sizeof(*state));
 452     if(!state)
 453         return NULL;
 454
 455     state->Destroy = NoneDestroy;
 456     state->DeviceUpdate = NoneDeviceUpdate;
 457     state->Update = NoneUpdate;
 458     state->Process = NoneProcess;
 459
 460     return state;
 461 }
 462
 463
 464 static ALvoid RemoveEffectSlotArray(ALCcontext *Context, ALeffectslot *slot)
 465 {
 466     ALeffectslot **slotlist, **slotlistend;
 467
 468     LockContext(Context);
 469     slotlist = Context->ActiveEffectSlots;
 470     slotlistend = slotlist + Context->ActiveEffectSlotCount;
 471     while(slotlist != slotlistend)
 472     {
 473         if(*slotlist == slot)
 474         {
 475             *slotlist = *(--slotlistend);
 476             Context->ActiveEffectSlotCount--;
 477             break;
 478         }
 479         slotlist++;
 480     }
 481     UnlockContext(Context);
 482 }
 483
 484 static ALenum ResizeEffectSlotArray(ALCcontext *Context, ALsizei count)
 485 {
 486     ALsizei newcount;
 487     void *temp;
 488
 489     if(count <= Context->MaxActiveEffectSlots-Context->ActiveEffectSlotCount)
 490         return AL_NO_ERROR;
 491
 492     newcount = Context->MaxActiveEffectSlots ?
 493                (Context->MaxActiveEffectSlots<<1) : 1;
 494     if(newcount <= Context->MaxActiveEffectSlots ||
 495        !(temp=realloc(Context->ActiveEffectSlots, newcount *
 496                                                   sizeof(*Context->ActiveEffectSlots))))
 497         return AL_OUT_OF_MEMORY;
 498
 499     Context->ActiveEffectSlots = temp;
 500     Context->MaxActiveEffectSlots = newcount;
 501     return AL_NO_ERROR;
 502 }
 503
 504 ALenum InitializeEffect(ALCdevice *Device, ALeffectslot *EffectSlot, ALeffect *effect)
 505 {
 506     ALenum newtype = (effect ? effect->type : AL_EFFECT_NULL);
 507     ALeffectState *State = NULL;
 508     ALenum err = AL_NO_ERROR;
 509
 510     LockDevice(Device);
 511     if(newtype == AL_EFFECT_NULL && EffectSlot->effect.type != AL_EFFECT_NULL)
 512     {
 513         State = NoneCreate();
 514         if(!State) err = AL_OUT_OF_MEMORY;
 515     }
 516     else if(newtype == AL_EFFECT_EAXREVERB || newtype == AL_EFFECT_REVERB)
 517     {
 518         if(EffectSlot->effect.type != AL_EFFECT_EAXREVERB && EffectSlot->effect.type != AL_EFFECT_REVERB)
 519         {
 520             State = ReverbCreate();
 521             if(!State) err = AL_OUT_OF_MEMORY;
 522         }
 523     }
 524     else if(newtype == AL_EFFECT_ECHO && EffectSlot->effect.type != AL_EFFECT_ECHO)
 525     {
 526         State = EchoCreate();
 527         if(!State) err = AL_OUT_OF_MEMORY;
 528     }
 529     else if(newtype == AL_EFFECT_RING_MODULATOR && EffectSlot->effect.type != AL_EFFECT_RING_MODULATOR)
 530     {
 531         State = ModulatorCreate();
 532         if(!State) err = AL_OUT_OF_MEMORY;
 533     }
 534     else if(newtype == AL_EFFECT_DEDICATED_DIALOGUE || newtype == AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT)
 535     {
 536         if(EffectSlot->effect.type != AL_EFFECT_DEDICATED_DIALOGUE && EffectSlot->effect.type != AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT)
 537         {
 538             State = DedicatedCreate();
 539             if(!State) err = AL_OUT_OF_MEMORY;
 540         }
 541     }
 542
 543     if(err != AL_NO_ERROR)
 544     {
 545         UnlockDevice(Device);
 546         return err;
 547     }
 548
 549     if(State)
 550     {
 551         int oldMode;
 552         oldMode = SetMixerFPUMode();
 553
 554         if(ALeffectState_DeviceUpdate(State, Device) == AL_FALSE)
 555         {
 556             RestoreFPUMode(oldMode);
 557             UnlockDevice(Device);
 558             ALeffectState_Destroy(State);
 559             return AL_OUT_OF_MEMORY;
 560         }
 561         State = ExchangePtr((XchgPtr*)&EffectSlot->EffectState, State);
 562
 563         if(!effect)
 564             memset(&EffectSlot->effect, 0, sizeof(EffectSlot->effect));
 565         else
 566             memcpy(&EffectSlot->effect, effect, sizeof(*effect));
 567         /* FIXME: This should be done asynchronously, but since the EffectState
 568          * object was changed, it needs an update before its Process method can
 569          * be called. */
 570         EffectSlot->NeedsUpdate = AL_FALSE;
 571         ALeffectState_Update(EffectSlot->EffectState, Device, EffectSlot);
 572         UnlockDevice(Device);
 573
 574         RestoreFPUMode(oldMode);
 575
 576         ALeffectState_Destroy(State);
 577         State = NULL;
 578     }
 579     else
 580     {
 581         if(!effect)
 582             memset(&EffectSlot->effect, 0, sizeof(EffectSlot->effect));
 583         else
 584             memcpy(&EffectSlot->effect, effect, sizeof(*effect));
 585         UnlockDevice(Device);
 586         EffectSlot->NeedsUpdate = AL_TRUE;
 587     }
 588
 589     return AL_NO_ERROR;
 590 }
 591
 592
 593 ALenum InitEffectSlot(ALeffectslot *slot)
 594 {
 595     ALint i;
 596
 597     if(!(slot->EffectState=NoneCreate()))
 598         return AL_OUT_OF_MEMORY;
 599
 600     slot->Gain = 1.0;
 601     slot->AuxSendAuto = AL_TRUE;
 602     slot->NeedsUpdate = AL_FALSE;
 603     for(i = 0;i < BUFFERSIZE;i++)
 604         slot->WetBuffer[i] = 0.0f;
 605     for(i = 0;i < 1;i++)
 606     {
 607         slot->ClickRemoval[i] = 0.0f;
 608         slot->PendingClicks[i] = 0.0f;
 609     }
 610     slot->ref = 0;
 611
 612     return AL_NO_ERROR;
 613 }
 614
 615 ALvoid ReleaseALAuxiliaryEffectSlots(ALCcontext *Context)
 616 {
 617     ALsizei pos;
 618     for(pos = 0;pos < Context->EffectSlotMap.size;pos++)
 619     {
 620         ALeffectslot *temp = Context->EffectSlotMap.array[pos].value;
 621         Context->EffectSlotMap.array[pos].value = NULL;
 622
 623         // Release effectslot structure
 624         ALeffectState_Destroy(temp->EffectState);
 625
 626         FreeThunkEntry(temp->effectslot);
 627         memset(temp, 0, sizeof(ALeffectslot));
 628         free(temp);
 629     }
 630 }