quantum/audio/voices.c

   1 #include "voices.h"
   2 #include "audio.h"
   3 #include "stdlib.h"
   4
   5 // these are imported from audio.c
   6 extern uint16_t envelope_index;
   7 extern float note_timbre;
   8 extern float polyphony_rate;
   9 extern bool glissando;
  10
  11 voice_type voice = default_voice;
  12
  13 void set_voice(voice_type v) {
  14     voice = v;
  15 }
  16
  17 void voice_iterate() {
  18     voice = (voice + 1) % number_of_voices;
  19 }
  20
  21 void voice_deiterate() {
  22     voice = (voice - 1 + number_of_voices) % number_of_voices;
  23 }
  24
  25 float voice_envelope(float frequency) {
  26     // envelope_index ranges from 0 to 0xFFFF, which is preserved at 880.0 Hz
  27     uint16_t compensated_index = (uint16_t)((float)envelope_index * (880.0 / frequency));
  28
  29     switch (voice) {
  30         case default_voice:
  31             glissando = true;
  32             note_timbre = TIMBRE_50;
  33             polyphony_rate = 0;
  34                 break;
  35
  36     #ifdef AUDIO_VOICES
  37
  38         case something:
  39             glissando = false;
  40             polyphony_rate = 0;
  41             switch (compensated_index) {
  42                 case 0 ... 9:
  43                     note_timbre = TIMBRE_12;
  44                     break;
  45
  46                 case 10 ... 19:
  47                     note_timbre = TIMBRE_25;
  48                     break;
  49
  50                 case 20 ... 200:
  51                     note_timbre = .125 + .125;
  52                     break;
  53
  54                 default:
  55                     note_timbre = .125;
  56                     break;
  57             }
  58             break;
  59
  60         case drums:
  61             glissando = false;
  62             polyphony_rate = 0;
  63                 // switch (compensated_index) {
  64                 //     case 0 ... 10:
  65                 //         note_timbre = 0.5;
  66                 //         break;
  67                 //     case 11 ... 20:
  68                 //         note_timbre = 0.5 * (21 - compensated_index) / 10;
  69                 //         break;
  70                 //     default:
  71                 //         note_timbre = 0;
  72                 //         break;
  73                 // }
  74                 // frequency = (rand() % (int)(frequency * 1.2 - frequency)) + (frequency * 0.8);
  75
  76             if (frequency < 80.0) {
  77
  78             } else if (frequency < 160.0) {
  79
  80                 // Bass drum: 60 - 100 Hz
  81                 frequency = (rand() % (int)(40)) + 60;
  82                 switch (envelope_index) {
  83                     case 0 ... 10:
  84                         note_timbre = 0.5;
  85                         break;
  86                     case 11 ... 20:
  87                         note_timbre = 0.5 * (21 - envelope_index) / 10;
  88                         break;
  89                     default:
  90                         note_timbre = 0;
  91                         break;
  92                 }
  93
  94             } else if (frequency < 320.0) {
  95
  96
  97                 // Snare drum: 1 - 2 KHz
  98                 frequency = (rand() % (int)(1000)) + 1000;
  99                 switch (envelope_index) {
 100                     case 0 ... 5:
 101                         note_timbre = 0.5;
 102                         break;
 103                     case 6 ... 20:
 104                         note_timbre = 0.5 * (21 - envelope_index) / 15;
 105                         break;
 106                     default:
 107                         note_timbre = 0;
 108                         break;
 109                 }
 110
 111             } else if (frequency < 640.0) {
 112
 113                 // Closed Hi-hat: 3 - 5 KHz
 114                 frequency = (rand() % (int)(2000)) + 3000;
 115                 switch (envelope_index) {
 116                     case 0 ... 15:
 117                         note_timbre = 0.5;
 118                         break;
 119                     case 16 ... 20:
 120                         note_timbre = 0.5 * (21 - envelope_index) / 5;
 121                         break;
 122                     default:
 123                         note_timbre = 0;
 124                         break;
 125                 }
 126
 127             } else if (frequency < 1280.0) {
 128
 129                 // Open Hi-hat: 3 - 5 KHz
 130                 frequency = (rand() % (int)(2000)) + 3000;
 131                 switch (envelope_index) {
 132                     case 0 ... 35:
 133                         note_timbre = 0.5;
 134                         break;
 135                     case 36 ... 50:
 136                         note_timbre = 0.5 * (51 - envelope_index) / 15;
 137                         break;
 138                     default:
 139                         note_timbre = 0;
 140                         break;
 141                 }
 142
 143             }
 144             break;
 145         case butts_fader:
 146             glissando = true;
 147             polyphony_rate = 0;
 148             switch (compensated_index) {
 149                 case 0 ... 9:
 150                     frequency = frequency / 4;
 151                     note_timbre = TIMBRE_12;
 152                         break;
 153
 154                 case 10 ... 19:
 155                     frequency = frequency / 2;
 156                     note_timbre = TIMBRE_12;
 157                         break;
 158
 159                 case 20 ... 200:
 160                     note_timbre = .125 - pow(((float)compensated_index - 20) / (200 - 20), 2)*.125;
 161                         break;
 162
 163                 default:
 164                     note_timbre = 0;
 165                         break;
 166             }
 167             break;
 168
 169         // case octave_crunch:
 170         //     polyphony_rate = 0;
 171         //     switch (compensated_index) {
 172         //         case 0 ... 9:
 173         //         case 20 ... 24:
 174         //         case 30 ... 32:
 175         //             frequency = frequency / 2;
 176         //             note_timbre = TIMBRE_12;
 177         //         break;
 178
 179         //         case 10 ... 19:
 180         //         case 25 ... 29:
 181         //         case 33 ... 35:
 182         //             frequency = frequency * 2;
 183         //             note_timbre = TIMBRE_12;
 184                //          break;
 185
 186         //         default:
 187         //             note_timbre = TIMBRE_12;
 188         //              break;
 189         //     }
 190                //  break;
 191
 192         case duty_osc:
 193             // This slows the loop down a substantial amount, so higher notes may freeze
 194             glissando = true;
 195             polyphony_rate = 0;
 196             switch (compensated_index) {
 197                 default:
 198                     #define OCS_SPEED 10
 199                     #define OCS_AMP   .25
 200                     // sine wave is slow
 201                     // note_timbre = (sin((float)compensated_index/10000*OCS_SPEED) * OCS_AMP / 2) + .5;
 202                     // triangle wave is a bit faster
 203                     note_timbre = (float)abs((compensated_index*OCS_SPEED % 3000) - 1500) * ( OCS_AMP / 1500 ) + (1 - OCS_AMP) / 2;
 204                         break;
 205             }
 206                 break;
 207
 208         case duty_octave_down:
 209             glissando = true;
 210             polyphony_rate = 0;
 211             note_timbre = (envelope_index % 2) * .125 + .375 * 2;
 212             if ((envelope_index % 4) == 0)
 213                 note_timbre = 0.5;
 214             if ((envelope_index % 8) == 0)
 215                 note_timbre = 0;
 216             break;
 217         case delayed_vibrato:
 218             glissando = true;
 219             polyphony_rate = 0;
 220             note_timbre = TIMBRE_50;
 221             #define VOICE_VIBRATO_DELAY 150
 222             #define VOICE_VIBRATO_SPEED 50
 223             switch (compensated_index) {
 224                 case 0 ... VOICE_VIBRATO_DELAY:
 225                     break;
 226                 default:
 227                     frequency = frequency * vibrato_lut[(int)fmod((((float)compensated_index - (VOICE_VIBRATO_DELAY + 1))/1000*VOICE_VIBRATO_SPEED), VIBRATO_LUT_LENGTH)];
 228                     break;
 229             }
 230             break;
 231         // case delayed_vibrato_octave:
 232         //     polyphony_rate = 0;
 233         //     if ((envelope_index % 2) == 1) {
 234         //         note_timbre = 0.55;
 235         //     } else {
 236         //         note_timbre = 0.45;
 237         //     }
 238         //     #define VOICE_VIBRATO_DELAY 150
 239         //     #define VOICE_VIBRATO_SPEED 50
 240         //     switch (compensated_index) {
 241         //         case 0 ... VOICE_VIBRATO_DELAY:
 242         //             break;
 243         //         default:
 244         //             frequency = frequency * VIBRATO_LUT[(int)fmod((((float)compensated_index - (VOICE_VIBRATO_DELAY + 1))/1000*VOICE_VIBRATO_SPEED), VIBRATO_LUT_LENGTH)];
 245         //             break;
 246         //     }
 247         //     break;
 248         // case duty_fifth_down:
 249         //     note_timbre = 0.5;
 250         //     if ((envelope_index % 3) == 0)
 251         //         note_timbre = 0.75;
 252         //     break;
 253         // case duty_fourth_down:
 254         //     note_timbre = 0.0;
 255         //     if ((envelope_index % 12) == 0)
 256         //         note_timbre = 0.75;
 257         //     if (((envelope_index % 12) % 4) != 1)
 258         //         note_timbre = 0.75;
 259         //     break;
 260         // case duty_third_down:
 261         //     note_timbre = 0.5;
 262         //     if ((envelope_index % 5) == 0)
 263         //         note_timbre = 0.75;
 264         //     break;
 265         // case duty_fifth_third_down:
 266         //     note_timbre = 0.5;
 267         //     if ((envelope_index % 5) == 0)
 268         //         note_timbre = 0.75;
 269         //     if ((envelope_index % 3) == 0)
 270         //         note_timbre = 0.25;
 271         //     break;
 272
 273     #endif
 274
 275                 default:
 276                         break;
 277     }
 278
 279     return frequency;
 280 }