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