precompute.c

   1 /*
   2 orgux - a just-for-fun real time synth
   3 Copyright (C) 2009  Evan Rinehart
   4
   5 This program is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU General Public License
   7 as published by the Free Software Foundation; either version 2
   8 of the License, or (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18 */
  19
  20 /* precompute waveforms */
  21
  22 #include <stdio.h>
  23 #include <math.h>
  24 #include <stdlib.h>
  25 #include "constants.h"
  26
  27 extern float square_wave[WAVEFORM_LENGTH];
  28 extern float saw_wave[WAVEFORM_LENGTH];
  29 extern float triangle_wave[WAVEFORM_LENGTH];
  30
  31 extern const unsigned char instr_config[128][16];
  32
  33 extern float waveform[128][WAVEFORM_LENGTH];
  34 extern float samples[SAMPLE_COUNT][SAMPLE_LENGTH];
  35 extern float antipop[ANTIPOP_LENGTH];
  36
  37 float linterp(float x, int k, float wave[]){
  38   float X = x*k;
  39   float Xw = X - WAVEFORM_LENGTH*floor(X/WAVEFORM_LENGTH);
  40   int X0 = floor(Xw);
  41   int X1 = X0+1;
  42   if(X1 == WAVEFORM_LENGTH) X1 = 0;
  43
  44   float y1 = wave[X1];
  45   float y0 = wave[X0];
  46   float m = (y1-y0)/(X1-X0);
  47
  48   return m*(x-X0)+y0;
  49 }
  50
  51 void precompute(int sample_rate){
  52
  53   float dt = 1.0/sample_rate;
  54
  55 printf("generating band limited bases... ");
  56
  57
  58   for(int i=0; i<WAVEFORM_LENGTH; i++){
  59     square_wave[i] = 0;
  60     triangle_wave[i] = 0;
  61     saw_wave[i] = 0;
  62     for(int j=0; j<7; j++){
  63       square_wave[i] += (4/PI)*sin(i*(2*j+1)*PI2/WAVEFORM_LENGTH)/(2*j+1);
  64       triangle_wave[i] += (8/(PI*PI))*(j&1?1:-1)*sin(i*(2*j+1)*PI2/WAVEFORM_LENGTH)/((2*j+1)*(2*j+1));
  65       saw_wave[i] += (2/PI)*sin(i*(j+1)*PI2/WAVEFORM_LENGTH)/(j+1);
  66     }
  67   }
  68
  69 float maxf[3] = {0,0,0};
  70 for(int i=0; i<WAVEFORM_LENGTH; i++){
  71   if(maxf[0] < square_wave[i]) maxf[0] = square_wave[i];
  72   if(maxf[1] < triangle_wave[i]) maxf[1] = triangle_wave[i];
  73   if(maxf[2] < saw_wave[i]) maxf[2] = saw_wave[i];
  74 }
  75
  76 for(int i=0; i<WAVEFORM_LENGTH; i++){
  77   square_wave[i] /= maxf[0];
  78   triangle_wave[i] /= maxf[1];
  79   saw_wave[i] /= maxf[2];
  80 }
  81
  82 //printf("\nsquare max = %f\n",maxf[0]);
  83 //printf("triangle max = %f\n",maxf[1]);
  84 //printf("saw max = %f\n\n",maxf[2]);
  85
  86
  87 printf("OK\n");
  88
  89   /* setup wave tables */
  90
  91 printf("generating instruments... ");
  92
  93 printf("                  0 1 2 3 4 5 6 7 | basis  FM  FM_freq  LP HP\n");
  94   for(int i=0; i<128; i++){
  95
  96 int max = 0;
  97 float N = 0;
  98
  99 printf("instrument[%d] = {",i);
 100
 101     for(int j=0; j<HARMONIC_COUNT; j++){
 102       printf("%d ",instr_config[i][j]);
 103       if(instr_config[i][j] > max){ max = instr_config[i][j]; }
 104     }
 105
 106 printf("|");
 107
 108     for(int j=0; j<HARMONIC_COUNT; j++){
 109       float M = ((float)instr_config[i][j])/max;
 110       M = M*M;
 111       N += M;
 112
 113       switch(instr_config[i][BASE_CONFIG]){
 114         case SINE_BASE:
 115           for(int k=0; k<WAVEFORM_LENGTH; k++){
 116             waveform[i][k]+=M*sin(k*(j+1)*PI2/WAVEFORM_LENGTH);
 117           }
 118           break;
 119         case SQUARE_BASE:
 120           for(int k=0; k<WAVEFORM_LENGTH; k++){
 121             waveform[i][k]+=M*linterp(k,j+1,square_wave);;
 122           }
 123           break;
 124         case SAW_BASE:
 125           for(int k=0; k<WAVEFORM_LENGTH; k++){
 126             waveform[i][k]+=M*linterp(k,j+1,saw_wave);;
 127           }
 128           break;
 129         case TRIANGLE_BASE:
 130           for(int k=0; k<WAVEFORM_LENGTH; k++){
 131             waveform[i][k]+=M*linterp(k,j+1,triangle_wave);
 132           }
 133           break;
 134       }
 135
 136     }
 137
 138     if(N>0){
 139       for(int j=0; j<WAVEFORM_LENGTH; j++){
 140         waveform[i][j] /= N*10;
 141       }
 142     }
 143
 144 /*
 145     for(int j=0; j<WAVEFORM_LENGTH; j++){
 146       waveform[i][j] = 0.0f;
 147       N = 0;
 148       for(int k=0; k<HARMONIC_COUNT; k++){
 149         float M = ((float)instr_config[i][k])/max;
 150         M = M*M;
 151         N += M;
 152
 153         float y;
 154         switch(instr_config[i][BASE_CONFIG]){
 155           case SINE_BASE: y = sin(j*(k+1)*PI2/WAVEFORM_LENGTH); break;
 156           //case SQUARE_BASE: y = ((2*j*(1<<k)/WAVEFORM_LENGTH)&1)?1:-1; break;
 157           case SQUARE_BASE: y = linterp(j,k+1,square_wave); break;
 158           case TRIANGLE_BASE: y = linterp(j,k+1,triangle_wave); break;
 159           case SAW_BASE: y = linterp(j,k+1,saw_wave); break;
 160           //case NOISE_BASE: y = RANDF()*2 - 1; break;
 161           case NOISE_BASE: y = 0; break;
 162           default: y = 0;//use previously defined waveform
 163         }
 164
 165         waveform[i][j] += M*y;
 166       }
 167       if(N>0){ waveform[i][j] /= N*10; }
 168     }
 169 */
 170     printf("\n");
 171
 172   }
 173
 174   printf("OK\n");
 175
 176
 177   //generate antipop cosine
 178   for(int i=0; i<ANTIPOP_LENGTH; i++){
 179     antipop[i] = -cos(i*PI2/(2.0*ANTIPOP_LENGTH))/2.0+0.5;
 180   }
 181
 182
 183   //generate samples
 184
 185   float par[16][8] = {/**/
 186 {50, 500, 0.5, 10000, 0, 0, 0, 0},
 187 {200, 200, 0.5, 10000, 0, 0, 0, 0},
 188 {100, 500, 0.5, 10000, 0, 0, 0, 0},
 189 {100, 1000, 0.5, 10000, 0, 0, 0, 0},
 190
 191 {100, 500, 0.5, 3000, 0, 0, 0, 0},
 192 {200, 500, 0.5, 3000, 0, 0, 0, 0},
 193 {300, 500, 0.5, 3000, 0, 0, 0, 0},
 194 {400, 500, 0.5, 3000, 0, 0, 0, 0},
 195
 196 {400, 200, 0.5, 3000, 0, 0, 0, 0},
 197 {400, 100, 0.5, 3000, 0, 0, 0, 0},
 198 {400, 50, 0.5, 3000, 0, 0, 0, 0},
 199 {400, 20, 0.5, 3000, 0, 0, 0, 0},
 200
 201 {100, 500, 0.5, 10000, 0, 0, 0, 0},
 202 {100, 500, 0.5, 10000, 0, 0, 0, 0},
 203 {100, 500, 0.5, 10000, 0, 0, 0, 0},
 204 {100, 500, 0.5, 10000, 0, 0, 0, 0}
 205 };
 206
 207   double K = PI2 / sample_rate;
 208 printf("generating samples... ");
 209   for(int i=0; i<SAMPLE_LENGTH; i++){
 210     for(int j=0; j<SAMPLE_COUNT; j++){
 211       double F_i = par[j][0];
 212       double F_r = par[j][1];
 213       double A_i = par[j][2];
 214       double A_r = par[j][3];
 215
 216       if(F_r < 1){F_r = 1;}
 217       double f = F_i - i/F_r;
 218       if(f < 0) f = 0;
 219
 220       if(A_r < 1){A_r = 1;}
 221       double A = A_i - i/A_r;
 222       if(A < 0) A = 0;
 223
 224       double E = 1;
 225       if(i < 64){
 226         E = -cos((i/64.0) * PI2 / 2)/2+0.5;
 227       }
 228
 229       samples[j][i] = E*A*sin(i*f*K);
 230     }
 231   }
 232
 233
 234
 235   float y_l;
 236   float y_h0=0;
 237   float y_h1=0;
 238
 239 /*
 240 notes
 241
 242 cool hit
 243 tau2 = 0.0001 / (1 + i/50.0)
 244 alpha2 = tau2 / (tau2 + dt)
 245 A = 0.2 - (i/10000.0)
 246
 247
 248
 249
 250
 251 */
 252
 253   for(int i=0; i<SAMPLE_LENGTH; i++){
 254
 255     float tau1 = (i/200.0)*0.0001;
 256     float alpha1 = dt/(tau1+dt);
 257
 258     float tau2 = 0.0001 / (1 + i/50.0);
 259     float alpha2 = tau2/(tau2+dt);
 260
 261     float y = RAND_SIGNAL();
 262
 263     //y = y_l0 + alpha1*(y - y_l0);
 264     //y_l0 = y;
 265
 266     float temp = y;
 267     y = alpha2*(y - y_h0 + y_h1);
 268     y_h0 = temp;
 269     y_h1 = y;
 270
 271     float A = 0.2 - (i/10000.0);
 272     if(A<0) A = 0;
 273
 274     double E = 1;
 275     if(i < 64){
 276       E = -cos((i/64.0) * PI2 / 2)/2+0.5;
 277     }
 278
 279     samples[15][i] = A*E*y;
 280
 281   }
 282 printf("OK\n");
 283
 284 printf("precompute OK\n");
 285
 286
 287 }