juce/source/src/audio/plugin_client/LV2/juce_LV2_Wrapper.cpp

   1 /*
   2  *  JUCE LV2 wrapper
   3  */
   4
   5 #include "../juce_IncludeCharacteristics.h"
   6
   7 #if JucePlugin_Build_LV2
   8
   9 // LV2 includes..
  10 #include "lv2/lv2.h"
  11 #include "lv2/event.h"
  12 #include "lv2/event_helpers.h"
  13 #include "lv2/instance_access.h"
  14 #include "lv2/uri_map.h"
  15 #include "lv2/ui.h"
  16 #include "lv2/lv2_external_ui.h"
  17
  18 #include "../juce_PluginHeaders.h"
  19 #include "../juce_PluginHostType.h"
  20
  21 //==============================================================================
  22 // Same as juce_lv2_gen.cpp
  23 String get_uri()
  24 {
  25     return String("urn:" JucePlugin_Manufacturer ":" JucePlugin_Name ":" JucePlugin_VersionString).replace(" ", "_");
  26 }
  27
  28 String get_juce_ui_uri()
  29 {
  30     return String("urn:" JucePlugin_Manufacturer ":" JucePlugin_Name ":JUCE-Native-UI").replace(" ", "_");
  31 }
  32
  33 String get_external_ui_uri()
  34 {
  35     return String("urn:" JucePlugin_Manufacturer ":" JucePlugin_Name ":JUCE-External-UI").replace(" ", "_");
  36 }
  37
  38 static Array<void*> activePlugins;
  39
  40 extern AudioProcessor* JUCE_CALLTYPE createPluginFilter();
  41
  42 //==============================================================================
  43 // Create a new JUCE LV2 Plugin
  44 class JuceLV2Wrapper : private Timer
  45 {
  46 public:
  47     JuceLV2Wrapper(const LV2_Descriptor* descriptor_, double sample_rate_, const LV2_Feature* const* features) :
  48             chunkMemoryTime (0),
  49             numInChans (JucePlugin_MaxNumInputChannels),
  50             numOutChans (JucePlugin_MaxNumOutputChannels),
  51             isProcessing (false),
  52             firstProcessCallback (true),
  53             descriptor (descriptor_),
  54             sample_rate (sample_rate_),
  55             buffer_size (512),
  56             midi_uri_id (0),
  57             port_count (0)
  58     {
  59         printf("JuceLV2Wrapper()\n");
  60         initialiseJuce_GUI();
  61
  62         filter = createPluginFilter();
  63         filter->setPlayConfigDetails(numInChans, numOutChans, 0, 0);
  64
  65         // Port count
  66 #if JucePlugin_WantsMidiInput
  67         port_count += 1;
  68 #endif
  69 #if JucePlugin_ProducesMidiOutput
  70         port_count += 1;
  71 #endif
  72         port_count += numInChans;
  73         port_count += numOutChans;
  74         port_count += filter->getNumParameters();
  75
  76         // Set Port data
  77         port_min = nullptr;
  78         port_mout = nullptr;
  79         ports_ctrl.insertMultiple(0, nullptr, filter->getNumParameters());
  80         ports_ctrl_last.insertMultiple(0, 0.0f, filter->getNumParameters());
  81
  82         for (int i=0; i < numInChans; i++) {
  83             ports_ain[i] = nullptr;
  84         }
  85
  86         for (int i=0; i < numOutChans; i++) {
  87             ports_aout[i] = nullptr;
  88         }
  89
  90         for (int i=0; i < filter->getNumParameters(); i++) {
  91             ports_ctrl_last.set(i, filter->getParameter(i));
  92         }
  93
  94         // Get MIDI URI Id
  95         for (uint16_t j = 0; features[j]; j++)
  96         {
  97             if (strcmp(features[j]->URI, LV2_URI_MAP_URI) == 0)
  98             {
  99                 LV2_URI_Map_Feature* uri_feature = (LV2_URI_Map_Feature*)features[j]->data;
 100                 midi_uri_id = uri_feature->uri_to_id(uri_feature->callback_data, LV2_EVENT_URI, "http://lv2plug.in/ns/ext/midi#MidiEvent");
 101                 break;
 102             }
 103         }
 104
 105         activePlugins.add (this);
 106
 107         startTimer(1000);
 108     }
 109
 110     ~JuceLV2Wrapper()
 111     {
 112         JUCE_AUTORELEASEPOOL
 113
 114         {
 115             stopTimer();
 116
 117             delete filter;
 118             filter = 0;
 119
 120             channels.free();
 121             deleteTempChannels();
 122
 123             ports_ctrl.clear();
 124             ports_ctrl_last.clear();
 125
 126             jassert (activePlugins.contains (this));
 127             activePlugins.removeValue (this);
 128
 129             if (activePlugins.size() == 0)
 130             {
 131                 shutdownJuce_GUI();
 132             }
 133         }
 134     }
 135
 136     //==============================================================================
 137     // LV2 Descriptor Calls
 138     void do_connect_port(uint32_t port, void* data_location)
 139     {
 140         if (port < port_count)
 141         {
 142             int i;
 143             uint32_t index = 0;
 144
 145 #if JucePlugin_WantsMidiInput
 146             if (port == index) {
 147                 port_min = (LV2_Event_Buffer*)data_location;
 148                 return;
 149             }
 150             index += 1;
 151 #endif
 152
 153 #if JucePlugin_ProducesMidiOutput
 154             if (port == index) {
 155                 port_mout = (LV2_Event_Buffer*)data_location;
 156                 return;
 157             }
 158             index += 1;
 159 #endif
 160
 161             for (i=0; i < numInChans; i++) {
 162                 if (port == index) {
 163                     ports_ain[i] = (float*)data_location;
 164                     return;
 165                 }
 166                 index += 1;
 167             }
 168
 169             for (i=0; i < numOutChans; i++) {
 170                 if (port == index) {
 171                     ports_aout[i] = (float*)data_location;
 172                     return;
 173                 }
 174                 index += 1;
 175             }
 176
 177             for (i=0; i < filter->getNumParameters(); i++) {
 178                 if (port == index) {
 179                     ports_ctrl.set(i, (float*)data_location);
 180                     return;
 181                 }
 182                 index += 1;
 183             }
 184         }
 185     }
 186
 187     void do_activate()
 188     {
 189         if (filter != nullptr)
 190         {
 191             isProcessing = true;
 192             channels.calloc (numInChans + numOutChans);
 193
 194             jassert (sample_rate > 0);
 195             if (sample_rate <= 0.0)
 196                 sample_rate = 44100.0;
 197
 198             jassert (buffer_size > 0);
 199
 200             firstProcessCallback = true;
 201
 202             filter->setNonRealtime (false);
 203             filter->setPlayConfigDetails (numInChans, numOutChans, sample_rate, buffer_size);
 204
 205             deleteTempChannels();
 206
 207             filter->prepareToPlay (sample_rate, buffer_size);
 208
 209             midiEvents.ensureSize (2048);
 210             midiEvents.clear();
 211         }
 212     }
 213
 214     void do_run(uint32_t sample_count)
 215     {
 216         if (firstProcessCallback)
 217         {
 218             firstProcessCallback = false;
 219
 220             // if this fails, the host hasn't called resume() before processing
 221             jassert (isProcessing);
 222
 223             // (tragically, some hosts actually need this, although it's stupid to have
 224             //  to do it here..)
 225             if (! isProcessing)
 226                 do_activate();
 227
 228             filter->setNonRealtime (false);
 229
 230            #if JUCE_WINDOWS
 231             if (GetThreadPriority (GetCurrentThread()) <= THREAD_PRIORITY_NORMAL
 232                   && GetThreadPriority (GetCurrentThread()) >= THREAD_PRIORITY_LOWEST)
 233                 filter->setNonRealtime (true);
 234            #endif
 235         }
 236
 237         // Check if buffer size changed
 238         if (buffer_size != sample_count)
 239         {
 240             buffer_size = sample_count;
 241             filter->setPlayConfigDetails(numInChans, numOutChans, sample_rate, buffer_size);
 242             filter->prepareToPlay(sample_rate, buffer_size);
 243         }
 244
 245         // Check for updated parameters
 246         float cur_value;
 247         for (int i = 0; i < ports_ctrl.size(); i++)
 248         {
 249             if (ports_ctrl[i] != nullptr)
 250             {
 251                 cur_value = *(float*)ports_ctrl[i];
 252                 if (ports_ctrl_last[i] != cur_value) {
 253                     filter->setParameter(i, cur_value);
 254                     ports_ctrl_last.setUnchecked(i, cur_value);
 255                 }
 256             }
 257         }
 258
 259         jassert (activePlugins.contains (this));
 260
 261         {
 262             const ScopedLock sl (filter->getCallbackLock());
 263
 264             const int numIn = numInChans;
 265             const int numOut = numOutChans;
 266
 267             if (filter->isSuspended())
 268             {
 269                 for (int i = 0; i < numOut; ++i)
 270                     zeromem (ports_aout[i], sizeof (float) * sample_count);
 271             }
 272             else
 273             {
 274                 int i;
 275                 for (i = 0; i < numOut; ++i)
 276                 {
 277                     float* chan = tempChannels.getUnchecked(i);
 278
 279                     if (chan == 0)
 280                     {
 281                         chan = ports_aout[i];
 282
 283                         // if some output channels are disabled, some hosts supply the same buffer
 284                         // for multiple channels - this buggers up our method of copying the
 285                         // inputs over the outputs, so we need to create unique temp buffers in this case..
 286                         for (int j = i; --j >= 0;)
 287                         {
 288                             if (ports_aout[j] == chan)
 289                             {
 290                                 chan = new float [buffer_size * 2];
 291                                 tempChannels.set (i, chan);
 292                                 break;
 293                             }
 294                         }
 295                     }
 296
 297                     if (i < numIn && chan != ports_ain[i])
 298                         memcpy (chan, ports_ain[i], sizeof (float) * sample_count);
 299
 300                     channels[i] = chan;
 301                 }
 302
 303                 // LV2 MIDI Input
 304                 LV2_Event_Iterator iter;
 305                 lv2_event_begin(&iter, port_min);
 306
 307                 lv2_event_buffer_reset(port_min, LV2_EVENT_AUDIO_STAMP, (uint8_t*)(port_min + 1));
 308
 309                 for (uint32_t i=0; i < iter.buf->event_count; ++i) {
 310                     uint8_t* data;
 311                     LV2_Event* ev = lv2_event_get(&iter, &data);
 312                     midiEvents.addEvent(data, ev->size, ev->frames);
 313                     lv2_event_increment(&iter);
 314                 }
 315
 316                 for (; i < numIn; ++i)
 317                     channels[i] = ports_ain[i];
 318
 319                 AudioSampleBuffer chans (channels, jmax (numIn, numOut), sample_count);
 320
 321                 filter->processBlock (chans, midiEvents);
 322             }
 323         }
 324
 325         if (! midiEvents.isEmpty())
 326         {
 327 #if JucePlugin_ProducesMidiOutput
 328             const int numEvents = midiEvents.getNumEvents();
 329
 330             LV2_Event_Iterator iter;
 331             lv2_event_buffer_reset(port_mout, LV2_EVENT_AUDIO_STAMP, (uint8_t*)(port_mout + 1));
 332             lv2_event_begin(&iter, port_mout);
 333
 334             const JUCE_NAMESPACE::uint8* midiEventData;
 335             int midiEventSize, midiEventPosition;
 336             MidiBuffer::Iterator i (midiEvents);
 337
 338             while (i.getNextEvent (midiEventData, midiEventSize, midiEventPosition))
 339             {
 340                 jassert (midiEventPosition >= 0 && midiEventPosition < sample_count);
 341
 342                 lv2_event_write(&iter, midiEventPosition, 0, midi_uri_id, midiEventSize, midiEventData);
 343             }
 344 #endif
 345             midiEvents.clear();
 346         }
 347     }
 348
 349     void do_deactivate()
 350     {
 351         if (filter != nullptr)
 352         {
 353             filter->releaseResources();
 354
 355             isProcessing = false;
 356             channels.free();
 357
 358             deleteTempChannels();
 359         }
 360     }
 361
 362     void do_cleanup()
 363     {
 364         stopTimer();
 365
 366         if (descriptor)
 367         {
 368             free((void*)descriptor->URI);
 369             delete descriptor;
 370         }
 371     }
 372
 373     //==============================================================================
 374     // JUCE Stuff
 375
 376     // TODO  - set/get chunk
 377
 378     AudioProcessor* getFilter() { return filter; }
 379
 380     void timerCallback()
 381     {
 382         if (chunkMemoryTime > 0 && chunkMemoryTime < JUCE_NAMESPACE::Time::getApproximateMillisecondCounter() - 2000)
 383         {
 384             chunkMemoryTime = 0;
 385             chunkMemory.setSize (0);
 386         }
 387     }
 388
 389     //==============================================================================
 390 private:
 391     AudioProcessor* filter;
 392     JUCE_NAMESPACE::MemoryBlock chunkMemory;
 393     JUCE_NAMESPACE::uint32 chunkMemoryTime;
 394     MidiBuffer midiEvents;
 395     int numInChans, numOutChans;
 396     bool isProcessing, firstProcessCallback;
 397     HeapBlock<float*> channels;
 398     Array<float*> tempChannels;  // see note in do_run()
 399
 400     const LV2_Descriptor* descriptor;
 401
 402     double sample_rate;
 403     int buffer_size;
 404     uint16_t midi_uri_id;
 405     uint32_t port_count;
 406
 407     LV2_Event_Buffer* port_min;
 408     LV2_Event_Buffer* port_mout;
 409     float* ports_ain[JucePlugin_MaxNumInputChannels];
 410     float* ports_aout[JucePlugin_MaxNumOutputChannels];
 411     Array<float*> ports_ctrl;
 412     Array<float> ports_ctrl_last;
 413
 414     //==============================================================================
 415     void deleteTempChannels()
 416     {
 417         for (int i = tempChannels.size(); --i >= 0;)
 418             delete[] (tempChannels.getUnchecked(i));
 419
 420         tempChannels.clear();
 421
 422         if (filter != nullptr)
 423             tempChannels.insertMultiple (0, 0, filter->getNumInputChannels() + filter->getNumOutputChannels());
 424     }
 425
 426     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (JuceLV2Wrapper);
 427 };
 428
 429 //==============================================================================
 430 // Create a new JUCE Editor
 431 class JuceLv2Editor : public AudioProcessorListener
 432 {
 433 public:
 434     JuceLv2Editor (JuceLV2Wrapper* const wrapper_, const LV2UI_Descriptor* ui_descriptor_, LV2UI_Write_Function write_function_, LV2UI_Controller controller_, LV2UI_Widget* widget_, const LV2_Feature* const* features) :
 435             wrapper(wrapper_),
 436             ui_descriptor(ui_descriptor_),
 437             write_function(write_function_),
 438             controller(controller_),
 439             widget(widget_)
 440     {
 441         initialiseJuce_GUI();
 442
 443         filter = wrapper->getFilter();
 444
 445         //printf("TEST - Before\n");
 446         //editor = filter->createEditorIfNeeded();
 447         //printf("TEST - After\n");
 448
 449         // Padding for control ports
 450         ctrl_pad = 0;
 451 #if JucePlugin_WantsMidiInput
 452         ctrl_pad += 1;
 453 #endif
 454 #if JucePlugin_ProducesMidiOutput
 455         ctrl_pad += 1;
 456 #endif
 457         ctrl_pad += JucePlugin_MaxNumInputChannels;
 458         ctrl_pad += JucePlugin_MaxNumOutputChannels;
 459     }
 460
 461     ~JuceLv2Editor()
 462     {
 463         deleteAndZero (editor);
 464         shutdownJuce_GUI();
 465     }
 466
 467     void do_port_event(uint32_t port_index, float value)
 468     {
 469         filter->setParameter(port_index-ctrl_pad, value);
 470     }
 471
 472     void do_cleanup()
 473     {
 474         if (ui_descriptor)
 475         {
 476             free((void*)ui_descriptor->URI);
 477             delete ui_descriptor;
 478         }
 479     }
 480
 481     void audioProcessorParameterChanged (AudioProcessor*, int index, float newValue)
 482     {
 483         if (controller && write_function)
 484             write_function(controller, index+ctrl_pad, sizeof(float), 0, &newValue);
 485     }
 486
 487     void audioProcessorChanged (AudioProcessor*) {}
 488
 489 private:
 490     JuceLV2Wrapper* wrapper;
 491     const LV2UI_Descriptor* ui_descriptor;
 492     LV2UI_Write_Function write_function;
 493     LV2UI_Controller controller;
 494     LV2UI_Widget* widget;
 495
 496     AudioProcessor* filter;
 497     AudioProcessorEditor* editor;
 498
 499     int ctrl_pad;
 500
 501     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (JuceLv2Editor);
 502 };
 503
 504 //==============================================================================
 505 // LV2 descriptor functions
 506 LV2_Handle juce_lv2_instantiate(const LV2_Descriptor* descriptor, double sample_rate, const char* bundle_path, const LV2_Feature* const* features)
 507 {
 508     MessageManagerLock mmLock;
 509     JuceLV2Wrapper* wrapper = new JuceLV2Wrapper(descriptor, sample_rate, features);
 510     return wrapper;
 511 }
 512
 513 void juce_lv2_connect_port(LV2_Handle instance, uint32_t port, void* data_location)
 514 {
 515     JuceLV2Wrapper* wrapper = (JuceLV2Wrapper*)instance;
 516     wrapper->do_connect_port(port, data_location);
 517 }
 518
 519 void juce_lv2_activate(LV2_Handle instance)
 520 {
 521     JuceLV2Wrapper* wrapper = (JuceLV2Wrapper*)instance;
 522     wrapper->do_activate();
 523 }
 524
 525 void juce_lv2_run(LV2_Handle instance, uint32_t sample_count)
 526 {
 527     JuceLV2Wrapper* wrapper = (JuceLV2Wrapper*)instance;
 528     wrapper->do_run(sample_count);
 529 }
 530
 531 void juce_lv2_deactivate(LV2_Handle instance)
 532 {
 533     JuceLV2Wrapper* wrapper = (JuceLV2Wrapper*)instance;
 534     wrapper->do_deactivate();
 535 }
 536
 537 void juce_lv2_cleanup(LV2_Handle instance)
 538 {
 539     MessageManagerLock mmLock;
 540     JuceLV2Wrapper* wrapper = (JuceLV2Wrapper*)instance;
 541     wrapper->do_cleanup();
 542     delete wrapper;
 543 }
 544
 545 const void* juce_lv2_extension_data(const char* uri)
 546 {
 547     printf("TODO :: juce_lv2_extension_data()\n");
 548     return nullptr;
 549 }
 550
 551 //==============================================================================
 552 LV2UI_Handle juce_lv2ui_instantiate(const LV2UI_Descriptor* descriptor, const char* plugin_uri, const char* bundle_path, LV2UI_Write_Function write_function, LV2UI_Controller controller, LV2UI_Widget* widget, const LV2_Feature* const* features)
 553 {
 554     MessageManagerLock mmLock;
 555     for (uint16_t i = 0; features[i]; i++)
 556     {
 557         if (strcmp(features[i]->URI, LV2_INSTANCE_ACCESS_URI) == 0 && features[i]->data)
 558         {
 559             JuceLV2Wrapper* wrapper = (JuceLV2Wrapper*)features[i]->data;
 560             JuceLv2Editor* editor = new JuceLv2Editor(wrapper, descriptor, write_function, controller, widget, features);
 561             return editor;
 562         }
 563     }
 564     printf("Host does not support instance data - cannot use UI\n");
 565     return nullptr;
 566 }
 567
 568 void juce_lv2ui_port_event(LV2UI_Handle instance, uint32_t port_index, uint32_t buffer_size, uint32_t format, const void* buffer)
 569 {
 570     MessageManagerLock mmLock;
 571     JuceLv2Editor* editor = (JuceLv2Editor*)instance;
 572
 573     if (buffer_size == sizeof(float) && format == 0)
 574     {
 575         float value = *(float*)buffer;
 576         editor->do_port_event(port_index, value);
 577     }
 578 }
 579
 580 void juce_lv2ui_cleanup(LV2UI_Handle instance)
 581 {
 582     MessageManagerLock mmLock;
 583     JuceLv2Editor* editor = (JuceLv2Editor*)instance;
 584     //editor->do_cleanup();
 585     delete editor;
 586 }
 587
 588 //==============================================================================
 589 // Create new LV2 objects
 590 LV2_Descriptor* getNewLv2Plugin()
 591 {
 592     LV2_Descriptor* const Lv2Plugin = new LV2_Descriptor;
 593     Lv2Plugin->URI = strdup((const char*)get_uri().toUTF8());
 594     Lv2Plugin->instantiate = juce_lv2_instantiate;
 595     Lv2Plugin->connect_port = juce_lv2_connect_port;
 596     Lv2Plugin->activate = juce_lv2_activate;
 597     Lv2Plugin->run = juce_lv2_run;
 598     Lv2Plugin->deactivate = juce_lv2_deactivate;
 599     Lv2Plugin->cleanup = juce_lv2_cleanup;
 600     Lv2Plugin->extension_data = juce_lv2_extension_data;
 601     return Lv2Plugin;
 602 }
 603
 604 LV2UI_Descriptor* getNewLv2UI(bool external)
 605 {
 606     LV2UI_Descriptor* Lv2UI = new LV2UI_Descriptor;
 607     Lv2UI->URI = strdup((const char*) (external ? get_external_ui_uri() : get_juce_ui_uri()).toUTF8());
 608     Lv2UI->instantiate = juce_lv2ui_instantiate;
 609     Lv2UI->cleanup = juce_lv2ui_cleanup;
 610     Lv2UI->port_event = juce_lv2ui_port_event;
 611     Lv2UI->extension_data = juce_lv2_extension_data;
 612     return Lv2UI;
 613 }
 614
 615 //==============================================================================
 616 // Mac startup code..
 617 #if JUCE_MAC
 618
 619     extern "C" __attribute__ ((visibility("default"))) const LV2_Descriptor* lv2_descriptor(uint32_t index)
 620     {
 621         initialiseMac();
 622         return (index == 0) ? getNewLv2Plugin() : nullptr;
 623     }
 624
 625     extern "C" __attribute__ ((visibility("default"))) const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index)
 626     {
 627         return (index <= 1) ? getNewLv2UI((index == 0)) : nullptr;
 628     }
 629
 630 //==============================================================================
 631 // Linux startup code..
 632 #elif JUCE_LINUX
 633
 634     extern "C" __attribute__ ((visibility("default"))) const LV2_Descriptor* lv2_descriptor(uint32_t index)
 635     {
 636         return (index == 0) ? getNewLv2Plugin() : nullptr;
 637     }
 638
 639     extern "C" __attribute__ ((visibility("default"))) const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index)
 640     {
 641         return (index <= 1) ? getNewLv2UI((index == 0)) : nullptr;
 642     }
 643
 644     // don't put initialiseJuce_GUI or shutdownJuce_GUI in these... it will crash!
 645     __attribute__((constructor)) void myPluginInit() {}
 646     __attribute__((destructor))  void myPluginFini() {}
 647
 648 //==============================================================================
 649 // Win32 startup code..
 650 #else
 651
 652     extern "C" __declspec (dllexport) const LV2_Descriptor* lv2_descriptor(uint32_t index)
 653     {
 654         return (index == 0) ? getNewLv2Plugin() : nullptr;
 655     }
 656
 657     extern "C" __declspec (dllexport) const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index)
 658     {
 659         return (index <= 1) ? getNewLv2UI((index == 0)) : nullptr;
 660     }
 661
 662 #endif
 663
 664 #endif