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