src/mdaPiano.cpp

   1 /* ==================================================
   2  * LV2 port of the famous mda Piano VSTi
   3  * ==================================================
   4  *
   5  * Port
   6  *   Author:    Ricardo Wurmus (rekado)
   7  *   Based on:  mda-vst-src-2010-02-14.zip
   8  *
   9  * mda Piano v1.0
  10  *   Copyright(c)1999-2000 Paul Kellett (maxim digital audio)
  11  *   Based on VST2 SDK (c)1996-1999 Steinberg Soft und Hardware GmbH, All Rights Reserved
  12  *
  13  * ==================================================
  14  */
  15
  16 #include "mdaPianoCommon.h"
  17 #include "mdaPiano.h"
  18 #include <cstdlib> //for exit
  19
  20 #include <stdio.h>
  21 #include <math.h>
  22
  23 #define STRING_BUF 2048
  24 static const char* sample_file = "samples.raw";
  25
  26
  27 mdaPiano::mdaPiano(double rate)
  28   : LV2::Synth<mdaPianoVoice, mdaPiano>(p_n_ports, p_midi) {
  29
  30   cmax = 0x7F;  //just in case...
  31
  32   load_samples(&waves);
  33   load_kgrp(kgrp);
  34
  35   for(uint32_t i=0; i<NVOICES; ++i) {
  36     voices[i] = new mdaPianoVoice(rate, waves, kgrp);
  37     add_voices(voices[i]);
  38   }
  39
  40   notes[0] = EVENTS_DONE;
  41   sustain = activevoices = 0;
  42
  43   update();
  44 }
  45
  46 //parameter change
  47 void mdaPiano::update() {
  48   for (uint32_t v=0; v<NVOICES; ++v) {
  49     voices[v]->update(Current);
  50   }
  51 }
  52
  53
  54 unsigned mdaPiano::find_free_voice(unsigned char key, unsigned char velocity) {
  55   //is this a retriggered note during sustain?
  56   if (sustain) {
  57     for (unsigned i = 0; i < NVOICES; ++i) {
  58       if ((voices[i]->get_key() == key) && (voices[i]->is_sustained()))
  59         return i;
  60     }
  61   }
  62
  63   //take the next free voice if
  64   // ... notes are sustained but not this new one
  65   // ... notes are not sustained
  66   for (unsigned i = 0; i < NVOICES; ++i) {
  67     if (voices[i]->get_key() == LV2::INVALID_KEY)
  68     {
  69       return i;
  70     }
  71   }
  72
  73   //TODO: steal quietest note if all voices are used up
  74   return 0;
  75 }
  76
  77
  78 void mdaPiano::setVolume(float value)
  79 {
  80   for (uint32_t v=0; v<NVOICES; ++v)
  81     voices[v]->set_volume(value);
  82 }
  83
  84
  85 void mdaPiano::setParameter(unsigned char id, float value)
  86 {
  87   if(id>=NPARAMS)
  88     return;
  89   *p(id+PARAM_OFFSET) = value;
  90   update();
  91 #ifdef DEBUG
  92   printf("changed %i to %f\n", id, value);
  93 #endif
  94 }
  95
  96
  97 void mdaPiano::handle_midi(uint32_t size, unsigned char* data) {
  98 #ifdef DEBUG
  99   printf("%d\n", data[1]);
 100 #endif
 101
 102   //discard invalid midi messages
 103   if (size != 3)
 104     return;
 105
 106   //receive on all channels
 107   switch(data[0] & 0xf0)
 108   {
 109     case 0x80: //note off
 110       for (unsigned i = 0; i < NVOICES; ++i) {
 111         if (voices[i]->get_key() == data[1]) {
 112           voices[i]->release(data[2]);
 113           break;
 114         }
 115       }
 116       break;
 117
 118     case 0x90: //note on
 119       {
 120         unsigned int v = find_free_voice(data[1], data[2]);
 121         if (v < NVOICES) {
 122           voices[v]->on(data[1], data[2]);
 123         }
 124         break;
 125       }
 126
 127     case 0xB0: //controller
 128       switch(data[1])
 129       {
 130         case 0x01:  //mod wheel
 131         case 0x43:  //soft pedal
 132           {
 133             float muff = 0.01f * (float)((127 - data[2]) * (127 - data[2]));
 134             for (unsigned i = 0; i < NVOICES; ++i) {
 135               voices[i]->set_muff(muff);
 136             }
 137             break;
 138           }
 139
 140         case 0x07:  //volume
 141           setVolume(0.00002f * (float)(data[2] * data[2]));
 142           break;
 143
 144         case 0x40:  //sustain pedal
 145         case 0x42:  //sustenuto pedal
 146           sustain = data[2] & 0x40;
 147           if(sustain==0)
 148           {
 149             notes[npos++] = SUSTAIN; //end all sustained notes
 150             notes[npos++] = 0;
 151           }
 152           break;
 153
 154         //all sound off
 155         case 0x78:
 156         //all notes off
 157         case 0x7b:
 158         default:
 159           for(short v=0; v<NVOICES; v++) {
 160             voices[v]->reset();
 161           }
 162           break;
 163       }
 164       break;
 165
 166     default: break;
 167   }
 168 }
 169
 170
 171 // TODO: load this from a file
 172 void mdaPiano::load_kgrp(KGRP *kgrp)
 173 {
 174   //Waveform data and keymapping is hard-wired in *this* version
 175   kgrp[ 0].root = 36;  kgrp[ 0].high = 37;  kgrp[ 0].pos = 0;       kgrp[ 0].end = 36275;   kgrp[ 0].loop = 14774;
 176   kgrp[ 1].root = 40;  kgrp[ 1].high = 41;  kgrp[ 1].pos = 36278;   kgrp[ 1].end = 83135;   kgrp[ 1].loop = 16268;
 177   kgrp[ 2].root = 43;  kgrp[ 2].high = 45;  kgrp[ 2].pos = 83137;   kgrp[ 2].end = 146756;  kgrp[ 2].loop = 33541;
 178   kgrp[ 3].root = 48;  kgrp[ 3].high = 49;  kgrp[ 3].pos = 146758;  kgrp[ 3].end = 204997;  kgrp[ 3].loop = 21156;
 179   kgrp[ 4].root = 52;  kgrp[ 4].high = 53;  kgrp[ 4].pos = 204999;  kgrp[ 4].end = 244908;  kgrp[ 4].loop = 17191;
 180   kgrp[ 5].root = 55;  kgrp[ 5].high = 57;  kgrp[ 5].pos = 244910;  kgrp[ 5].end = 290978;  kgrp[ 5].loop = 23286;
 181   kgrp[ 6].root = 60;  kgrp[ 6].high = 61;  kgrp[ 6].pos = 290980;  kgrp[ 6].end = 342948;  kgrp[ 6].loop = 18002;
 182   kgrp[ 7].root = 64;  kgrp[ 7].high = 65;  kgrp[ 7].pos = 342950;  kgrp[ 7].end = 391750;  kgrp[ 7].loop = 19746;
 183   kgrp[ 8].root = 67;  kgrp[ 8].high = 69;  kgrp[ 8].pos = 391752;  kgrp[ 8].end = 436915;  kgrp[ 8].loop = 22253;
 184   kgrp[ 9].root = 72;  kgrp[ 9].high = 73;  kgrp[ 9].pos = 436917;  kgrp[ 9].end = 468807;  kgrp[ 9].loop = 8852;
 185   kgrp[10].root = 76;  kgrp[10].high = 77;  kgrp[10].pos = 468809;  kgrp[10].end = 492772;  kgrp[10].loop = 9693;
 186   kgrp[11].root = 79;  kgrp[11].high = 81;  kgrp[11].pos = 492774;  kgrp[11].end = 532293;  kgrp[11].loop = 10596;
 187   kgrp[12].root = 84;  kgrp[12].high = 85;  kgrp[12].pos = 532295;  kgrp[12].end = 560192;  kgrp[12].loop = 6011;
 188   kgrp[13].root = 88;  kgrp[13].high = 89;  kgrp[13].pos = 560194;  kgrp[13].end = 574121;  kgrp[13].loop = 3414;
 189   kgrp[14].root = 93;  kgrp[14].high = 999; kgrp[14].pos = 574123;  kgrp[14].end = 586343;  kgrp[14].loop = 2399;
 190 }
 191
 192
 193 void mdaPiano::load_samples(short **buffer)
 194 {
 195   FILE *f;
 196   long num, size;
 197   char filepath[STRING_BUF];
 198
 199   strncpy(filepath, bundle_path(), STRING_BUF);
 200   strncat(filepath,
 201           sample_file,
 202           STRING_BUF - strlen(filepath));
 203   f = fopen(filepath, "rb");
 204   if (f == NULL) {
 205     fputs("File error", stderr);
 206     exit(1);
 207   }
 208
 209   // obtain file size
 210   fseek(f, 0, SEEK_END);
 211   size = ftell(f);
 212   rewind(f);
 213
 214   // allocate memory to contain the whole file
 215   *buffer = (short*) malloc (sizeof(short)*size);
 216   if (*buffer == NULL) {
 217     fputs("Memory error", stderr);
 218     exit(2);
 219   }
 220
 221   // copy the file into the buffer
 222   num = fread(*buffer, 1, size, f);
 223   if (num != size) {
 224     fputs ("Reading error", stderr);
 225     exit (3);
 226   }
 227   fclose (f);
 228   return;
 229 }