Alc/effects/dedicated.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 2011 by Chris Robinson.
   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.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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 "alMain.h"
  26 #include "alFilter.h"
  27 #include "alAuxEffectSlot.h"
  28 #include "alError.h"
  29 #include "alu.h"
  30
  31
  32 typedef struct ALdedicatedState {
  33     DERIVE_FROM_TYPE(ALeffectState);
  34
  35     ALfloat gains[MAX_OUTPUT_CHANNELS];
  36 } ALdedicatedState;
  37
  38
  39 static ALvoid ALdedicatedState_Destruct(ALdedicatedState *UNUSED(state))
  40 {
  41 }
  42
  43 static ALboolean ALdedicatedState_deviceUpdate(ALdedicatedState *UNUSED(state), ALCdevice *UNUSED(device))
  44 {
  45     return AL_TRUE;
  46 }
  47
  48 static ALvoid ALdedicatedState_update(ALdedicatedState *state, ALCdevice *device, const ALeffectslot *Slot)
  49 {
  50     ALfloat Gain;
  51     ALuint i;
  52
  53     for(i = 0;i < MAX_OUTPUT_CHANNELS;i++)
  54         state->gains[i] = 0.0f;
  55
  56     Gain = Slot->Gain * Slot->EffectProps.Dedicated.Gain;
  57     if(Slot->EffectType == AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT)
  58     {
  59         int idx;
  60         if((idx=GetChannelIdxByName(device, LFE)) != -1)
  61             state->gains[idx] = Gain;
  62     }
  63     else if(Slot->EffectType == AL_EFFECT_DEDICATED_DIALOGUE)
  64     {
  65         int idx;
  66         /* Dialog goes to the front-center speaker if it exists, otherwise it
  67          * plays from the front-center location. */
  68         if((idx=GetChannelIdxByName(device, FrontCenter)) != -1)
  69             state->gains[idx] = Gain;
  70         else
  71         {
  72             static const ALfloat front_dir[3] = { 0.0f, 0.0f, -1.0f };
  73             ComputeDirectionalGains(device, front_dir, Gain, state->gains);
  74         }
  75     }
  76 }
  77
  78 static ALvoid ALdedicatedState_process(ALdedicatedState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALuint NumChannels)
  79 {
  80     const ALfloat *gains = state->gains;
  81     ALuint i, c;
  82
  83     for(c = 0;c < NumChannels;c++)
  84     {
  85         if(!(fabsf(gains[c]) > GAIN_SILENCE_THRESHOLD))
  86             continue;
  87
  88         for(i = 0;i < SamplesToDo;i++)
  89             SamplesOut[c][i] = SamplesIn[i] * gains[c];
  90     }
  91 }
  92
  93 DECLARE_DEFAULT_ALLOCATORS(ALdedicatedState)
  94
  95 DEFINE_ALEFFECTSTATE_VTABLE(ALdedicatedState);
  96
  97
  98 typedef struct ALdedicatedStateFactory {
  99     DERIVE_FROM_TYPE(ALeffectStateFactory);
 100 } ALdedicatedStateFactory;
 101
 102 ALeffectState *ALdedicatedStateFactory_create(ALdedicatedStateFactory *UNUSED(factory))
 103 {
 104     ALdedicatedState *state;
 105     ALsizei s;
 106
 107     state = ALdedicatedState_New(sizeof(*state));
 108     if(!state) return NULL;
 109     SET_VTABLE2(ALdedicatedState, ALeffectState, state);
 110
 111     for(s = 0;s < MAX_OUTPUT_CHANNELS;s++)
 112         state->gains[s] = 0.0f;
 113
 114     return STATIC_CAST(ALeffectState, state);
 115 }
 116
 117 DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALdedicatedStateFactory);
 118
 119
 120 ALeffectStateFactory *ALdedicatedStateFactory_getFactory(void)
 121 {
 122     static ALdedicatedStateFactory DedicatedFactory = { { GET_VTABLE2(ALdedicatedStateFactory, ALeffectStateFactory) } };
 123
 124     return STATIC_CAST(ALeffectStateFactory, &DedicatedFactory);
 125 }
 126
 127
 128 void ALdedicated_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val))
 129 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
 130 void ALdedicated_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
 131 {
 132     ALdedicated_setParami(effect, context, param, vals[0]);
 133 }
 134 void ALdedicated_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
 135 {
 136     ALeffectProps *props = &effect->Props;
 137     switch(param)
 138     {
 139         case AL_DEDICATED_GAIN:
 140             if(!(val >= 0.0f && isfinite(val)))
 141                 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 142             props->Dedicated.Gain = val;
 143             break;
 144
 145         default:
 146             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 147     }
 148 }
 149 void ALdedicated_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
 150 {
 151     ALdedicated_setParamf(effect, context, param, vals[0]);
 152 }
 153
 154 void ALdedicated_getParami(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val))
 155 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
 156 void ALdedicated_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
 157 {
 158     ALdedicated_getParami(effect, context, param, vals);
 159 }
 160 void ALdedicated_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
 161 {
 162     const ALeffectProps *props = &effect->Props;
 163     switch(param)
 164     {
 165         case AL_DEDICATED_GAIN:
 166             *val = props->Dedicated.Gain;
 167             break;
 168
 169         default:
 170             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 171     }
 172 }
 173 void ALdedicated_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
 174 {
 175     ALdedicated_getParamf(effect, context, param, vals);
 176 }
 177
 178 DEFINE_ALEFFECT_VTABLE(ALdedicated);