Alc/effects/modulator.cpp

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 2009 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 <cmath>
  24 #include <cstdlib>
  25
  26 #include <cmath>
  27 #include <algorithm>
  28
  29 #include "alMain.h"
  30 #include "alcontext.h"
  31 #include "alAuxEffectSlot.h"
  32 #include "alError.h"
  33 #include "alu.h"
  34 #include "filters/biquad.h"
  35 #include "vecmat.h"
  36
  37
  38 #define MAX_UPDATE_SAMPLES 128
  39
  40 #define WAVEFORM_FRACBITS  24
  41 #define WAVEFORM_FRACONE   (1<<WAVEFORM_FRACBITS)
  42 #define WAVEFORM_FRACMASK  (WAVEFORM_FRACONE-1)
  43
  44 static inline ALfloat Sin(ALsizei index)
  45 {
  46     return std::sin(static_cast<ALfloat>(index) * (al::MathDefs<float>::Tau() / static_cast<ALfloat>WAVEFORM_FRACONE));
  47 }
  48
  49 static inline ALfloat Saw(ALsizei index)
  50 {
  51     return static_cast<ALfloat>(index)*(2.0f/WAVEFORM_FRACONE) - 1.0f;
  52 }
  53
  54 static inline ALfloat Square(ALsizei index)
  55 {
  56     return static_cast<ALfloat>(((index>>(WAVEFORM_FRACBITS-2))&2) - 1);
  57 }
  58
  59 static inline ALfloat One(ALsizei UNUSED(index))
  60 {
  61     return 1.0f;
  62 }
  63
  64 template<ALfloat func(ALsizei)>
  65 static void Modulate(ALfloat *RESTRICT dst, ALsizei index, const ALsizei step, ALsizei todo)
  66 {
  67     ALsizei i;
  68     for(i = 0;i < todo;i++)
  69     {
  70         index += step;
  71         index &= WAVEFORM_FRACMASK;
  72         dst[i] = func(index);
  73     }
  74 }
  75
  76
  77 struct ALmodulatorState final : public EffectState {
  78     void (*mGetSamples)(ALfloat*RESTRICT, ALsizei, const ALsizei, ALsizei){};
  79
  80     ALsizei mIndex{0};
  81     ALsizei mStep{1};
  82
  83     struct {
  84         BiquadFilter Filter;
  85
  86         ALfloat CurrentGains[MAX_OUTPUT_CHANNELS]{};
  87         ALfloat TargetGains[MAX_OUTPUT_CHANNELS]{};
  88     } mChans[MAX_EFFECT_CHANNELS];
  89
  90
  91     ALboolean deviceUpdate(const ALCdevice *device) override;
  92     void update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props, const EffectTarget target) override;
  93     void process(ALsizei samplesToDo, const ALfloat (*RESTRICT samplesIn)[BUFFERSIZE], ALfloat (*RESTRICT samplesOut)[BUFFERSIZE], ALsizei numChannels) override;
  94
  95     DEF_NEWDEL(ALmodulatorState)
  96 };
  97
  98 ALboolean ALmodulatorState::deviceUpdate(const ALCdevice *UNUSED(device))
  99 {
 100     for(auto &e : mChans)
 101     {
 102         e.Filter.clear();
 103         std::fill(std::begin(e.CurrentGains), std::end(e.CurrentGains), 0.0f);
 104     }
 105     return AL_TRUE;
 106 }
 107
 108 void ALmodulatorState::update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props, const EffectTarget target)
 109 {
 110     const ALCdevice *device = context->Device;
 111     ALfloat f0norm;
 112     ALsizei i;
 113
 114     mStep = fastf2i(props->Modulator.Frequency / static_cast<ALfloat>(device->Frequency) * WAVEFORM_FRACONE);
 115     mStep = clampi(mStep, 0, WAVEFORM_FRACONE-1);
 116
 117     if(mStep == 0)
 118         mGetSamples = Modulate<One>;
 119     else if(props->Modulator.Waveform == AL_RING_MODULATOR_SINUSOID)
 120         mGetSamples = Modulate<Sin>;
 121     else if(props->Modulator.Waveform == AL_RING_MODULATOR_SAWTOOTH)
 122         mGetSamples = Modulate<Saw>;
 123     else /*if(Slot->Params.EffectProps.Modulator.Waveform == AL_RING_MODULATOR_SQUARE)*/
 124         mGetSamples = Modulate<Square>;
 125
 126     f0norm = props->Modulator.HighPassCutoff / static_cast<ALfloat>(device->Frequency);
 127     f0norm = clampf(f0norm, 1.0f/512.0f, 0.49f);
 128     /* Bandwidth value is constant in octaves. */
 129     mChans[0].Filter.setParams(BiquadType::HighPass, 1.0f, f0norm,
 130         calc_rcpQ_from_bandwidth(f0norm, 0.75f));
 131     for(i = 1;i < MAX_EFFECT_CHANNELS;i++)
 132         mChans[i].Filter.copyParamsFrom(mChans[0].Filter);
 133
 134     mOutBuffer = target.FOAOut->Buffer;
 135     mOutChannels = target.FOAOut->NumChannels;
 136     for(i = 0;i < MAX_EFFECT_CHANNELS;i++)
 137         ComputePanGains(target.FOAOut, alu::Matrix::Identity()[i].data(), slot->Params.Gain,
 138             mChans[i].TargetGains);
 139 }
 140
 141 void ALmodulatorState::process(ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
 142 {
 143     const ALsizei step = mStep;
 144     ALsizei base;
 145
 146     for(base = 0;base < SamplesToDo;)
 147     {
 148         alignas(16) ALfloat modsamples[MAX_UPDATE_SAMPLES];
 149         ALsizei td = mini(MAX_UPDATE_SAMPLES, SamplesToDo-base);
 150         ALsizei c, i;
 151
 152         mGetSamples(modsamples, mIndex, step, td);
 153         mIndex += (step*td) & WAVEFORM_FRACMASK;
 154         mIndex &= WAVEFORM_FRACMASK;
 155
 156         for(c = 0;c < MAX_EFFECT_CHANNELS;c++)
 157         {
 158             alignas(16) ALfloat temps[MAX_UPDATE_SAMPLES];
 159
 160             mChans[c].Filter.process(temps, &SamplesIn[c][base], td);
 161             for(i = 0;i < td;i++)
 162                 temps[i] *= modsamples[i];
 163
 164             MixSamples(temps, NumChannels, SamplesOut, mChans[c].CurrentGains,
 165                        mChans[c].TargetGains, SamplesToDo-base, base, td);
 166         }
 167
 168         base += td;
 169     }
 170 }
 171
 172
 173 struct ModulatorStateFactory final : public EffectStateFactory {
 174     EffectState *create() override;
 175 };
 176
 177 EffectState *ModulatorStateFactory::create()
 178 { return new ALmodulatorState{}; }
 179
 180 EffectStateFactory *ModulatorStateFactory_getFactory()
 181 {
 182     static ModulatorStateFactory ModulatorFactory{};
 183     return &ModulatorFactory;
 184 }
 185
 186
 187 void ALmodulator_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
 188 {
 189     ALeffectProps *props = &effect->Props;
 190     switch(param)
 191     {
 192         case AL_RING_MODULATOR_FREQUENCY:
 193             if(!(val >= AL_RING_MODULATOR_MIN_FREQUENCY && val <= AL_RING_MODULATOR_MAX_FREQUENCY))
 194                 SETERR_RETURN(context, AL_INVALID_VALUE,, "Modulator frequency out of range");
 195             props->Modulator.Frequency = val;
 196             break;
 197
 198         case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
 199             if(!(val >= AL_RING_MODULATOR_MIN_HIGHPASS_CUTOFF && val <= AL_RING_MODULATOR_MAX_HIGHPASS_CUTOFF))
 200                 SETERR_RETURN(context, AL_INVALID_VALUE,, "Modulator high-pass cutoff out of range");
 201             props->Modulator.HighPassCutoff = val;
 202             break;
 203
 204         default:
 205             alSetError(context, AL_INVALID_ENUM, "Invalid modulator float property 0x%04x", param);
 206     }
 207 }
 208 void ALmodulator_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
 209 { ALmodulator_setParamf(effect, context, param, vals[0]); }
 210 void ALmodulator_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
 211 {
 212     ALeffectProps *props = &effect->Props;
 213     switch(param)
 214     {
 215         case AL_RING_MODULATOR_FREQUENCY:
 216         case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
 217             ALmodulator_setParamf(effect, context, param, static_cast<ALfloat>(val));
 218             break;
 219
 220         case AL_RING_MODULATOR_WAVEFORM:
 221             if(!(val >= AL_RING_MODULATOR_MIN_WAVEFORM && val <= AL_RING_MODULATOR_MAX_WAVEFORM))
 222                 SETERR_RETURN(context, AL_INVALID_VALUE,, "Invalid modulator waveform");
 223             props->Modulator.Waveform = val;
 224             break;
 225
 226         default:
 227             alSetError(context, AL_INVALID_ENUM, "Invalid modulator integer property 0x%04x", param);
 228     }
 229 }
 230 void ALmodulator_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
 231 { ALmodulator_setParami(effect, context, param, vals[0]); }
 232
 233 void ALmodulator_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
 234 {
 235     const ALeffectProps *props = &effect->Props;
 236     switch(param)
 237     {
 238         case AL_RING_MODULATOR_FREQUENCY:
 239             *val = static_cast<ALint>(props->Modulator.Frequency);
 240             break;
 241         case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
 242             *val = static_cast<ALint>(props->Modulator.HighPassCutoff);
 243             break;
 244         case AL_RING_MODULATOR_WAVEFORM:
 245             *val = props->Modulator.Waveform;
 246             break;
 247
 248         default:
 249             alSetError(context, AL_INVALID_ENUM, "Invalid modulator integer property 0x%04x", param);
 250     }
 251 }
 252 void ALmodulator_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
 253 { ALmodulator_getParami(effect, context, param, vals); }
 254 void ALmodulator_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
 255 {
 256     const ALeffectProps *props = &effect->Props;
 257     switch(param)
 258     {
 259         case AL_RING_MODULATOR_FREQUENCY:
 260             *val = props->Modulator.Frequency;
 261             break;
 262         case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
 263             *val = props->Modulator.HighPassCutoff;
 264             break;
 265
 266         default:
 267             alSetError(context, AL_INVALID_ENUM, "Invalid modulator float property 0x%04x", param);
 268     }
 269 }
 270 void ALmodulator_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
 271 { ALmodulator_getParamf(effect, context, param, vals); }
 272
 273 DEFINE_ALEFFECT_VTABLE(ALmodulator);