2 * OpenAL cross platform audio library
3 * Copyright (C) 2013 by Mike Gorchak
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.
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.
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
28 #include "alAuxEffectSlot.h"
34 CWF_Triangle
= AL_CHORUS_WAVEFORM_TRIANGLE
,
35 CWF_Sinusoid
= AL_CHORUS_WAVEFORM_SINUSOID
38 typedef struct ALchorusState
{
39 DERIVE_FROM_TYPE(ALeffectState
);
41 ALfloat
*SampleBuffer
[2];
48 /* Gains for left and right sides */
49 ALfloat Gain
[2][MAX_OUTPUT_CHANNELS
];
51 /* effect parameters */
52 enum ChorusWaveForm waveform
;
58 static ALvoid
ALchorusState_Destruct(ALchorusState
*state
)
60 free(state
->SampleBuffer
[0]);
61 state
->SampleBuffer
[0] = NULL
;
62 state
->SampleBuffer
[1] = NULL
;
65 static ALboolean
ALchorusState_deviceUpdate(ALchorusState
*state
, ALCdevice
*Device
)
70 maxlen
= fastf2u(AL_CHORUS_MAX_DELAY
* 3.0f
* Device
->Frequency
) + 1;
71 maxlen
= NextPowerOf2(maxlen
);
73 if(maxlen
!= state
->BufferLength
)
77 temp
= realloc(state
->SampleBuffer
[0], maxlen
* sizeof(ALfloat
) * 2);
78 if(!temp
) return AL_FALSE
;
79 state
->SampleBuffer
[0] = temp
;
80 state
->SampleBuffer
[1] = state
->SampleBuffer
[0] + maxlen
;
82 state
->BufferLength
= maxlen
;
85 for(it
= 0;it
< state
->BufferLength
;it
++)
87 state
->SampleBuffer
[0][it
] = 0.0f
;
88 state
->SampleBuffer
[1][it
] = 0.0f
;
94 static ALvoid
ALchorusState_update(ALchorusState
*state
, ALCdevice
*Device
, const ALeffectslot
*Slot
)
96 static const ALfloat left_dir
[3] = { -1.0f
, 0.0f
, 0.0f
};
97 static const ALfloat right_dir
[3] = { 1.0f
, 0.0f
, 0.0f
};
98 ALfloat frequency
= (ALfloat
)Device
->Frequency
;
102 switch(Slot
->EffectProps
.Chorus
.Waveform
)
104 case AL_CHORUS_WAVEFORM_TRIANGLE
:
105 state
->waveform
= CWF_Triangle
;
107 case AL_CHORUS_WAVEFORM_SINUSOID
:
108 state
->waveform
= CWF_Sinusoid
;
111 state
->depth
= Slot
->EffectProps
.Chorus
.Depth
;
112 state
->feedback
= Slot
->EffectProps
.Chorus
.Feedback
;
113 state
->delay
= fastf2i(Slot
->EffectProps
.Chorus
.Delay
* frequency
);
115 /* Gains for left and right sides */
116 ComputeDirectionalGains(Device
, left_dir
, Slot
->Gain
, state
->Gain
[0]);
117 ComputeDirectionalGains(Device
, right_dir
, Slot
->Gain
, state
->Gain
[1]);
119 phase
= Slot
->EffectProps
.Chorus
.Phase
;
120 rate
= Slot
->EffectProps
.Chorus
.Rate
;
123 state
->lfo_scale
= 0.0f
;
124 state
->lfo_range
= 1;
129 /* Calculate LFO coefficient */
130 state
->lfo_range
= fastf2u(frequency
/rate
+ 0.5f
);
131 switch(state
->waveform
)
134 state
->lfo_scale
= 4.0f
/ state
->lfo_range
;
137 state
->lfo_scale
= F_2PI
/ state
->lfo_range
;
141 /* Calculate lfo phase displacement */
142 state
->lfo_disp
= fastf2i(state
->lfo_range
* (phase
/360.0f
));
146 static inline void Triangle(ALint
*delay_left
, ALint
*delay_right
, ALuint offset
, const ALchorusState
*state
)
150 lfo_value
= 2.0f
- fabsf(2.0f
- state
->lfo_scale
*(offset
%state
->lfo_range
));
151 lfo_value
*= state
->depth
* state
->delay
;
152 *delay_left
= fastf2i(lfo_value
) + state
->delay
;
154 offset
+= state
->lfo_disp
;
155 lfo_value
= 2.0f
- fabsf(2.0f
- state
->lfo_scale
*(offset
%state
->lfo_range
));
156 lfo_value
*= state
->depth
* state
->delay
;
157 *delay_right
= fastf2i(lfo_value
) + state
->delay
;
160 static inline void Sinusoid(ALint
*delay_left
, ALint
*delay_right
, ALuint offset
, const ALchorusState
*state
)
164 lfo_value
= 1.0f
+ sinf(state
->lfo_scale
*(offset
%state
->lfo_range
));
165 lfo_value
*= state
->depth
* state
->delay
;
166 *delay_left
= fastf2i(lfo_value
) + state
->delay
;
168 offset
+= state
->lfo_disp
;
169 lfo_value
= 1.0f
+ sinf(state
->lfo_scale
*(offset
%state
->lfo_range
));
170 lfo_value
*= state
->depth
* state
->delay
;
171 *delay_right
= fastf2i(lfo_value
) + state
->delay
;
174 #define DECL_TEMPLATE(Func) \
175 static void Process##Func(ALchorusState *state, const ALuint SamplesToDo, \
176 const ALfloat *restrict SamplesIn, ALfloat (*restrict out)[2]) \
178 const ALuint bufmask = state->BufferLength-1; \
179 ALfloat *restrict leftbuf = state->SampleBuffer[0]; \
180 ALfloat *restrict rightbuf = state->SampleBuffer[1]; \
181 ALuint offset = state->offset; \
182 const ALfloat feedback = state->feedback; \
185 for(it = 0;it < SamplesToDo;it++) \
187 ALint delay_left, delay_right; \
188 Func(&delay_left, &delay_right, offset, state); \
190 out[it][0] = leftbuf[(offset-delay_left)&bufmask]; \
191 leftbuf[offset&bufmask] = (out[it][0]+SamplesIn[it]) * feedback; \
193 out[it][1] = rightbuf[(offset-delay_right)&bufmask]; \
194 rightbuf[offset&bufmask] = (out[it][1]+SamplesIn[it]) * feedback; \
198 state->offset = offset; \
201 DECL_TEMPLATE(Triangle
)
202 DECL_TEMPLATE(Sinusoid
)
206 static ALvoid
ALchorusState_process(ALchorusState
*state
, ALuint SamplesToDo
, const ALfloat
*restrict SamplesIn
, ALfloat (*restrict SamplesOut
)[BUFFERSIZE
], ALuint NumChannels
)
211 for(base
= 0;base
< SamplesToDo
;)
213 ALfloat temps
[64][2];
214 ALuint td
= minu(SamplesToDo
-base
, 64);
216 switch(state
->waveform
)
219 ProcessTriangle(state
, td
, SamplesIn
+base
, temps
);
222 ProcessSinusoid(state
, td
, SamplesIn
+base
, temps
);
226 for(kt
= 0;kt
< NumChannels
;kt
++)
228 ALfloat gain
= state
->Gain
[0][kt
];
229 if(fabsf(gain
) > GAIN_SILENCE_THRESHOLD
)
231 for(it
= 0;it
< td
;it
++)
232 SamplesOut
[kt
][it
+base
] += temps
[it
][0] * gain
;
235 gain
= state
->Gain
[1][kt
];
236 if(fabsf(gain
) > GAIN_SILENCE_THRESHOLD
)
238 for(it
= 0;it
< td
;it
++)
239 SamplesOut
[kt
][it
+base
] += temps
[it
][1] * gain
;
247 DECLARE_DEFAULT_ALLOCATORS(ALchorusState
)
249 DEFINE_ALEFFECTSTATE_VTABLE(ALchorusState
);
252 typedef struct ALchorusStateFactory
{
253 DERIVE_FROM_TYPE(ALeffectStateFactory
);
254 } ALchorusStateFactory
;
256 static ALeffectState
*ALchorusStateFactory_create(ALchorusStateFactory
*UNUSED(factory
))
258 ALchorusState
*state
;
260 state
= ALchorusState_New(sizeof(*state
));
261 if(!state
) return NULL
;
262 SET_VTABLE2(ALchorusState
, ALeffectState
, state
);
264 state
->BufferLength
= 0;
265 state
->SampleBuffer
[0] = NULL
;
266 state
->SampleBuffer
[1] = NULL
;
268 state
->lfo_range
= 1;
269 state
->waveform
= CWF_Triangle
;
271 return STATIC_CAST(ALeffectState
, state
);
274 DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALchorusStateFactory
);
277 ALeffectStateFactory
*ALchorusStateFactory_getFactory(void)
279 static ALchorusStateFactory ChorusFactory
= { { GET_VTABLE2(ALchorusStateFactory
, ALeffectStateFactory
) } };
281 return STATIC_CAST(ALeffectStateFactory
, &ChorusFactory
);
285 void ALchorus_setParami(ALeffect
*effect
, ALCcontext
*context
, ALenum param
, ALint val
)
287 ALeffectProps
*props
= &effect
->Props
;
290 case AL_CHORUS_WAVEFORM
:
291 if(!(val
>= AL_CHORUS_MIN_WAVEFORM
&& val
<= AL_CHORUS_MAX_WAVEFORM
))
292 SET_ERROR_AND_RETURN(context
, AL_INVALID_VALUE
);
293 props
->Chorus
.Waveform
= val
;
296 case AL_CHORUS_PHASE
:
297 if(!(val
>= AL_CHORUS_MIN_PHASE
&& val
<= AL_CHORUS_MAX_PHASE
))
298 SET_ERROR_AND_RETURN(context
, AL_INVALID_VALUE
);
299 props
->Chorus
.Phase
= val
;
303 SET_ERROR_AND_RETURN(context
, AL_INVALID_ENUM
);
306 void ALchorus_setParamiv(ALeffect
*effect
, ALCcontext
*context
, ALenum param
, const ALint
*vals
)
308 ALchorus_setParami(effect
, context
, param
, vals
[0]);
310 void ALchorus_setParamf(ALeffect
*effect
, ALCcontext
*context
, ALenum param
, ALfloat val
)
312 ALeffectProps
*props
= &effect
->Props
;
316 if(!(val
>= AL_CHORUS_MIN_RATE
&& val
<= AL_CHORUS_MAX_RATE
))
317 SET_ERROR_AND_RETURN(context
, AL_INVALID_VALUE
);
318 props
->Chorus
.Rate
= val
;
321 case AL_CHORUS_DEPTH
:
322 if(!(val
>= AL_CHORUS_MIN_DEPTH
&& val
<= AL_CHORUS_MAX_DEPTH
))
323 SET_ERROR_AND_RETURN(context
, AL_INVALID_VALUE
);
324 props
->Chorus
.Depth
= val
;
327 case AL_CHORUS_FEEDBACK
:
328 if(!(val
>= AL_CHORUS_MIN_FEEDBACK
&& val
<= AL_CHORUS_MAX_FEEDBACK
))
329 SET_ERROR_AND_RETURN(context
, AL_INVALID_VALUE
);
330 props
->Chorus
.Feedback
= val
;
333 case AL_CHORUS_DELAY
:
334 if(!(val
>= AL_CHORUS_MIN_DELAY
&& val
<= AL_CHORUS_MAX_DELAY
))
335 SET_ERROR_AND_RETURN(context
, AL_INVALID_VALUE
);
336 props
->Chorus
.Delay
= val
;
340 SET_ERROR_AND_RETURN(context
, AL_INVALID_ENUM
);
343 void ALchorus_setParamfv(ALeffect
*effect
, ALCcontext
*context
, ALenum param
, const ALfloat
*vals
)
345 ALchorus_setParamf(effect
, context
, param
, vals
[0]);
348 void ALchorus_getParami(const ALeffect
*effect
, ALCcontext
*context
, ALenum param
, ALint
*val
)
350 const ALeffectProps
*props
= &effect
->Props
;
353 case AL_CHORUS_WAVEFORM
:
354 *val
= props
->Chorus
.Waveform
;
357 case AL_CHORUS_PHASE
:
358 *val
= props
->Chorus
.Phase
;
362 SET_ERROR_AND_RETURN(context
, AL_INVALID_ENUM
);
365 void ALchorus_getParamiv(const ALeffect
*effect
, ALCcontext
*context
, ALenum param
, ALint
*vals
)
367 ALchorus_getParami(effect
, context
, param
, vals
);
369 void ALchorus_getParamf(const ALeffect
*effect
, ALCcontext
*context
, ALenum param
, ALfloat
*val
)
371 const ALeffectProps
*props
= &effect
->Props
;
375 *val
= props
->Chorus
.Rate
;
378 case AL_CHORUS_DEPTH
:
379 *val
= props
->Chorus
.Depth
;
382 case AL_CHORUS_FEEDBACK
:
383 *val
= props
->Chorus
.Feedback
;
386 case AL_CHORUS_DELAY
:
387 *val
= props
->Chorus
.Delay
;
391 SET_ERROR_AND_RETURN(context
, AL_INVALID_ENUM
);
394 void ALchorus_getParamfv(const ALeffect
*effect
, ALCcontext
*context
, ALenum param
, ALfloat
*vals
)
396 ALchorus_getParamf(effect
, context
, param
, vals
);
399 DEFINE_ALEFFECT_VTABLE(ALchorus
);