orc.c

   1 /*
   2 orc.c
   3 various software synths and samples
   4
   5 Copyright (C) 2009 Evan Rinehart
   6
   7 This software comes with no warranty.
   8 1. This software can be used for any purpose, good or evil.
   9 2. Modifications must retain this license, at least in spirit.
  10 */
  11
  12 #include <stdlib.h>
  13 #include <math.h>
  14
  15 #include <orc.h>
  16
  17 /*
  18 heres a list of instrument ideas...
  19
  20 piano (not sure yet)
  21 brass (not sure yet)
  22 string (not sure yet)
  23 drum (probably samples)
  24 bass kick (classic analog algorithm)
  25 square triangle saw (polyblep ?)
  26 wind instruments (additive synth via uninterpolated table)
  27 sampler (perhaps a compressed array of samples)
  28 rendered ambient (PADsynth)
  29
  30 */
  31
  32
  33 /* SINE TABLE */
  34 static float SAMPLE_RATE = 44100;
  35
  36 #define TABLE_SIZE (1<<8)
  37 #define RELEASE_STEPS (SAMPLE_RATE/333)
  38 #define RELEASE_RATE 0.999
  39
  40
  41 float sine_table[TABLE_SIZE];
  42
  43 float note2tablestep(float note){
  44         /* critical formula for tuning a table */
  45         /* table steps for 2pif/SAMPLE_RATE radians is...*/
  46         /* TABLE_SIZE/PI2 == entries per radian */
  47         /* step == 2pif/SAMPLE_RATE * (TABLE_SIZE/PI2) */
  48         /*      == f * TABLE_SIZE / SAMPLE_RATE */
  49         /*      == f_0 2^(note/12) TABLE_SIZE / SAMPLE_RATE */
  50         float f = 440 * pow(2, note/12.0);
  51         return f*TABLE_SIZE / SAMPLE_RATE;
  52 }
  53
  54 float sine_table_interp(float ptr){
  55         float i0 = floor(ptr);
  56         float i1 = i0+1;
  57         int I0 = i0;
  58         int I1 = i1;
  59         if(I0 < 0) I0 += TABLE_SIZE;
  60         if(I1 >= TABLE_SIZE) I1 -= TABLE_SIZE;
  61         float _y0 = sine_table[I0];
  62         float _y1 = sine_table[I1];
  63
  64         float m = (ptr-i0);
  65         float ans = m*((_y1-_y0)/(i1-i0)) + _y0;
  66         return ans;
  67 }
  68
  69
  70 float normalize(float note){
  71         /* original
  72         -inf, -24 : 4
  73         -24, -12: 2
  74         -12, 24: 1
  75         24,36: 0.5
  76         36,48: 0.25
  77         48, +inf: 0.125*/
  78         const float min = -48;
  79         const float max = 48;
  80         const float left = 4;
  81         const float right = 0.125;
  82
  83         if(note < min) return left;
  84         if(note > max) return right;
  85
  86         float ans = (note - min)*((right-left) / (max-min)) + left;
  87         if(ans > 4) return 4;
  88         if(ans < 0.125) return 0.125;
  89         return ans;
  90 }
  91
  92
  93
  94 /* ORG_DEFAULT: default fallback instrument */
  95 struct defstate {
  96         int on[16];
  97         int note[16];
  98         float step[16];
  99         float ptr[16];
 100         float release[16];
 101         float bendstep[16];
 102         float bend;
 103 };
 104
 105 void default_gen(struct defstate* data, int z, float out[], int count){
 106         if(data->on[z] == 0) return;
 107         int i;
 108         for(i=0; i<count; i++){
 109                 float step = data->step[z] + data->bendstep[z];
 110                 if(data->on[z] == 2){
 111                         data->release[z] *= RELEASE_RATE;
 112                         if(data->release[z] < 0.01){
 113                                 data->on[z] = 0;
 114                                 break;
 115                         }
 116                 }
 117
 118         //      float factor = normalize(data->note[z] + data->bend) * data->release[z];
 119                 //float amp = sine_table[data->ptr[z]];
 120                 float amp = sine_table_interp(data->ptr[z]);
 121         //      out[i] += amp * factor;
 122                 out[i] += 13*(amp / 16.0 * data->release[z]);
 123                 data->ptr[z] += step;
 124                 while(data->ptr[z] >= TABLE_SIZE){
 125                         data->ptr[z] -= TABLE_SIZE;
 126                 }
 127                 while(data->ptr[z] < 0){
 128                         data->ptr[z] += TABLE_SIZE;
 129                 }
 130         }
 131 }
 132
 133 void default_mix(void* ud, float out[], int count){
 134         struct defstate* data = ud;
 135         int i;
 136         for(i=0; i<16; i++){
 137                 default_gen(data, i, out, count);
 138         }
 139 }
 140
 141
 142 void default_bend_gen(struct defstate* data, int i, float bend){
 143         if(data->on[i] == 0) return;
 144         int note = data->note[i];
 145         data->bendstep[i] = note2tablestep(note + bend) - data->step[i];
 146 }
 147
 148 void default_turn_on(struct defstate* data, int note){
 149         float step = note2tablestep(note);
 150         int i;
 151         for(i=0; i<16; i++){
 152                 if(data->on[i]==0){
 153                         data->step[i] = step;
 154                         data->note[i] = note;
 155                         data->on[i] = 1;
 156                         data->ptr[i] = 0;
 157                         data->release[i] = 1.0;
 158                         default_bend_gen(data, i, data->bend);
 159                         return;
 160                 }
 161         }
 162 }
 163
 164 void default_turn_off(struct defstate* data, int note){
 165         int i;
 166         for(i=0; i<16; i++){
 167                 if(data->note[i] == note && data->on[i] == 1){
 168                         data->on[i] = 2;
 169                         return;
 170                 }
 171         }
 172 }
 173
 174 void default_bend(struct defstate* data, int amount){
 175         int max = 16383;
 176         int relative = amount - max/2;
 177         float bend = 1.0*relative/max * 4;
 178         int i;
 179         data->bend = bend;
 180         for(i=0; i<16; i++){
 181                 default_bend_gen(data, i, bend);
 182         }
 183 }
 184
 185 void default_control(void* ud, int type, int val1, int val2, int val){
 186         struct defstate* data = ud;
 187         switch(type){
 188                 case EV_NOTEON: default_turn_on(data, val1); break;
 189                 case EV_NOTEOFF: default_turn_off(data, val1); break;
 190                 case EV_PITCHBEND: default_bend(data, val); break;
 191         }
 192 }
 193
 194 void default_cleanup(void* data){ free(data); }
 195
 196 instrument make_default(){
 197         instrument ins;
 198         struct defstate* data = malloc(sizeof(struct defstate));
 199         int i;
 200         for(i=0; i<16; i++){
 201                 data->on[i] = 0;
 202                 data->note[i] = 0;
 203                 data->step[i] = 100;
 204                 data->ptr[i] = 0;
 205                 data->bendstep[i] = 0;
 206                 data->bend = 0;
 207         }
 208         ins.mix = default_mix;
 209         ins.control = default_control;
 210         ins.cleanup = default_cleanup;
 211         ins.data = data;
 212         return ins;
 213 }
 214
 215
 216
 217
 218 /* ORG_KARPLUS: karplus strong string synth */
 219
 220 #define KARF 1024
 221
 222 struct karplus {
 223         float buf[KARF];
 224         float ptr;
 225         float length;
 226         float note;
 227         float bend;
 228         float step;
 229         float offset;
 230 };
 231
 232 void karplus_mix(void* ud, float out[], int count){
 233         int i;
 234         struct karplus* data = ud;
 235         for(i=0; i<count; i++){
 236                 int L = data->length;
 237                 int z1 = floor(data->ptr);
 238                 int z0 = z1-1;
 239                 if(z1 >= L) z1 -= L;
 240                 if(z1 < 0) z1 += L;
 241                 if(z0 >= L) z0 -= L;
 242                 if(z0 < 0) z0 += L;
 243                 //out[i] = linterp(data->buf, data->ptr) * 6;
 244                 out[i] = data->buf[z0] * 10;
 245                 data->buf[z1] = (data->buf[z1] + data->buf[z0]) / 2.015;
 246                 data->ptr += 1;
 247                 if(data->ptr >= L){
 248                         data->ptr -= L;
 249                 }
 250         }
 251 }
 252
 253 void karplus_control(void* ud, int type, int val1, int val2, int val){
 254         struct karplus* data = ud;
 255         int i;
 256         float f, L;
 257         double r;
 258         switch(type){
 259                 case EV_NOTEON:
 260                         data->note = val1;
 261                         f = 440*(pow(2, val1/12.0));
 262                         L = SAMPLE_RATE * 1.0 / f;
 263                         data->length = L*2;
 264                         for(i=0; i<100; i++){
 265                                 r = rand();
 266                                 data->buf[i] += r/RAND_MAX - 0.5;
 267                         }
 268                         return;
 269                 case EV_NOTEOFF:
 270                         for(i=0; i<KARF; i++){
 271                                 data->buf[i] = 0;
 272                         }
 273                         return;
 274 //              case EV_PITCHBEND: default_bend(data, val); break;
 275         }
 276 }
 277
 278
 279 void karplus_cleanup(void* data){ free(data); }
 280
 281 instrument make_karplus(){
 282         instrument ins;
 283         struct karplus* data = malloc(sizeof(struct karplus));
 284         int i;
 285         data->length = 512;
 286         data->ptr = 0;
 287         for(i=0; i<KARF; i++){
 288                 data->buf[i] = 0;
 289         }
 290         ins.mix = karplus_mix;
 291         ins.control = karplus_control;
 292         ins.cleanup = karplus_cleanup;
 293         ins.data = data;
 294         return ins;
 295 }
 296
 297
 298
 299 /*** exported methods ***/
 300 instrument orc_load(enum instrument_name name){
 301         switch(name){
 302                 case ORC_DEFAULT: return make_default();
 303                 case ORC_KARPLUS: return make_karplus();
 304 //              case ORC_COOL: return make_cool();
 305                 default: return make_default();
 306         }
 307 }
 308
 309
 310 void orc_init(int sample_rate){
 311         int i;
 312         SAMPLE_RATE = sample_rate;
 313         for(i=0; i<TABLE_SIZE; i++){
 314                 sine_table[i] = sin( (PI2*i) / TABLE_SIZE);
 315         }
 316 }
 317
 318
 319
 320