git.sesse.net Git - vlc/blob - modules/audio_filter/spatializer/revmodel.cpp

   1 // Reverb model implementation
   2 //
   3 //
   4 // Google Summer of Code 2007
   5 //
   6 // Authors: Biodun Osunkunle <biodun@videolan.org>
   7 //
   8 // Mentor : Jean-Baptiste Kempf <jb@videolan.org>
   9 //
  10 // Original written by Jezar at Dreampoint, June 2000
  11
  12 // This code is public domain
  13
  14 #include "revmodel.hpp"
  15 #include <stdlib.h>
  16
  17 revmodel::revmodel()
  18 {
  19         // Tie the components to their buffers
  20         combL[0].setbuffer(bufcombL1,combtuningL1);
  21         combR[0].setbuffer(bufcombR1,combtuningR1);
  22         combL[1].setbuffer(bufcombL2,combtuningL2);
  23         combR[1].setbuffer(bufcombR2,combtuningR2);
  24         combL[2].setbuffer(bufcombL3,combtuningL3);
  25         combR[2].setbuffer(bufcombR3,combtuningR3);
  26         combL[3].setbuffer(bufcombL4,combtuningL4);
  27         combR[3].setbuffer(bufcombR4,combtuningR4);
  28         combL[4].setbuffer(bufcombL5,combtuningL5);
  29         combR[4].setbuffer(bufcombR5,combtuningR5);
  30         combL[5].setbuffer(bufcombL6,combtuningL6);
  31         combR[5].setbuffer(bufcombR6,combtuningR6);
  32         combL[6].setbuffer(bufcombL7,combtuningL7);
  33         combR[6].setbuffer(bufcombR7,combtuningR7);
  34         combL[7].setbuffer(bufcombL8,combtuningL8);
  35         combR[7].setbuffer(bufcombR8,combtuningR8);
  36         allpassL[0].setbuffer(bufallpassL1,allpasstuningL1);
  37         allpassR[0].setbuffer(bufallpassR1,allpasstuningR1);
  38         allpassL[1].setbuffer(bufallpassL2,allpasstuningL2);
  39         allpassR[1].setbuffer(bufallpassR2,allpasstuningR2);
  40         allpassL[2].setbuffer(bufallpassL3,allpasstuningL3);
  41         allpassR[2].setbuffer(bufallpassR3,allpasstuningR3);
  42         allpassL[3].setbuffer(bufallpassL4,allpasstuningL4);
  43         allpassR[3].setbuffer(bufallpassR4,allpasstuningR4);
  44
  45         // Set default values
  46         allpassL[0].setfeedback(0.5f);
  47         allpassR[0].setfeedback(0.5f);
  48         allpassL[1].setfeedback(0.5f);
  49         allpassR[1].setfeedback(0.5f);
  50         allpassL[2].setfeedback(0.5f);
  51         allpassR[2].setfeedback(0.5f);
  52         allpassL[3].setfeedback(0.5f);
  53         allpassR[3].setfeedback(0.5f);
  54         setwet(initialwet);
  55         setroomsize(initialroom);
  56         setdry(initialdry);
  57         setdamp(initialdamp);
  58         setwidth(initialwidth);
  59         setmode(initialmode);
  60
  61         // Buffer will be full of rubbish - so we MUST mute them
  62         mute();
  63 }
  64
  65 void revmodel::mute()
  66 {
  67         int i;
  68         if (getmode() >= freezemode)
  69                 return;
  70
  71         for (i = 0 ; i < numcombs ; i++)
  72         {
  73                 combL[i].mute();
  74                 combR[i].mute();
  75         }
  76         for (i=0;i<numallpasses;i++)
  77         {
  78                 allpassL[i].mute();
  79                 allpassR[i].mute();
  80         }
  81 }
  82
  83 void revmodel::processreplace(float *inputL, float *outputL, long numsamples, int skip)
  84 {
  85         float outL,outR,input;
  86         float inputR;
  87         int i;
  88
  89         outL = outR = 0;
  90         if (skip > 1)
  91            inputR = inputL[1];
  92         else
  93            inputR = inputL[0];
  94                 input = (inputL[0] + inputR) * gain;
  95
  96                 // Accumulate comb filters in parallel
  97                 for(i=0; i<numcombs; i++)
  98                 {
  99                         outL += combL[i].process(input);
 100                         outR += combR[i].process(input);
 101                 }
 102
 103                 // Feed through allpasses in series
 104                 for(i=0; i<numallpasses; i++)
 105                 {
 106                         outL = allpassL[i].process(outL);
 107                         outR = allpassR[i].process(outR);
 108                 }
 109
 110                 // Calculate output REPLACING anything already there
 111                 outputL[0] = (outL*wet1 + outR*wet2 + inputR*dry);
 112            if (skip > 1)
 113                 outputL[1] = (outR*wet1 + outL*wet2 + inputR*dry);
 114 }
 115
 116 void revmodel::processmix(float *inputL, float *outputL, long numsamples, int skip)
 117 {
 118         float outL,outR,input;
 119         float inputR;
 120         int i;
 121
 122         outL = outR = 0;
 123         if (skip > 1)
 124            inputR = inputL[1];
 125         else
 126            inputR = inputL[0];
 127                 input = (inputL[0] + inputR) * gain;
 128
 129                 // Accumulate comb filters in parallel
 130                 for(i=0; i<numcombs; i++)
 131                 {
 132                         outL += combL[i].process(input);
 133                         outR += combR[i].process(input);
 134                 }
 135
 136                 // Feed through allpasses in series
 137                 for(i=0; i<numallpasses; i++)
 138                 {
 139                         outL = allpassL[i].process(outL);
 140                         outR = allpassR[i].process(outR);
 141                 }
 142
 143                 // Calculate output REPLACING anything already there
 144                 outputL[0] += (outL*wet1 + outR*wet2 + inputR*dry);
 145            if (skip > 1)
 146                 outputL[1] += (outR*wet1 + outL*wet2 + inputR*dry);
 147 }
 148
 149 void revmodel::update()
 150 {
 151 // Recalculate internal values after parameter change
 152
 153         int i;
 154
 155         wet1 = wet*(width/2 + 0.5f);
 156         wet2 = wet*((1-width)/2);
 157
 158         if (mode >= freezemode)
 159         {
 160                 roomsize1 = 1;
 161                 damp1 = 0;
 162                 gain = muted;
 163         }
 164         else
 165         {
 166                 roomsize1 = roomsize;
 167                 damp1 = damp;
 168                 gain = fixedgain;
 169         }
 170
 171         for(i=0; i<numcombs; i++)
 172         {
 173                 combL[i].setfeedback(roomsize1);
 174                 combR[i].setfeedback(roomsize1);
 175         }
 176
 177         for(i=0; i<numcombs; i++)
 178         {
 179                 combL[i].setdamp(damp1);
 180                 combR[i].setdamp(damp1);
 181         }
 182 }
 183
 184 // The following get/set functions are not inlined, because
 185 // speed is never an issue when calling them, and also
 186 // because as you develop the reverb model, you may
 187 // wish to take dynamic action when they are called.
 188
 189 void revmodel::setroomsize(float value)
 190 {
 191         roomsize = (value*scaleroom) + offsetroom;
 192         update();
 193 }
 194
 195 float revmodel::getroomsize()
 196 {
 197         return (roomsize-offsetroom)/scaleroom;
 198 }
 199
 200 void revmodel::setdamp(float value)
 201 {
 202         damp = value*scaledamp;
 203         update();
 204 }
 205
 206 float revmodel::getdamp()
 207 {
 208         return damp/scaledamp;
 209 }
 210
 211 void revmodel::setwet(float value)
 212 {
 213         wet = value*scalewet;
 214         update();
 215 }
 216
 217 float revmodel::getwet()
 218 {
 219         return wet/scalewet;
 220 }
 221
 222 void revmodel::setdry(float value)
 223 {
 224         dry = value*scaledry;
 225 }
 226
 227 float revmodel::getdry()
 228 {
 229         return dry/scaledry;
 230 }
 231
 232 void revmodel::setwidth(float value)
 233 {
 234         width = value;
 235         update();
 236 }
 237
 238 float revmodel::getwidth()
 239 {
 240         return width;
 241 }
 242
 243 void revmodel::setmode(float value)
 244 {
 245         mode = value;
 246         update();
 247 }
 248
 249 float revmodel::getmode()
 250 {
 251         if (mode >= freezemode)
 252                 return 1;
 253         else
 254                 return 0;
 255 }
 256
 257 //ends