Changeset 4215


Ignore:
Timestamp:
2012-04-20 11:52:14 (2 years ago)
Author:
drobilla
Message:

Make instrument plugins work.

Location:
trunk/plugins/mda.lv2
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • trunk/plugins/mda.lv2/lvz/audioeffectx.h

    r4128 r4215  
    2222#include <stdint.h> 
    2323#include <string.h> 
     24 
     25#include "lv2/lv2plug.in/ns/ext/atom/atom.h" 
     26#include "lv2/lv2plug.in/ns/ext/urid/urid.h" 
    2427 
    2528class AudioEffect; 
     
    7679        : URI("NIL") 
    7780        , uniqueID("NIL") 
     81        , eventInput(NULL) 
    7882        , sampleRate(44100) 
    7983        , curProgram(0) 
     
    8589    } 
    8690 
    87     virtual void process         (float **inputs, float **outputs, int32_t nframes) = 0; 
     91    virtual void process         (float **inputs, float **outputs, int32_t nframes) {} 
    8892    virtual void processReplacing(float **inputs, float **outputs, int32_t nframes) = 0; 
     93 
     94    void setMidiEventType(LV2_URID urid) { midiEventType = urid; } 
     95    void setEventInput(const LV2_Atom_Sequence* seq) { eventInput = seq; } 
    8996 
    9097    virtual int32_t processEvents(LvzEvents* ev) { return 0; } 
     
    100107    virtual bool getProductString(char* text)                 = 0; 
    101108 
    102     virtual bool canHostDo(const char* act) { return false; } 
    103     virtual void canMono()                  {} 
    104     virtual void canProcessReplacing()      {} 
    105     virtual void isSynth()                  {} 
    106     virtual void wantEvents()               {} 
     109    virtual int32_t canDo(const char* text) { return false; } 
     110    virtual bool    canHostDo(const char* act) { return false; } 
     111    virtual void    canMono()                  {} 
     112    virtual void    canProcessReplacing()      {} 
     113    virtual void    isSynth()                  {} 
     114    virtual void    wantEvents()               {} 
    107115 
    108116    virtual void setBlockSize(int32_t size)  {} 
     
    122130 
    123131protected: 
    124     const char* URI; 
    125     const char* uniqueID; 
    126     float       sampleRate; 
    127     int32_t     curProgram; 
    128     int32_t     numInputs; 
    129     int32_t     numOutputs; 
    130     int32_t     numParams; 
    131     int32_t     numPrograms; 
     132    const char*              URI; 
     133    const char*              uniqueID; 
     134    const LV2_Atom_Sequence* eventInput; 
     135    LV2_URID                 midiEventType; 
     136    float                    sampleRate; 
     137    int32_t                  curProgram; 
     138    int32_t                  numInputs; 
     139    int32_t                  numOutputs; 
     140    int32_t                  numParams; 
     141    int32_t                  numPrograms; 
    132142}; 
    133143 
  • trunk/plugins/mda.lv2/lvz/wrapper.cpp

    r4157 r4215  
    3333#include "audioeffectx.h" 
    3434#include "lv2.h" 
     35#include "lv2/lv2plug.in/ns/ext/atom/atom.h" 
     36#include "lv2/lv2plug.in/ns/ext/midi/midi.h" 
     37#include "lv2/lv2plug.in/ns/ext/urid/urid.h" 
    3538#include PLUGIN_HEADER 
    3639 
     
    6265lvz_connect_port(LV2_Handle instance, uint32_t port, void* data) 
    6366{ 
    64     LVZPlugin* plugin = (LVZPlugin*)instance; 
    65  
    66     uint32_t num_params = plugin->effect->getNumParameters(); 
    67     uint32_t num_inputs = plugin->effect->getNumInputs(); 
     67    LVZPlugin*     plugin      = (LVZPlugin*)instance; 
     68    const uint32_t num_params  = plugin->effect->getNumParameters(); 
     69    const uint32_t num_inputs  = plugin->effect->getNumInputs(); 
     70    const uint32_t num_outputs = plugin->effect->getNumOutputs(); 
    6871 
    6972    if (port < num_params) { 
     
    7174    } else if (port < num_params + num_inputs) { 
    7275        plugin->inputs[port - num_params] = (float*)data; 
    73     } else { 
     76    } else if (port < num_params + num_inputs + num_outputs) { 
    7477        plugin->outputs[port - num_params - num_inputs] = (float*)data; 
     78    } else if (port == num_params + num_inputs + num_outputs) { 
     79        plugin->effect->setEventInput((LV2_Atom_Sequence*)data); 
    7580    } 
    7681} 
     
    98103    LVZPlugin* plugin = (LVZPlugin*)malloc(sizeof(LVZPlugin)); 
    99104    plugin->effect = effect; 
     105 
     106    for (int i = 0; features[i]; ++i) { 
     107        if (!strcmp(features[i]->URI, LV2_URID__map)) { 
     108            LV2_URID_Map* map = (LV2_URID_Map*)features[i]->data; 
     109            plugin->effect->setMidiEventType( 
     110                map->map(map->handle, LV2_MIDI__MidiEvent)); 
     111            break; 
     112        } 
     113    } 
    100114 
    101115    if (num_params > 0) { 
  • trunk/plugins/mda.lv2/mda.lv2/DX10.ttl

    r4188 r4215  
     1@prefix atom: <http://lv2plug.in/ns/ext/atom#> . 
    12@prefix doap: <http://usefulinc.com/ns/doap#> . 
    23@prefix lv2: <http://lv2plug.in/ns/lv2core#> . 
     
    2021    doap:license <http://usefulinc.com/doap/licenses/gpl> ; 
    2122    lv2:optionalFeature lv2:hardRTCapable ; 
     23    lv2:requiredFeature <http://lv2plug.in/ns/ext/urid#map> ; 
    2224    pg:mainInput mda:mainIn ; 
    2325    pg:mainOutput mda:mainOut ; 
    24     rdfs:comment """Sounds similar to the later Yamaha DX synths including the heavy bass but with a warmer, cleaner tone.  This plug-in is 8-voice polyphonic.""" ; 
     26    rdfs:comment "Sounds similar to the later Yamaha DX synths including the heavy bass but with a warmer, cleaner tone.  This plug-in is 8-voice polyphonic." ; 
    2527    lv2:port [ 
    2628        a lv2:InputPort , 
     
    189191        lv2:designation pg:right ; 
    190192        pg:group mda:mainOut 
     193    ] , [ 
     194        a lv2:InputPort , 
     195            atom:AtomPort ; 
     196        atom:bufferType atom:Sequence ; 
     197        atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent> ; 
     198        lv2:index 18 ; 
     199        lv2:symbol "event_in" ; 
     200        lv2:name "Event In" 
    191201    ] . 
  • trunk/plugins/mda.lv2/mda.lv2/EPiano.ttl

    r4214 r4215  
     1@prefix atom: <http://lv2plug.in/ns/ext/atom#> . 
    12@prefix doap: <http://usefulinc.com/ns/doap#> . 
    23@prefix lv2: <http://lv2plug.in/ns/lv2core#> . 
     
    1213    doap:license <http://usefulinc.com/doap/licenses/gpl> ; 
    1314    lv2:optionalFeature lv2:hardRTCapable ; 
     15    lv2:requiredFeature <http://lv2plug.in/ns/ext/urid#map> ; 
    1416    pg:mainInput mda:mainIn ; 
    1517    pg:mainOutput mda:mainOut ; 
     
    9092            lv2:ControlPort ; 
    9193        lv2:index 8 ; 
    92         lv2:name "Polyphony" ; 
    93         lv2:symbol "polyphony" ; 
    94         lv2:default 0.5 ; 
     94        lv2:name "Polyphonic" ; 
     95        lv2:symbol "polyphonic" ; 
     96        lv2:default 1.0 ; 
    9597        lv2:minimum 0.0 ; 
    96         lv2:maximum 1.0 
     98        lv2:maximum 1.0 ; 
     99        lv2:portProperty lv2:toggled 
    97100    ] , [ 
    98101        a lv2:InputPort , 
     
    138141        lv2:designation pg:right ; 
    139142        pg:group mda:mainOut 
     143    ] , [ 
     144        a lv2:InputPort , 
     145            atom:AtomPort ; 
     146        atom:bufferType atom:Sequence ; 
     147        atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent> ; 
     148        lv2:index 14 ; 
     149        lv2:symbol "event_in" ; 
     150        lv2:name "Event In" 
    140151    ] . 
  • trunk/plugins/mda.lv2/mda.lv2/JX10.ttl

    r4188 r4215  
     1@prefix atom: <http://lv2plug.in/ns/ext/atom#> . 
    12@prefix doap: <http://usefulinc.com/ns/doap#> . 
    23@prefix lv2: <http://lv2plug.in/ns/lv2core#> . 
     
    2425    lv2:project mda: ; 
    2526    lv2:symbol "JX10" ; 
    26     doap:name "MDA JX10 Synth" ; 
     27    doap:name "MDA JX10" ; 
    2728    doap:license <http://usefulinc.com/doap/licenses/gpl> ; 
    2829    lv2:optionalFeature lv2:hardRTCapable ; 
     30    lv2:requiredFeature <http://lv2plug.in/ns/ext/urid#map> ; 
    2931    pg:mainInput mda:mainIn ; 
    3032    pg:mainOutput mda:mainOut ; 
     
    298300        lv2:designation pg:right ; 
    299301        pg:group mda:mainOut 
     302    ] , [ 
     303        a lv2:InputPort , 
     304            atom:AtomPort ; 
     305        atom:bufferType atom:Sequence ; 
     306        atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent> ; 
     307        lv2:index 26 ; 
     308        lv2:symbol "event_in" ; 
     309        lv2:name "Event In" 
    300310    ] . 
  • trunk/plugins/mda.lv2/mda.lv2/Piano.ttl

    r4214 r4215  
     1@prefix atom: <http://lv2plug.in/ns/ext/atom#> . 
    12@prefix doap: <http://usefulinc.com/ns/doap#> . 
    23@prefix lv2: <http://lv2plug.in/ns/lv2core#> . 
     
    2021    doap:license <http://usefulinc.com/doap/licenses/gpl> ; 
    2122    lv2:optionalFeature lv2:hardRTCapable ; 
     23    lv2:requiredFeature <http://lv2plug.in/ns/ext/urid#map> ; 
    2224    pg:mainInput mda:mainIn ; 
    2325    pg:mainOutput mda:mainOut ; 
     
    153155        lv2:designation pg:right ; 
    154156        pg:group mda:mainOut 
     157    ] , [ 
     158        a lv2:InputPort , 
     159            atom:AtomPort ; 
     160        atom:bufferType atom:Sequence ; 
     161        atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent> ; 
     162        lv2:index 14 ; 
     163        lv2:symbol "event_in" ; 
     164        lv2:name "Event In" 
    155165    ] . 
  • trunk/plugins/mda.lv2/src/mdaDX10.cpp

    r4127 r4215  
    1818 
    1919#include "mdaDX10.h" 
     20 
     21#include "lv2/lv2plug.in/ns/ext/atom/util.h" 
    2022 
    2123#include <stdio.h> 
     
    9193    voice[i].cdec = 0.99f; //all notes off 
    9294  } 
    93   notes[0] = EVENTS_DONE; 
    9495  lfo0 = dlfo = modwhl = 0.0f; 
    9596  lfo1 = pbend = 1.0f; 
     
    241242 
    242243 
    243 int32_t mdaDX10::canDo(char* text) 
     244int32_t mdaDX10::canDo(const char* text) 
    244245{ 
    245246  if(strcmp(text, "receiveLvzEvents") == 0) return 1; 
     
    305306} 
    306307 
    307  
    308 void mdaDX10::process(float **inputs, float **outputs, int32_t sampleFrames) 
     308void mdaDX10::processReplacing(float **inputs, float **outputs, int32_t sampleFrames) 
    309309{ 
    310310    float* out1 = outputs[0]; 
    311311    float* out2 = outputs[1]; 
    312     int32_t event=0, frame=0, frames, v; 
     312    int32_t frame=0, frames, v; 
    313313  float o, x, e, mw=MW, w=rich, m=modmix; 
    314314  int32_t k=K; 
    315315 
    316   if(activevoices>0 || notes[event]<sampleFrames) //detect & bypass completely empty blocks 
     316  LV2_Atom_Event* ev = lv2_atom_sequence_begin(&eventInput->body); 
     317  bool end = lv2_atom_sequence_is_end(&eventInput->body, eventInput->atom.size, ev); 
     318  if(activevoices>0 || !end) //detect & bypass completely empty blocks 
    317319  { 
    318320    while(frame<sampleFrames) 
    319321    { 
    320       frames = notes[event++]; 
    321       if(frames>sampleFrames) frames = sampleFrames; 
     322      end = lv2_atom_sequence_is_end(&eventInput->body, eventInput->atom.size, ev); 
     323      frames = end ? sampleFrames : ev->time.frames; 
    322324      frames -= frame; 
    323325      frame += frames; 
     
    355357            o += V->cenv * (m * V->mod1 + (x + x * x * x * (w * x * x - 1.0f - w))); 
    356358          }      //amp env //mod thru-mix //5th-order sine approximation 
     359 
     360         ///  xx = x * x; 
     361         ///  x + x + x * xx * (xx - 3.0f); 
     362 
    357363          V++; 
    358364        } 
    359         *out1++ += o; 
    360         *out2++ += o; 
     365        *out1++ = o; 
     366        *out2++ = o; 
    361367      } 
    362368 
    363       if(frame<sampleFrames) //next note on/off 
     369      if(!end) //next note on/off 
    364370      { 
    365         int32_t note = notes[event++]; 
    366         int32_t vel  = notes[event++]; 
    367         noteOn(note, vel); 
     371        processEvent(ev); 
     372        ev = lv2_atom_sequence_next(ev); 
    368373      } 
    369374    } 
     
    380385    } 
    381386  } 
    382  
    383   K=k; MW=mw; //remember these so vibrato speed not buffer size dependant! 
    384   notes[0] = EVENTS_DONE; 
    385 } 
    386  
    387  
    388 void mdaDX10::processReplacing(float **inputs, float **outputs, int32_t sampleFrames) 
    389 { 
    390     float* out1 = outputs[0]; 
    391     float* out2 = outputs[1]; 
    392     int32_t event=0, frame=0, frames, v; 
    393   float o, x, e, mw=MW, w=rich, m=modmix; 
    394   int32_t k=K; 
    395  
    396   if(activevoices>0 || notes[event]<sampleFrames) //detect & bypass completely empty blocks 
    397   { 
    398     while(frame<sampleFrames) 
    399     { 
    400       frames = notes[event++]; 
    401       if(frames>sampleFrames) frames = sampleFrames; 
    402       frames -= frame; 
    403       frame += frames; 
    404  
    405       while(--frames>=0)  //would be faster with voice loop outside frame loop! 
    406       {                   //but then each voice would need it's own LFO... 
    407         VOICE *V = voice; 
    408         o = 0.0f; 
    409  
    410         if(--k<0) 
    411         { 
    412           lfo0 += dlfo * lfo1; //sine LFO 
    413           lfo1 -= dlfo * lfo0; 
    414           mw = lfo1 * (modwhl + vibrato); 
    415           k=100; 
    416         } 
    417  
    418         for(v=0; v<NVOICES; v++) //for each voice 
    419         { 
    420           e = V->env; 
    421           if(e > SILENCE) //**** this is the synth **** 
    422           { 
    423             V->env = e * V->cdec; //decay & release 
    424             V->cenv += V->catt * (e - V->cenv); //attack 
    425  
    426             x = V->dmod * V->mod0 - V->mod1; //could add more modulator blocks like 
    427             V->mod1 = V->mod0;               //this for a wider range of FM sounds 
    428             V->mod0 = x; 
    429             V->menv += V->mdec * (V->mlev - V->menv); 
    430  
    431             x = V->car + V->dcar + x * V->menv + mw; //carrier phase 
    432             while(x >  1.0f) x -= 2.0f;  //wrap phase 
    433             while(x < -1.0f) x += 2.0f; 
    434             V->car = x; 
    435             o += V->cenv * (m * V->mod1 + (x + x * x * x * (w * x * x - 1.0f - w))); 
    436           }      //amp env //mod thru-mix //5th-order sine approximation 
    437  
    438          ///  xx = x * x; 
    439          ///  x + x + x * xx * (xx - 3.0f); 
    440  
    441           V++; 
    442         } 
    443         *out1++ = o; 
    444         *out2++ = o; 
    445       } 
    446  
    447       if(frame<sampleFrames) //next note on/off 
    448       { 
    449         int32_t note = notes[event++]; 
    450         int32_t vel  = notes[event++]; 
    451         noteOn(note, vel); 
    452       } 
    453     } 
    454  
    455     activevoices = NVOICES; 
    456     for(v=0; v<NVOICES; v++) 
    457     { 
    458       if(voice[v].env < SILENCE)  //choke voices that have finished 
    459       { 
    460         voice[v].env = voice[v].cenv = 0.0f; 
    461         activevoices--; 
    462       } 
    463       if(voice[v].menv < SILENCE) voice[v].menv = voice[v].mlev = 0.0f; 
    464     } 
    465   } 
    466387  else //completely empty block 
    467388  { 
     
    473394  } 
    474395  K=k; MW=mw; //remember these so vibrato speed not buffer size dependant! 
    475   notes[0] = EVENTS_DONE; 
    476396} 
    477397 
     
    529449 
    530450 
    531 int32_t mdaDX10::processEvents(LvzEvents* ev) 
    532 { 
    533   int32_t npos=0; 
    534  
    535   for (int32_t i=0; i<ev->numEvents; i++) 
    536     { 
    537         if((ev->events[i])->type != kLvzMidiType) continue; 
    538         LvzMidiEvent* event = (LvzMidiEvent*)ev->events[i]; 
    539         char* midiData = event->midiData; 
     451int32_t mdaDX10::processEvent(const LV2_Atom_Event* ev) 
     452{ 
     453  if (ev->body.type != midiEventType) 
     454      return 0; 
     455 
     456  const uint8_t* midiData = (const uint8_t*)LV2_ATOM_BODY(&ev->body); 
    540457 
    541458    switch(midiData[0] & 0xf0) //status byte (all channels) 
    542459    { 
    543460      case 0x80: //note off 
    544         notes[npos++] = event->deltaFrames; //delta 
    545         notes[npos++] = midiData[1] & 0x7F; //note 
    546         notes[npos++] = 0;                  //vel 
     461        noteOn(midiData[1] & 0x7F, 0); 
    547462        break; 
    548463 
    549464      case 0x90: //note on 
    550         notes[npos++] = event->deltaFrames; //delta 
    551         notes[npos++] = midiData[1] & 0x7F; //note 
    552         notes[npos++] = midiData[2] & 0x7F; //vel 
     465        noteOn(midiData[1] & 0x7F, midiData[2] & 0x7F); 
    553466        break; 
    554467 
     
    568481            if(sustain==0) 
    569482            { 
    570               notes[npos++] = event->deltaFrames; 
    571               notes[npos++] = SUSTAIN; //end all sustained notes 
    572               notes[npos++] = 0; 
     483              noteOn(SUSTAIN, 0); 
    573484            } 
    574485            break; 
     
    597508    } 
    598509 
    599     if(npos>EVENTBUFFER) npos -= 3; //discard events if buffer full!! 
    600     event++; 
    601     } 
    602   notes[npos] = EVENTS_DONE; 
    603510    return 1; 
    604511} 
  • trunk/plugins/mda.lv2/src/mdaDX10.h

    r4127 r4215  
    6363    ~mdaDX10(); 
    6464 
    65     virtual void process(float **inputs, float **outputs, int32_t sampleframes); 
    6665    virtual void processReplacing(float **inputs, float **outputs, int32_t sampleframes); 
    67     virtual int32_t processEvents(LvzEvents* events); 
    6866 
    6967    virtual void setProgram(int32_t program); 
     
    8684    virtual bool getProductString (char* text); 
    8785    virtual int32_t getVendorVersion () {return 1;} 
    88     virtual int32_t canDo (char* text); 
     86    virtual int32_t canDo (const char* text); 
    8987 
    9088    virtual int32_t getNumMidiInputChannels ()  { return 1; } 
    9189 
    9290private: 
     91    int32_t processEvent(const LV2_Atom_Event* ev); 
    9392    void update();  //my parameter update 
    9493  void noteOn(int32_t note, int32_t velocity); 
     
    10099  mdaDX10Program* programs; 
    101100  float Fs; 
    102  
    103   #define EVENTBUFFER 120 
    104   #define EVENTS_DONE 99999999 
    105   int32_t notes[EVENTBUFFER + 8];  //list of delta|note|velocity for current block 
    106101 
    107102  ///global internal variables 
  • trunk/plugins/mda.lv2/src/mdaEPiano.cpp

    r4127 r4215  
    1919#include "mdaEPianoData.h" 
    2020#include "mdaEPiano.h" 
     21 
     22#include "lv2/lv2plug.in/ns/ext/atom/util.h" 
    2123 
    2224#include <stdio.h> 
     
    133135    voice[v].dec = 0.99f; //all notes off 
    134136  } 
    135   notes[0] = EVENTS_DONE; 
    136137  volume = 0.2f; 
    137138  muff = 160.0f; 
     
    264265 
    265266 
    266 int32_t mdaEPiano::canDo(char* text) 
     267int32_t mdaEPiano::canDo(const char* text) 
    267268{ 
    268269  if(strcmp(text, "receiveLvzEvents") == 0) return 1; 
     
    345346 
    346347 
    347 void mdaEPiano::process(float **inputs, float **outputs, int32_t sampleFrames) 
     348void mdaEPiano::processReplacing(float **inputs, float **outputs, int32_t sampleFrames) 
    348349{ 
    349350    float* out0 = outputs[0]; 
    350351    float* out1 = outputs[1]; 
    351     int32_t event=0, frame=0, frames, v; 
     352    int32_t frame=0, frames, v; 
    352353  float x, l, r, od=overdrive; 
    353354  int32_t i; 
    354355 
     356  LV2_Atom_Event* ev = lv2_atom_sequence_begin(&eventInput->body); 
    355357  while(frame<sampleFrames) 
    356358  { 
    357     frames = notes[event++]; 
    358     if(frames>sampleFrames) frames = sampleFrames; 
    359     frames -= frame; 
    360     frame += frames; 
    361  
    362     while(--frames>=0) 
    363     { 
    364       VOICE *V = voice; 
    365       l = r = 0.0f; 
    366  
    367       for(v=0; v<activevoices; v++) 
    368       { 
    369         V->frac += V->delta;  //integer-based linear interpolation 
    370         V->pos += V->frac >> 16; 
    371         V->frac &= 0xFFFF; 
    372         if(V->pos > V->end) V->pos -= V->loop; 
    373         i = waves[V->pos]; 
    374         i = (i << 7) + (V->frac >> 9) * (waves[V->pos + 1] - i) + 0x40400000; 
    375         x = V->env * (*(float *)&i - 3.0f);  //fast int->float 
    376         V->env = V->env * V->dec;  //envelope 
    377  
    378         if(x>0.0f) { x -= od * x * x;  if(x < -V->env) x = -V->env; } //+= 0.5f * x * x; } //overdrive 
    379  
    380         l += V->outl * x; 
    381         r += V->outr * x; 
    382  
    383         V++; 
    384       } 
    385       tl += tfrq * (l - tl);  //treble boost 
    386       tr += tfrq * (r - tr); 
    387       r  += treb * (r - tr); 
    388       l  += treb * (l - tl); 
    389  
    390       lfo0 += dlfo * lfo1;  //LFO for tremolo and autopan 
    391       lfo1 -= dlfo * lfo0; 
    392       l += l * lmod * lfo1; 
    393       r += r * rmod * lfo1;  //worth making all these local variables? 
    394  
    395       *out0++ += l; 
    396       *out1++ += r; 
    397     } 
    398  
    399     if(frame<sampleFrames) 
    400     { 
    401       if(activevoices == 0 && programs[curProgram].param[4] > 0.5f)  
    402         { lfo0 = -0.7071f;  lfo1 = 0.7071f; } //reset LFO phase - good idea? 
    403       int32_t note = notes[event++]; 
    404       int32_t vel  = notes[event++]; 
    405       noteOn(note, vel); 
    406     } 
    407   } 
    408   if(fabs(tl)<1.0e-10) tl = 0.0f; //anti-denormal 
    409   if(fabs(tr)<1.0e-10) tr = 0.0f; 
    410  
    411   for(v=0; v<activevoices; v++) if(voice[v].env < SILENCE) voice[v] = voice[--activevoices]; 
    412   notes[0] = EVENTS_DONE;  //mark events buffer as done 
    413 } 
    414  
    415  
    416 void mdaEPiano::processReplacing(float **inputs, float **outputs, int32_t sampleFrames) 
    417 { 
    418     float* out0 = outputs[0]; 
    419     float* out1 = outputs[1]; 
    420     int32_t event=0, frame=0, frames, v; 
    421   float x, l, r, od=overdrive; 
    422   int32_t i; 
    423  
    424   while(frame<sampleFrames) 
    425   { 
    426     frames = notes[event++]; 
    427     if(frames>sampleFrames) frames = sampleFrames; 
     359    bool end = lv2_atom_sequence_is_end(&eventInput->body, eventInput->atom.size, ev); 
     360    frames = end ? sampleFrames : ev->time.frames; 
    428361    frames -= frame; 
    429362    frame += frames; 
     
    474407      if(activevoices == 0 && programs[curProgram].param[4] > 0.5f)  
    475408        { lfo0 = -0.7071f;  lfo1 = 0.7071f; } //reset LFO phase - good idea? 
    476       int32_t note = notes[event++]; 
    477       int32_t vel  = notes[event++]; 
    478       noteOn(note, vel); 
     409 
     410      if (!end) { 
     411        processEvent(ev); 
     412        ev = lv2_atom_sequence_next(ev); 
     413      } 
     414 
    479415    } 
    480416  } 
     
    483419 
    484420  for(v=0; v<activevoices; v++) if(voice[v].env < SILENCE) voice[v] = voice[--activevoices]; 
    485   notes[0] = EVENTS_DONE;  //mark events buffer as done 
    486421} 
    487422 
     
    562497 
    563498 
    564 int32_t mdaEPiano::processEvents(LvzEvents* ev) 
     499int32_t mdaEPiano::processEvent(const LV2_Atom_Event* ev) 
    565500{ 
    566501  float * param = programs[curProgram].param; 
    567   int32_t npos=0; 
    568  
    569   for (int32_t i=0; i<ev->numEvents; i++) 
    570     { 
    571         if((ev->events[i])->type != kLvzMidiType) continue; 
    572         LvzMidiEvent* event = (LvzMidiEvent*)ev->events[i]; 
    573         char* midiData = event->midiData; 
     502 
     503  if (ev->body.type != midiEventType) 
     504      return 0; 
     505 
     506  const uint8_t* midiData = (const uint8_t*)LV2_ATOM_BODY(&ev->body); 
    574507 
    575508    switch(midiData[0] & 0xf0) //status byte (all channels) 
    576509    { 
    577510      case 0x80: //note off 
    578         notes[npos++] = event->deltaFrames; //delta 
    579         notes[npos++] = midiData[1] & 0x7F; //note 
    580         notes[npos++] = 0;                  //vel 
     511        noteOn(midiData[1] & 0x7F, 0); 
    581512        break; 
    582513 
    583514      case 0x90: //note on 
    584         notes[npos++] = event->deltaFrames; //delta 
    585         notes[npos++] = midiData[1] & 0x7F; //note 
    586         notes[npos++] = midiData[2] & 0x7F; //vel 
     515        noteOn(midiData[1] & 0x7F, midiData[2] & 0x7F); 
    587516        break; 
    588517 
     
    609538            if(sustain==0) 
    610539            { 
    611               notes[npos++] = event->deltaFrames; 
    612               notes[npos++] = SUSTAIN; //end all sustained notes 
    613               notes[npos++] = 0; 
     540              noteOn(SUSTAIN, 0); //end all sustained notes   
    614541            } 
    615542            break; 
     
    633560    } 
    634561 
    635     if(npos>EVENTBUFFER) npos -= 3; //discard events if buffer full!! 
    636     event++; //? 
    637     } 
    638   notes[npos] = EVENTS_DONE; 
    639562    return 1; 
    640563} 
  • trunk/plugins/mda.lv2/src/mdaEPiano.h

    r4127 r4215  
    7777    ~mdaEPiano(); 
    7878 
    79     virtual void process(float **inputs, float **outputs, int32_t sampleframes); 
    8079    virtual void processReplacing(float **inputs, float **outputs, int32_t sampleframes); 
    81     virtual int32_t processEvents(LvzEvents* events); 
    8280 
    8381    virtual void setProgram(int32_t program); 
     
    9997    virtual bool getProductString (char* text); 
    10098    virtual int32_t getVendorVersion () {return 1;} 
    101     virtual int32_t canDo (char* text); 
     99    virtual int32_t canDo (const char* text); 
    102100 
    103101    virtual int32_t getNumMidiInputChannels ()  { return 1; } 
     
    107105 
    108106private: 
     107    int32_t processEvent(const LV2_Atom_Event* ev); 
    109108    void update();  //my parameter update 
    110109  void noteOn(int32_t note, int32_t velocity); 
     
    114113  mdaEPianoProgram* programs; 
    115114  float Fs, iFs; 
    116  
    117   #define EVENTBUFFER 120 
    118   #define EVENTS_DONE 99999999 
    119   int32_t notes[EVENTBUFFER + 8];  //list of delta|note|velocity for current block 
    120115 
    121116  ///global internal variables 
  • trunk/plugins/mda.lv2/src/mdaJX10.cpp

    r4127 r4215  
    1818 
    1919#include "mdaJX10.h" 
     20 
     21#include "lv2/lv2plug.in/ns/ext/atom/util.h" 
    2022 
    2123#include <stdio.h> 
     
    155157    voice[v].note = 0; 
    156158  } 
    157   notes[0] = EVENTS_DONE; 
    158159  lfo = modwhl = filtwhl = press = fzip = 0.0f;  
    159160  rezwhl = pbend = ipbend = 1.0f; 
     
    333334 
    334335 
    335 int32_t mdaJX10::canDo(char* text) 
     336int32_t mdaJX10::canDo(const char* text) 
    336337{ 
    337338    if(!strcmp (text, "receiveLvzEvents")) return 1; 
     
    431432} 
    432433 
    433  
    434 void mdaJX10::process(float **inputs, float **outputs, int32_t sampleFrames) 
     434void mdaJX10::processReplacing(float **inputs, float **outputs, int32_t sampleFrames) 
    435435{ 
    436436    float* out1 = outputs[0]; 
    437437    float* out2 = outputs[1]; 
    438     int32_t event=0, frame=0, frames, v; 
     438    int32_t frame=0, frames, v; 
    439439  float o, e, vib, pwm, pb=pbend, ipb=ipbend, gl=glide; 
    440440  float x, y, hpf=0.997f, min=1.0f, w=0.0f, ww=noisemix; 
     
    448448  vib = 1.0f + vib * (modwhl + vibrato); 
    449449 
    450   if(activevoices>0 || notes[event]<sampleFrames) 
     450  LV2_Atom_Event* ev = lv2_atom_sequence_begin(&eventInput->body); 
     451  bool end = lv2_atom_sequence_is_end(&eventInput->body, eventInput->atom.size, ev); 
     452  if(activevoices>0 || !end) 
    451453  {     
    452454    while(frame<sampleFrames) 
    453455    { 
    454       frames = notes[event++]; 
    455       if(frames>sampleFrames) frames = sampleFrames; 
     456      end = lv2_atom_sequence_is_end(&eventInput->body, eventInput->atom.size, ev); 
     457      frames = end ? sampleFrames : ev->time.frames; 
    456458      frames -= frame; 
    457459      frame += frames; 
     
    558560 
    559561            if(V->ff > fx) V->ff = fx; //stability limit 
    560  
     562             
    561563            V->f0 += V->ff * V->f1; //state-variable filter 
    562564            V->f1 -= V->ff * (V->f0 + fq * V->f1 - x - V->f2); 
    563             V->f1 -= 0.2f * V->f1 * V->f1 * V->f1; //soft limit  //was 0.08f 
     565            V->f1 -= 0.2f * V->f1 * V->f1 * V->f1; //soft limit 
     566 
    564567            V->f2 = x; 
    565568             
     
    569572        } 
    570573 
    571         *out1++ += o; 
    572         *out2++ += o; 
    573       } 
    574  
    575       if(frame<sampleFrames) 
    576       { 
    577         int32_t note = notes[event++]; 
    578         int32_t vel  = notes[event++]; 
    579         noteOn(note, vel); 
    580       } 
    581     } 
    582    
    583     activevoices = NVOICES; 
    584     for(v=0; v<NVOICES; v++) 
    585     { 
    586       if(voice[v].env<SILENCE)  //choke voices 
    587       { 
    588         voice[v].env = voice[v].envl = 0.0f; 
    589         voice[v].f0 = voice[v].f1 = voice[v].f2 = 0.0f; 
    590         activevoices--; 
    591       } 
    592     } 
    593   } 
    594   notes[0] = EVENTS_DONE;  //mark events buffer as done 
    595   fzip = fz; 
    596   K = k; 
    597 } 
    598  
    599  
    600 void mdaJX10::processReplacing(float **inputs, float **outputs, int32_t sampleFrames) 
    601 { 
    602     float* out1 = outputs[0]; 
    603     float* out2 = outputs[1]; 
    604     int32_t event=0, frame=0, frames, v; 
    605   float o, e, vib, pwm, pb=pbend, ipb=ipbend, gl=glide; 
    606   float x, y, hpf=0.997f, min=1.0f, w=0.0f, ww=noisemix; 
    607   float ff, fe=filtenv, fq=filtq * rezwhl, fx=1.97f-0.85f*fq, fz=fzip; 
    608   int32_t k=K; 
    609   unsigned int r; 
    610  
    611   vib = (float)sin(lfo); 
    612   ff = filtf + filtwhl + (filtlfo + press) * vib; //have to do again here as way that 
    613   pwm = 1.0f + vib * (modwhl + pwmdep);           //below triggers on k was too cheap! 
    614   vib = 1.0f + vib * (modwhl + vibrato); 
    615  
    616   if(activevoices>0 || notes[event]<sampleFrames) 
    617   {     
    618     while(frame<sampleFrames) 
    619     { 
    620       frames = notes[event++]; 
    621       if(frames>sampleFrames) frames = sampleFrames; 
    622       frames -= frame; 
    623       frame += frames; 
    624  
    625       while(--frames>=0) 
    626       { 
    627         VOICE *V = voice; 
    628         o = 0.0f; 
    629          
    630         noise = (noise * 196314165) + 907633515; 
    631         r = (noise & 0x7FFFFF) + 0x40000000; //generate noise + fast convert to float 
    632         w = *(float *)&r; 
    633         w = ww * (w - 3.0f); 
    634  
    635         if(--k<0) 
    636         { 
    637           lfo += dlfo; 
    638           if(lfo>PI) lfo -= TWOPI; 
    639           vib = (float)sin(lfo); 
    640           ff = filtf + filtwhl + (filtlfo + press) * vib; 
    641           pwm = 1.0f + vib * (modwhl + pwmdep); 
    642           vib = 1.0f + vib * (modwhl + vibrato); 
    643           k = KMAX; 
    644         } 
    645  
    646         for(v=0; v<NVOICES; v++)  //for each voice 
    647         {  
    648           e = V->env; 
    649           if(e > SILENCE) 
    650           { //Sinc-Loop Oscillator 
    651             x = V->p + V->dp; 
    652             if(x > min)  
    653             { 
    654               if(x > V->pmax)  
    655               {  
    656                 x = V->pmax + V->pmax - x;   
    657                 V->dp = -V->dp;  
    658               } 
    659               V->p = x; 
    660               x = V->sin0 * V->sinx - V->sin1; //sine osc 
    661               V->sin1 = V->sin0; 
    662               V->sin0 = x; 
    663               x = x / V->p; 
    664             } 
    665             else 
    666             {  
    667               V->p = x = - x;   
    668               V->dp = V->period * vib * pb; //set period for next cycle 
    669               V->pmax = (float)floor(0.5f + V->dp) - 0.5f; 
    670               V->dc = -0.5f * V->lev / V->pmax; 
    671               V->pmax *= PI; 
    672               V->dp = V->pmax / V->dp; 
    673               V->sin0 = V->lev * (float)sin(x); 
    674               V->sin1 = V->lev * (float)sin(x - V->dp); 
    675               V->sinx = 2.0f * (float)cos(V->dp); 
    676               if(x*x > .1f) x = V->sin0 / x; else x = V->lev; //was 0.01f; 
    677             } 
    678              
    679             y = V->p2 + V->dp2; //osc2 
    680             if(y > min)  
    681             {  
    682               if(y > V->pmax2)  
    683               {  
    684                 y = V->pmax2 + V->pmax2 - y;   
    685                 V->dp2 = -V->dp2;  
    686               } 
    687               V->p2 = y; 
    688               y = V->sin02 * V->sinx2 - V->sin12; 
    689               V->sin12 = V->sin02; 
    690               V->sin02 = y; 
    691               y = y / V->p2; 
    692             } 
    693             else 
    694             { 
    695               V->p2 = y = - y;   
    696               V->dp2 = V->period * V->detune * pwm * pb; 
    697               V->pmax2 = (float)floor(0.5f + V->dp2) - 0.5f; 
    698               V->dc2 = -0.5f * V->lev2 / V->pmax2; 
    699               V->pmax2 *= PI; 
    700               V->dp2 = V->pmax2 / V->dp2; 
    701               V->sin02 = V->lev2 * (float)sin(y); 
    702               V->sin12 = V->lev2 * (float)sin(y - V->dp2); 
    703               V->sinx2 = 2.0f * (float)cos(V->dp2); 
    704               if(y*y > .1f) y = V->sin02 / y; else y = V->lev2; 
    705             } 
    706             V->saw = V->saw * hpf + V->dc + x - V->dc2 - y;  //integrated sinc = saw 
    707             x = V->saw + w; 
    708             V->env += V->envd * (V->envl - V->env); 
    709  
    710             if(k==KMAX) //filter freq update at LFO rate 
    711             { 
    712               if((V->env+V->envl)>3.0f) { V->envd=dec; V->envl=sus; } //envelopes 
    713               V->fenv += V->fenvd * (V->fenvl - V->fenv); 
    714               if((V->fenv+V->fenvl)>3.0f) { V->fenvd=fdec; V->fenvl=fsus; } 
    715  
    716               fz += 0.005f * (ff - fz); //filter zipper noise filter 
    717               y = V->fc * (float)exp(fz + fe * V->fenv) * ipb; //filter cutoff 
    718               if(y<0.005f) y=0.005f; 
    719               V->ff = y; 
    720   
    721               V->period += gl * (V->target - V->period); //glide 
    722               if(V->target < V->period) V->period += gl * (V->target - V->period); 
    723             } 
    724  
    725             if(V->ff > fx) V->ff = fx; //stability limit 
    726              
    727             V->f0 += V->ff * V->f1; //state-variable filter 
    728             V->f1 -= V->ff * (V->f0 + fq * V->f1 - x - V->f2); 
    729             V->f1 -= 0.2f * V->f1 * V->f1 * V->f1; //soft limit 
    730  
    731             V->f2 = x; 
    732              
    733             o += V->env * V->f0; 
    734           } 
    735           V++; 
    736         } 
    737  
    738574        *out1++ = o; 
    739575        *out2++ = o; 
    740576      } 
    741577 
    742       if(frame<sampleFrames) 
    743       { 
    744         int32_t note = notes[event++]; 
    745         int32_t vel  = notes[event++]; 
    746         noteOn(note, vel); 
     578      if(!end) 
     579      { 
     580        processEvent(ev); 
     581        ev = lv2_atom_sequence_next(ev); 
    747582      } 
    748583    } 
     
    767602        } 
    768603  } 
    769   notes[0] = EVENTS_DONE;  //mark events buffer as done 
    770604  fzip = fz; 
    771605  K = k; 
     
    913747 
    914748 
    915 int32_t mdaJX10::processEvents(LvzEvents* ev) 
    916 { 
    917   int32_t npos=0; 
    918    
    919   for (int32_t i=0; i<ev->numEvents; i++) 
    920     { 
    921         if((ev->events[i])->type != kLvzMidiType) continue; 
    922         LvzMidiEvent* event = (LvzMidiEvent*)ev->events[i]; 
    923         char* midiData = event->midiData; 
     749int32_t mdaJX10::processEvent(const LV2_Atom_Event* ev) 
     750{ 
     751  if (ev->body.type != midiEventType) 
     752      return 0; 
     753 
     754  const uint8_t* midiData = (const uint8_t*)LV2_ATOM_BODY(&ev->body); 
    924755         
    925756    switch(midiData[0] & 0xf0) //status byte (all channels) 
    926757    { 
    927758      case 0x80: //note off 
    928         notes[npos++] = event->deltaFrames; //delta 
    929         notes[npos++] = midiData[1] & 0x7F; //note 
    930         notes[npos++] = 0;                  //vel 
     759        noteOn(midiData[1] & 0x7F, 0); 
    931760        break; 
    932761 
    933762      case 0x90: //note on 
    934         notes[npos++] = event->deltaFrames; //delta 
    935         notes[npos++] = midiData[1] & 0x7F; //note 
    936         notes[npos++] = midiData[2] & 0x7F; //vel 
     763        noteOn(midiData[1] & 0x7F, midiData[2] & 0x7F); 
    937764        break; 
    938765 
     
    964791            if(sustain==0) 
    965792            { 
    966               notes[npos++] = event->deltaFrames; 
    967               notes[npos++] = SUSTAIN; //end all sustained notes 
    968               notes[npos++] = 0; 
     793              noteOn(SUSTAIN, 0); 
    969794            } 
    970795            break; 
     
    1002827    } 
    1003828 
    1004     if(npos>EVENTBUFFER) npos -= 3; //discard events if buffer full!! 
    1005     event++; 
    1006     } 
    1007   notes[npos] = EVENTS_DONE; 
    1008829    return 1; 
    1009830} 
  • trunk/plugins/mda.lv2/src/mdaJX10.h

    r4127 r4215  
    9595    ~mdaJX10(); 
    9696 
    97     virtual void process(float **inputs, float **outputs, int32_t sampleframes); 
    9897    virtual void processReplacing(float **inputs, float **outputs, int32_t sampleframes); 
    99     virtual int32_t processEvents(LvzEvents* events); 
    10098 
    10199    virtual void setProgram(int32_t program); 
     
    119117    virtual bool getProductString (char* text); 
    120118    virtual int32_t getVendorVersion () {return 1;} 
    121     virtual int32_t canDo (char* text); 
     119    virtual int32_t canDo (const char* text); 
    122120 
    123121private: 
     122    int32_t processEvent(const LV2_Atom_Event* ev); 
    124123    void update();  //my parameter update 
    125124  void noteOn(int32_t note, int32_t velocity); 
     
    133132  float Fs; 
    134133 
    135   #define EVENTBUFFER 120 
    136   #define EVENTS_DONE 99999999 
    137   int32_t notes[EVENTBUFFER + 8];  //list of delta|note|velocity for current block 
    138134  #define KMAX 32 
    139135 
  • trunk/plugins/mda.lv2/src/mdaPiano.cpp

    r4127 r4215  
    1919#include "mdaPianoData.h" 
    2020#include "mdaPiano.h" 
     21 
     22#include "lv2/lv2plug.in/ns/ext/atom/util.h" 
    2123 
    2224#include <stdio.h> 
     
    110112    voice[v].dec = 0.99f; //all notes off 
    111113  } 
    112   notes[0] = EVENTS_DONE; 
    113114  volume = 0.2f; 
    114115  muff = 160.0f; 
     
    241242 
    242243 
    243 int32_t mdaPiano::canDo(char* text) 
     244int32_t mdaPiano::canDo(const char* text) 
    244245{ 
    245246  if(strcmp(text, "receiveLvzEvents") == 0) return 1; 
     
    314315} 
    315316 
    316  
    317  
    318 void mdaPiano::process(float **inputs, float **outputs, int32_t sampleFrames) 
     317void mdaPiano::processReplacing(float **inputs, float **outputs, int32_t sampleFrames) 
    319318{ 
    320319    float* out0 = outputs[0]; 
    321320    float* out1 = outputs[1]; 
    322     int32_t event=0, frame=0, frames, v; 
     321    int32_t frame=0, frames, v; 
    323322  float x, l, r; 
    324323  int32_t i; 
    325324 
     325  LV2_Atom_Event* ev = lv2_atom_sequence_begin(&eventInput->body); 
    326326  while(frame<sampleFrames) 
    327327  { 
    328     frames = notes[event++]; 
    329     if(frames>sampleFrames) frames = sampleFrames; 
    330     frames -= frame; 
    331     frame += frames; 
    332  
    333     while(--frames>=0) 
    334     { 
    335       VOICE *V = voice; 
    336       l = r = 0.0f; 
    337  
    338       for(v=0; v<activevoices; v++) 
    339       { 
    340         V->frac += V->delta;  //integer-based linear interpolation 
    341         V->pos += V->frac >> 16; 
    342         V->frac &= 0xFFFF; 
    343         if(V->pos > V->end) V->pos -= V->loop; 
    344         i = waves[V->pos]; 
    345         i = (i << 7) + (V->frac >> 9) * (waves[V->pos + 1] - i) + 0x40400000; 
    346         x = V->env * (*(float *)&i - 3.0f);  //fast int->float 
    347  
    348         V->env = V->env * V->dec;  //envelope 
    349         V->f0 += V->ff * (x + V->f1 - V->f0);  //muffle filter 
    350         V->f1 = x; 
    351  
    352         l += V->outl * V->f0; 
    353         r += V->outr * V->f0; 
    354  
    355         V++; 
    356       } 
    357       comb[cpos] = l + r; 
    358       ++cpos &= cmax; 
    359       x = cdep * comb[cpos];  //stereo simulator 
    360  
    361       *out0++ += l + x; 
    362       *out1++ += r - x; 
    363     } 
    364  
    365     if(frame<sampleFrames) 
    366     { 
    367       int32_t note = notes[event++]; 
    368       int32_t vel  = notes[event++]; 
    369       noteOn(note, vel); 
    370     } 
    371   } 
    372   for(v=0; v<activevoices; v++) if(voice[v].env < SILENCE) voice[v] = voice[--activevoices]; 
    373   notes[0] = EVENTS_DONE;  //mark events buffer as done 
    374 } 
    375  
    376  
    377 void mdaPiano::processReplacing(float **inputs, float **outputs, int32_t sampleFrames) 
    378 { 
    379     float* out0 = outputs[0]; 
    380     float* out1 = outputs[1]; 
    381     int32_t event=0, frame=0, frames, v; 
    382   float x, l, r; 
    383   int32_t i; 
    384  
    385   while(frame<sampleFrames) 
    386   { 
    387     frames = notes[event++]; 
    388     if(frames>sampleFrames) frames = sampleFrames; 
     328    bool end = lv2_atom_sequence_is_end(&eventInput->body, eventInput->atom.size, ev); 
     329    frames = end ? sampleFrames : ev->time.frames; 
    389330    frames -= frame; 
    390331    frame += frames; 
     
    433374    } 
    434375 
    435     if(frame<sampleFrames) 
     376    if(!end) 
    436377    { 
    437       int32_t note = notes[event++]; 
    438       int32_t vel  = notes[event++]; 
    439       noteOn(note, vel); 
     378      processEvent(ev); 
     379      ev = lv2_atom_sequence_next(ev); 
    440380    } 
    441381  } 
    442382  for(v=0; v<activevoices; v++) if(voice[v].env < SILENCE) voice[v] = voice[--activevoices]; 
    443   notes[0] = EVENTS_DONE;  //mark events buffer as done 
    444383} 
    445384 
     
    519458 
    520459 
    521 int32_t mdaPiano::processEvents(LvzEvents* ev) 
    522 { 
    523   int32_t npos=0; 
    524  
    525   for (int32_t i=0; i<ev->numEvents; i++) 
    526     { 
    527         if((ev->events[i])->type != kLvzMidiType) continue; 
    528         LvzMidiEvent* event = (LvzMidiEvent*)ev->events[i]; 
    529         char* midiData = event->midiData; 
     460int32_t mdaPiano::processEvent(const LV2_Atom_Event* ev) 
     461{ 
     462  if (ev->body.type != midiEventType) 
     463      return 0; 
     464 
     465  const uint8_t* midiData = (const uint8_t*)LV2_ATOM_BODY(&ev->body); 
    530466 
    531467    switch(midiData[0] & 0xf0) //status byte (all channels) 
    532468    { 
    533469      case 0x80: //note off 
    534         notes[npos++] = event->deltaFrames; //delta 
    535         notes[npos++] = midiData[1] & 0x7F; //note 
    536         notes[npos++] = 0;                  //vel 
     470        noteOn(midiData[1] & 0x7F, 0); 
    537471        break; 
    538472 
    539473      case 0x90: //note on 
    540         notes[npos++] = event->deltaFrames; //delta 
    541         notes[npos++] = midiData[1] & 0x7F; //note 
    542         notes[npos++] = midiData[2] & 0x7F; //vel 
     474        noteOn(midiData[1] & 0x7F, midiData[2] & 0x7F); 
    543475        break; 
    544476 
     
    560492            if(sustain==0) 
    561493            { 
    562               notes[npos++] = event->deltaFrames; 
    563               notes[npos++] = SUSTAIN; //end all sustained notes 
    564               notes[npos++] = 0; 
     494              noteOn(SUSTAIN, 0); //end all sustained notes   
    565495            } 
    566496            break; 
     
    584514    } 
    585515 
    586     if(npos>EVENTBUFFER) npos -= 3; //discard events if buffer full!! 
    587     event++; //? 
    588     } 
    589   notes[npos] = EVENTS_DONE; 
    590516    return 1; 
    591517} 
  • trunk/plugins/mda.lv2/src/mdaPiano.h

    r4127 r4215  
    8181    ~mdaPiano(); 
    8282 
    83     virtual void process(float **inputs, float **outputs, int32_t sampleframes); 
    8483    virtual void processReplacing(float **inputs, float **outputs, int32_t sampleframes); 
    85     virtual int32_t processEvents(LvzEvents* events); 
    8684 
    8785    virtual void setProgram(int32_t program); 
     
    103101    virtual bool getProductString (char* text); 
    104102    virtual int32_t getVendorVersion () {return 1;} 
    105     virtual int32_t canDo (char* text); 
     103    virtual int32_t canDo (const char* text); 
    106104 
    107105  virtual int32_t getNumMidiInputChannels ()  { return 1; } 
     
    111109 
    112110private: 
     111    int32_t processEvent(const LV2_Atom_Event* ev); 
    113112    void update();  //my parameter update 
    114113  void noteOn(int32_t note, int32_t velocity); 
     
    119118  mdaPianoProgram* programs; 
    120119  float Fs, iFs; 
    121  
    122   #define EVENTBUFFER 120 
    123   #define EVENTS_DONE 99999999 
    124   int32_t notes[EVENTBUFFER + 8];  //list of delta|note|velocity for current block 
    125120 
    126121  ///global internal variables 
Note: See TracChangeset for help on using the changeset viewer.