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[OUTPUTCHANNELS];
  47
  48     FILTER iirFilter;
  49     ALfloat history[1];
  50 } ALmodulatorState;
  51
  52 #define WAVEFORM_FRACBITS  16
  53 #define WAVEFORM_FRACMASK  ((1<<WAVEFORM_FRACBITS)-1)
  54
  55 static __inline ALfloat sin_func(ALuint index)
  56 {
  57     return sin(index / (double)(1<<WAVEFORM_FRACBITS) * M_PI * 2.0f);
  58 }
  59
  60 static __inline ALfloat saw_func(ALuint index)
  61 {
  62     return index*2.0f/(1<<WAVEFORM_FRACBITS) - 1.0f;
  63 }
  64
  65 static __inline ALfloat square_func(ALuint index)
  66 {
  67     return ((index>>(WAVEFORM_FRACBITS-1))&1) ? -1.0f : 1.0f;
  68 }
  69
  70
  71 static __inline ALfloat hpFilter1P(FILTER *iir, ALuint offset, ALfloat input)
  72 {
  73     ALfloat *history = &iir->history[offset];
  74     ALfloat a = iir->coeff;
  75     ALfloat output = input;
  76
  77     output = output + (history[0]-output)*a;
  78     history[0] = output;
  79
  80     return input - output;
  81 }
  82
  83
  84 static ALvoid ModulatorDestroy(ALeffectState *effect)
  85 {
  86     ALmodulatorState *state = (ALmodulatorState*)effect;
  87     free(state);
  88 }
  89
  90 static ALboolean ModulatorDeviceUpdate(ALeffectState *effect, ALCdevice *Device)
  91 {
  92     ALmodulatorState *state = (ALmodulatorState*)effect;
  93     ALuint index;
  94
  95     for(index = 0;index < OUTPUTCHANNELS;index++)
  96         state->Gain[index] = 0.0f;
  97     for(index = 0;index < Device->NumChan;index++)
  98     {
  99         Channel chan = Device->Speaker2Chan[index];
 100         state->Gain[chan] = 1.0f;
 101     }
 102
 103     return AL_TRUE;
 104 }
 105
 106 static ALvoid ModulatorUpdate(ALeffectState *effect, ALCcontext *Context, const ALeffect *Effect)
 107 {
 108     ALmodulatorState *state = (ALmodulatorState*)effect;
 109     ALfloat cw, a = 0.0f;
 110
 111     if(Effect->Modulator.Waveform == AL_RING_MODULATOR_SINUSOID)
 112         state->Waveform = SINUSOID;
 113     else if(Effect->Modulator.Waveform == AL_RING_MODULATOR_SAWTOOTH)
 114         state->Waveform = SAWTOOTH;
 115     else if(Effect->Modulator.Waveform == AL_RING_MODULATOR_SQUARE)
 116         state->Waveform = SQUARE;
 117
 118     state->step = Effect->Modulator.Frequency*(1<<WAVEFORM_FRACBITS) /
 119                   Context->Device->Frequency;
 120     if(!state->step)
 121         state->step = 1;
 122
 123     cw = cos(2.0*M_PI * Effect->Modulator.HighPassCutoff / Context->Device->Frequency);
 124     a = (2.0f-cw) - aluSqrt(aluPow(2.0f-cw, 2.0f) - 1.0f);
 125     state->iirFilter.coeff = a;
 126 }
 127
 128 static ALvoid ModulatorProcess(ALeffectState *effect, const ALeffectslot *Slot, ALuint SamplesToDo, const ALfloat *SamplesIn, ALfloat (*SamplesOut)[OUTPUTCHANNELS])
 129 {
 130     ALmodulatorState *state = (ALmodulatorState*)effect;
 131     const ALfloat gain = Slot->Gain;
 132     const ALuint step = state->step;
 133     ALuint index = state->index;
 134     ALfloat samp;
 135     ALuint i;
 136
 137     switch(state->Waveform)
 138     {
 139     case SINUSOID:
 140         for(i = 0;i < SamplesToDo;i++)
 141         {
 142 #define FILTER_OUT(func) do {                                                 \
 143     samp = SamplesIn[i];                                                      \
 144                                                                               \
 145     index += step;                                                            \
 146     index &= WAVEFORM_FRACMASK;                                               \
 147     samp *= func(index);                                                      \
 148                                                                               \
 149     samp = hpFilter1P(&state->iirFilter, 0, samp);                            \
 150                                                                               \
 151     /* Apply slot gain */                                                     \
 152     samp *= gain;                                                             \
 153                                                                               \
 154     SamplesOut[i][FRONT_LEFT]   += state->Gain[FRONT_LEFT]   * samp;          \
 155     SamplesOut[i][FRONT_RIGHT]  += state->Gain[FRONT_RIGHT]  * samp;          \
 156     SamplesOut[i][FRONT_CENTER] += state->Gain[FRONT_CENTER] * samp;          \
 157     SamplesOut[i][SIDE_LEFT]    += state->Gain[SIDE_LEFT]    * samp;          \
 158     SamplesOut[i][SIDE_RIGHT]   += state->Gain[SIDE_RIGHT]   * samp;          \
 159     SamplesOut[i][BACK_LEFT]    += state->Gain[BACK_LEFT]    * samp;          \
 160     SamplesOut[i][BACK_RIGHT]   += state->Gain[BACK_RIGHT]   * samp;          \
 161     SamplesOut[i][BACK_CENTER]  += state->Gain[BACK_CENTER]  * samp;          \
 162 } while(0)
 163             FILTER_OUT(sin_func);
 164         }
 165         break;
 166
 167     case SAWTOOTH:
 168         for(i = 0;i < SamplesToDo;i++)
 169         {
 170             FILTER_OUT(saw_func);
 171         }
 172         break;
 173
 174     case SQUARE:
 175         for(i = 0;i < SamplesToDo;i++)
 176         {
 177             FILTER_OUT(square_func);
 178 #undef FILTER_OUT
 179         }
 180         break;
 181     }
 182     state->index = index;
 183 }
 184
 185 ALeffectState *ModulatorCreate(void)
 186 {
 187     ALmodulatorState *state;
 188
 189     state = malloc(sizeof(*state));
 190     if(!state)
 191         return NULL;
 192
 193     state->state.Destroy = ModulatorDestroy;
 194     state->state.DeviceUpdate = ModulatorDeviceUpdate;
 195     state->state.Update = ModulatorUpdate;
 196     state->state.Process = ModulatorProcess;
 197
 198     state->index = 0.0f;
 199     state->step = 1.0f;
 200
 201     state->iirFilter.coeff = 0.0f;
 202     state->iirFilter.history[0] = 0.0f;
 203
 204     return &state->state;
 205 }