ef0d4f8210
Similar to the listener, separate containers are provided atomically for the mixer thread to apply updates without needing to block, and a free-list is used to reuse container objects. A couple things to note. First, the lock is still used when the effect state's deviceUpdate method is called to prevent asynchronous calls to reset the device from interfering. This can be fixed by using the list lock in ALc.c instead. Secondly, old effect states aren't immediately deleted when the effect type changes (the actual type, not just its properties). This is because the mixer thread is intended to be real-time safe, and so can't be freeing anything. They are cleared away when updates reuse the container they were kept in, and they don't incur any extra processing cost, but there may be cases where the memory is kept around until the effect slot is deleted.
253 lines
8.1 KiB
C
253 lines
8.1 KiB
C
/**
|
|
* OpenAL cross platform audio library
|
|
* Copyright (C) 2013 by Anis A. Hireche
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
* Or go to http://www.gnu.org/copyleft/lgpl.html
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include "config.h"
|
|
#include "alError.h"
|
|
#include "alMain.h"
|
|
#include "alAuxEffectSlot.h"
|
|
#include "alu.h"
|
|
|
|
|
|
typedef struct ALcompressorState {
|
|
DERIVE_FROM_TYPE(ALeffectState);
|
|
|
|
/* Effect gains for each channel */
|
|
ALfloat Gain[MAX_EFFECT_CHANNELS][MAX_OUTPUT_CHANNELS];
|
|
|
|
/* Effect parameters */
|
|
ALboolean Enabled;
|
|
ALfloat AttackRate;
|
|
ALfloat ReleaseRate;
|
|
ALfloat GainCtrl;
|
|
} ALcompressorState;
|
|
|
|
static ALvoid ALcompressorState_Destruct(ALcompressorState *state)
|
|
{
|
|
ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
|
|
}
|
|
|
|
static ALboolean ALcompressorState_deviceUpdate(ALcompressorState *state, ALCdevice *device)
|
|
{
|
|
const ALfloat attackTime = device->Frequency * 0.2f; /* 200ms Attack */
|
|
const ALfloat releaseTime = device->Frequency * 0.4f; /* 400ms Release */
|
|
|
|
state->AttackRate = 1.0f / attackTime;
|
|
state->ReleaseRate = 1.0f / releaseTime;
|
|
|
|
return AL_TRUE;
|
|
}
|
|
|
|
static ALvoid ALcompressorState_update(ALcompressorState *state, const ALCdevice *device, const ALeffectslot *slot)
|
|
{
|
|
aluMatrixf matrix;
|
|
ALuint i;
|
|
|
|
state->Enabled = slot->Params.EffectProps.Compressor.OnOff;
|
|
|
|
aluMatrixfSet(&matrix,
|
|
1.0f, 0.0f, 0.0f, 0.0f,
|
|
0.0f, 1.0f, 0.0f, 0.0f,
|
|
0.0f, 0.0f, 1.0f, 0.0f,
|
|
0.0f, 0.0f, 0.0f, 1.0f
|
|
);
|
|
|
|
STATIC_CAST(ALeffectState,state)->OutBuffer = device->FOAOut.Buffer;
|
|
STATIC_CAST(ALeffectState,state)->OutChannels = device->FOAOut.NumChannels;
|
|
for(i = 0;i < 4;i++)
|
|
ComputeFirstOrderGains(device->FOAOut, matrix.m[i], slot->Params.Gain,
|
|
state->Gain[i]);
|
|
}
|
|
|
|
static ALvoid ALcompressorState_process(ALcompressorState *state, ALuint SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALuint NumChannels)
|
|
{
|
|
ALuint i, j, k;
|
|
ALuint base;
|
|
|
|
for(base = 0;base < SamplesToDo;)
|
|
{
|
|
ALfloat temps[64][4];
|
|
ALuint td = minu(64, SamplesToDo-base);
|
|
|
|
/* Load samples into the temp buffer first. */
|
|
for(j = 0;j < 4;j++)
|
|
{
|
|
for(i = 0;i < td;i++)
|
|
temps[i][j] = SamplesIn[j][i+base];
|
|
}
|
|
|
|
if(state->Enabled)
|
|
{
|
|
ALfloat gain = state->GainCtrl;
|
|
ALfloat output, amplitude;
|
|
|
|
for(i = 0;i < td;i++)
|
|
{
|
|
/* Roughly calculate the maximum amplitude from the 4-channel
|
|
* signal, and attack or release the gain control to reach it.
|
|
*/
|
|
amplitude = fabsf(temps[i][0]);
|
|
amplitude = maxf(amplitude + fabsf(temps[i][1]),
|
|
maxf(amplitude + fabsf(temps[i][2]),
|
|
amplitude + fabsf(temps[i][3])));
|
|
if(amplitude > gain)
|
|
gain = minf(gain+state->AttackRate, amplitude);
|
|
else if(amplitude < gain)
|
|
gain = maxf(gain-state->ReleaseRate, amplitude);
|
|
|
|
/* Apply the inverse of the gain control to normalize/compress
|
|
* the volume. */
|
|
output = 1.0f / clampf(gain, 0.5f, 2.0f);
|
|
for(j = 0;j < 4;j++)
|
|
temps[i][j] *= output;
|
|
}
|
|
|
|
state->GainCtrl = gain;
|
|
}
|
|
else
|
|
{
|
|
ALfloat gain = state->GainCtrl;
|
|
ALfloat output, amplitude;
|
|
|
|
for(i = 0;i < td;i++)
|
|
{
|
|
/* Same as above, except the amplitude is forced to 1. This
|
|
* helps ensure smooth gain changes when the compressor is
|
|
* turned on and off.
|
|
*/
|
|
amplitude = 1.0f;
|
|
if(amplitude > gain)
|
|
gain = minf(gain+state->AttackRate, amplitude);
|
|
else if(amplitude < gain)
|
|
gain = maxf(gain-state->ReleaseRate, amplitude);
|
|
|
|
output = 1.0f / clampf(gain, 0.5f, 2.0f);
|
|
for(j = 0;j < 4;j++)
|
|
temps[i][j] *= output;
|
|
}
|
|
|
|
state->GainCtrl = gain;
|
|
}
|
|
|
|
/* Now mix to the output. */
|
|
for(j = 0;j < 4;j++)
|
|
{
|
|
for(k = 0;k < NumChannels;k++)
|
|
{
|
|
ALfloat gain = state->Gain[j][k];
|
|
if(!(fabsf(gain) > GAIN_SILENCE_THRESHOLD))
|
|
continue;
|
|
|
|
for(i = 0;i < td;i++)
|
|
SamplesOut[k][base+i] += gain * temps[i][j];
|
|
}
|
|
}
|
|
|
|
base += td;
|
|
}
|
|
}
|
|
|
|
DECLARE_DEFAULT_ALLOCATORS(ALcompressorState)
|
|
|
|
DEFINE_ALEFFECTSTATE_VTABLE(ALcompressorState);
|
|
|
|
|
|
typedef struct ALcompressorStateFactory {
|
|
DERIVE_FROM_TYPE(ALeffectStateFactory);
|
|
} ALcompressorStateFactory;
|
|
|
|
static ALeffectState *ALcompressorStateFactory_create(ALcompressorStateFactory *UNUSED(factory))
|
|
{
|
|
ALcompressorState *state;
|
|
|
|
state = ALcompressorState_New(sizeof(*state));
|
|
if(!state) return NULL;
|
|
SET_VTABLE2(ALcompressorState, ALeffectState, state);
|
|
|
|
state->Enabled = AL_TRUE;
|
|
state->AttackRate = 0.0f;
|
|
state->ReleaseRate = 0.0f;
|
|
state->GainCtrl = 1.0f;
|
|
|
|
return STATIC_CAST(ALeffectState, state);
|
|
}
|
|
|
|
DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALcompressorStateFactory);
|
|
|
|
ALeffectStateFactory *ALcompressorStateFactory_getFactory(void)
|
|
{
|
|
static ALcompressorStateFactory CompressorFactory = { { GET_VTABLE2(ALcompressorStateFactory, ALeffectStateFactory) } };
|
|
|
|
return STATIC_CAST(ALeffectStateFactory, &CompressorFactory);
|
|
}
|
|
|
|
|
|
void ALcompressor_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
|
|
{
|
|
ALeffectProps *props = &effect->Props;
|
|
switch(param)
|
|
{
|
|
case AL_COMPRESSOR_ONOFF:
|
|
if(!(val >= AL_COMPRESSOR_MIN_ONOFF && val <= AL_COMPRESSOR_MAX_ONOFF))
|
|
SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
|
|
props->Compressor.OnOff = val;
|
|
break;
|
|
|
|
default:
|
|
SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
|
|
}
|
|
}
|
|
void ALcompressor_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
|
|
{
|
|
ALcompressor_setParami(effect, context, param, vals[0]);
|
|
}
|
|
void ALcompressor_setParamf(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALfloat UNUSED(val))
|
|
{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
|
|
void ALcompressor_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
|
|
{
|
|
ALcompressor_setParamf(effect, context, param, vals[0]);
|
|
}
|
|
|
|
void ALcompressor_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
|
|
{
|
|
const ALeffectProps *props = &effect->Props;
|
|
switch(param)
|
|
{
|
|
case AL_COMPRESSOR_ONOFF:
|
|
*val = props->Compressor.OnOff;
|
|
break;
|
|
default:
|
|
SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
|
|
}
|
|
}
|
|
void ALcompressor_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
|
|
{
|
|
ALcompressor_getParami(effect, context, param, vals);
|
|
}
|
|
void ALcompressor_getParamf(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALfloat *UNUSED(val))
|
|
{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
|
|
void ALcompressor_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
|
|
{
|
|
ALcompressor_getParamf(effect, context, param, vals);
|
|
}
|
|
|
|
DEFINE_ALEFFECT_VTABLE(ALcompressor);
|