Alc/alcModulator.c

   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., 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 <math.h>
  24 #include <stdlib.h>
  25
  26 #include "alMain.h"
  27 #include "alFilter.h"
  28 #include "alAuxEffectSlot.h"
  29 #include "alError.h"
  30 #include "alu.h"
  31
  32
  33 typedef struct ALmodulatorState {
  34     // Must be first in all effects!
  35     ALeffectState state;
  36
  37     enum {
  38         SINUSOID,
  39         SAWTOOTH,
  40         SQUARE
  41     } Waveform;
  42
  43     ALuint index;
  44     ALuint step;
  45
  46     ALfloat Gain[MAXCHANNELS];
  47
  48     FILTER iirFilter;
  49     ALfloat history[1];
  50 } ALmodulatorState;
  51
  52 #define WAVEFORM_FRACBITS  16
  53 #define WAVEFORM_FRACONE   (1<<WAVEFORM_FRACBITS)
  54 #define WAVEFORM_FRACMASK  (WAVEFORM_FRACONE-1)
  55
  56 static __inline ALfloat Sin(ALuint index)
  57 {
  58     return aluSin(index * (F_PI*2.0f / WAVEFORM_FRACONE));
  59 }
  60
  61 static __inline ALfloat Saw(ALuint index)
  62 {
  63     return index*(2.0f/WAVEFORM_FRACONE) - 1.0f;
  64 }
  65
  66 static __inline ALfloat Square(ALuint index)
  67 {
  68     return ((index>>(WAVEFORM_FRACBITS-1))&1)*2.0f - 1.0f;
  69 }
  70
  71
  72 static __inline ALfloat hpFilter1P(FILTER *iir, ALuint offset, ALfloat input)
  73 {
  74     ALfloat *history = &iir->history[offset];
  75     ALfloat a = iir->coeff;
  76     ALfloat output = input;
  77
  78     output = output + (history[0]-output)*a;
  79     history[0] = output;
  80
  81     return input - output;
  82 }
  83
  84
  85 #define DECL_TEMPLATE(func)                                                   \
  86 static void Process##func(ALmodulatorState *state, ALuint SamplesToDo,        \
  87   const ALfloat *SamplesIn, ALfloat (*SamplesOut)[MAXCHANNELS])               \
  88 {                                                                             \
  89     const ALuint step = state->step;                                          \
  90     ALuint index = state->index;                                              \
  91     ALfloat samp;                                                             \
  92     ALuint i, k;                                                              \
  93                                                                               \
  94     for(i = 0;i < SamplesToDo;i++)                                            \
  95     {                                                                         \
  96         samp = SamplesIn[i];                                                  \
  97                                                                               \
  98         index += step;                                                        \
  99         index &= WAVEFORM_FRACMASK;                                           \
 100         samp *= func(index);                                                  \
 101                                                                               \
 102         samp = hpFilter1P(&state->iirFilter, 0, samp);                        \
 103                                                                               \
 104         for(k = 0;k < MAXCHANNELS;k++)                                        \
 105             SamplesOut[i][k] += state->Gain[k] * samp;                        \
 106     }                                                                         \
 107     state->index = index;                                                     \
 108 }
 109
 110 DECL_TEMPLATE(Sin)
 111 DECL_TEMPLATE(Saw)
 112 DECL_TEMPLATE(Square)
 113
 114 #undef DECL_TEMPLATE
 115
 116
 117 static ALvoid ModulatorDestroy(ALeffectState *effect)
 118 {
 119     ALmodulatorState *state = (ALmodulatorState*)effect;
 120     free(state);
 121 }
 122
 123 static ALboolean ModulatorDeviceUpdate(ALeffectState *effect, ALCdevice *Device)
 124 {
 125     return AL_TRUE;
 126     (void)effect;
 127     (void)Device;
 128 }
 129
 130 static ALvoid ModulatorUpdate(ALeffectState *effect, ALCcontext *Context, const ALeffectslot *Slot)
 131 {
 132     ALmodulatorState *state = (ALmodulatorState*)effect;
 133     ALCdevice *Device = Context->Device;
 134     ALfloat gain, cw, a = 0.0f;
 135     ALuint index;
 136
 137     if(Slot->effect.Modulator.Waveform == AL_RING_MODULATOR_SINUSOID)
 138         state->Waveform = SINUSOID;
 139     else if(Slot->effect.Modulator.Waveform == AL_RING_MODULATOR_SAWTOOTH)
 140         state->Waveform = SAWTOOTH;
 141     else if(Slot->effect.Modulator.Waveform == AL_RING_MODULATOR_SQUARE)
 142         state->Waveform = SQUARE;
 143
 144     state->step = fastf2u(Slot->effect.Modulator.Frequency*WAVEFORM_FRACONE /
 145                           Device->Frequency);
 146     if(state->step == 0) state->step = 1;
 147
 148     cw = aluCos(F_PI*2.0f * Slot->effect.Modulator.HighPassCutoff /
 149                             Device->Frequency);
 150     a = (2.0f-cw) - aluSqrt(aluPow(2.0f-cw, 2.0f) - 1.0f);
 151     state->iirFilter.coeff = a;
 152
 153     gain = aluSqrt(1.0f/Device->NumChan);
 154     gain *= Slot->Gain;
 155     for(index = 0;index < MAXCHANNELS;index++)
 156         state->Gain[index] = 0.0f;
 157     for(index = 0;index < Device->NumChan;index++)
 158     {
 159         enum Channel chan = Device->Speaker2Chan[index];
 160         state->Gain[chan] = gain;
 161     }
 162 }
 163
 164 static ALvoid ModulatorProcess(ALeffectState *effect, ALuint SamplesToDo, const ALfloat *SamplesIn, ALfloat (*SamplesOut)[MAXCHANNELS])
 165 {
 166     ALmodulatorState *state = (ALmodulatorState*)effect;
 167
 168     switch(state->Waveform)
 169     {
 170         case SINUSOID:
 171             ProcessSin(state, SamplesToDo, SamplesIn, SamplesOut);
 172             break;
 173
 174         case SAWTOOTH:
 175             ProcessSaw(state, SamplesToDo, SamplesIn, SamplesOut);
 176             break;
 177
 178         case SQUARE:
 179             ProcessSquare(state, SamplesToDo, SamplesIn, SamplesOut);
 180             break;
 181     }
 182 }
 183
 184 ALeffectState *ModulatorCreate(void)
 185 {
 186     ALmodulatorState *state;
 187
 188     state = malloc(sizeof(*state));
 189     if(!state)
 190         return NULL;
 191
 192     state->state.Destroy = ModulatorDestroy;
 193     state->state.DeviceUpdate = ModulatorDeviceUpdate;
 194     state->state.Update = ModulatorUpdate;
 195     state->state.Process = ModulatorProcess;
 196
 197     state->index = 0;
 198     state->step = 1;
 199
 200     state->iirFilter.coeff = 0.0f;
 201     state->iirFilter.history[0] = 0.0f;
 202
 203     return &state->state;
 204 }