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