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 #include <fstream>
  10 #include <iostream>
  11 #include <stdint.h>
  12
  13 #include "juce.h"
  14
  15 // LV2 includes
  16 #include "lv2/lv2.h"
  17 #include "lv2/event.h"
  18 #include "lv2/event_helpers.h"
  19 #include "lv2/instance_access.h"
  20 #include "lv2/uri_map.h"
  21 #include "lv2/ui.h"
  22 #include "lv2/lv2_external_ui.h"
  23
  24 // These are dummy values!
  25 enum FakePlugCategory
  26 {
  27     kPlugCategUnknown,
  28     kPlugCategEffect,
  29     kPlugCategSynth,
  30     kPlugCategAnalysis,
  31     kPlugCategMastering,
  32     kPlugCategSpacializer,
  33     kPlugCategRoomFx,
  34     kPlugSurroundFx,
  35     kPlugCategRestoration,
  36     kPlugCategOfflineProcess,
  37     kPlugCategGenerator
  38 };
  39
  40 extern AudioProcessor* JUCE_CALLTYPE createPluginFilter();
  41
  42 String name_to_symbol(String Name, uint32_t port_index)
  43 {
  44     String Symbol = Name.trimStart().trimEnd().replace(" ", "_").toLowerCase();
  45
  46     if (Symbol.isEmpty())
  47     {
  48         Symbol += String(port_index);
  49     }
  50     else
  51     {
  52         for (int i=0; i < Symbol.length(); i++)
  53         {
  54             if (std::isalpha(Symbol[i]) || std::isdigit(Symbol[i]) || Symbol[i] == '_') {
  55                 // nothing
  56             } else {
  57                 Symbol[i] == '_';
  58             }
  59         }
  60     }
  61
  62     return Symbol;
  63 }
  64
  65 String float_to_string(float value)
  66 {
  67     if (value < 0.0f || value > 1.0f) {
  68         std::cerr << "WARNING - Parameter uses out-of-bounds value -> " << value << std::endl;
  69     }
  70     String string(value);
  71     if (!string.contains(".")) {
  72         string += ".0";
  73     }
  74     return string;
  75 }
  76
  77 String get_uri()
  78 {
  79     return String("urn:" JucePlugin_Manufacturer ":" JucePlugin_Name ":" JucePlugin_VersionString).replace(" ", "_");
  80 }
  81
  82 String get_juce_ui_uri()
  83 {
  84     return String("urn:" JucePlugin_Manufacturer ":" JucePlugin_Name ":JUCE-Native-UI").replace(" ", "_");
  85 }
  86
  87 String get_external_ui_uri()
  88 {
  89     return String("urn:" JucePlugin_Manufacturer ":" JucePlugin_Name ":JUCE-External-UI").replace(" ", "_");
  90 }
  91
  92 String get_binary_name()
  93 {
  94     return String(JucePlugin_Name).replace(" ", "_");
  95 }
  96
  97 String get_plugin_type()
  98 {
  99     String ptype;
 100
 101     switch (JucePlugin_VSTCategory) {
 102     case kPlugCategSynth:
 103         ptype += "lv2:InstrumentPlugin";
 104         break;
 105     case kPlugCategAnalysis:
 106         ptype += "lv2:AnalyserPlugin";
 107         break;
 108     case kPlugCategMastering:
 109         ptype += "lv2:DynamicsPlugin";
 110         break;
 111     case kPlugCategSpacializer:
 112         ptype += "lv2:SpatialPlugin";
 113         break;
 114     case kPlugCategRoomFx:
 115         ptype += "lv2:ModulatorPlugin";
 116         break;
 117     case kPlugCategRestoration:
 118         ptype += "lv2:UtilityPlugin";
 119         break;
 120     case kPlugCategGenerator:
 121         ptype += "lv2:GeneratorPlugin";
 122         break;
 123     }
 124
 125     if (ptype.isNotEmpty()) {
 126         ptype += ", ";
 127     }
 128
 129     ptype += "lv2:Plugin";
 130     return ptype;
 131 }
 132
 133 String get_manifest_ttl(String URI, String Binary)
 134 {
 135     String manifest;
 136     manifest += "@prefix lv2:  <http://lv2plug.in/ns/lv2core#> .\n";
 137     manifest += "@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .\n";
 138     manifest += "\n";
 139     manifest += "<" + URI + ">\n";
 140     manifest += "    a lv2:Plugin ;\n";
 141     manifest += "    lv2:binary <" + Binary + ".so> ;\n";
 142     manifest += "    rdfs:seeAlso <" + Binary +".ttl> .\n";
 143     return manifest;
 144 }
 145
 146 String get_plugin_ttl(String URI, String Binary)
 147 {
 148     uint32_t i, port_index = 0;
 149     AudioProcessor* filter = createPluginFilter();
 150
 151     String plugin;
 152     plugin += "@prefix doap:  <http://usefulinc.com/ns/doap#> .\n";
 153     //plugin += "@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .\n";
 154     //plugin += "@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .\n";
 155     plugin += "@prefix lv2:   <http://lv2plug.in/ns/lv2core#> .\n";
 156     plugin += "@prefix lv2ev: <http://lv2plug.in/ns/ext/event#> .\n";
 157     plugin += "@prefix lv2ui: <http://lv2plug.in/ns/extensions/ui#> .\n";
 158     plugin += "\n";
 159
 160     if (filter->hasEditor()) {
 161         plugin += "<" + get_juce_ui_uri() + ">\n";
 162         plugin += "    a lv2ui:JUCEUI ;\n";
 163         plugin += "    lv2ui:binary <" + Binary + ".so> .\n";
 164         plugin += "<" + get_external_ui_uri() + ">\n";
 165         plugin += "    a lv2ui:external ;\n";
 166         plugin += "    lv2ui:binary <" + Binary + ".so> .\n";
 167         plugin += "\n";
 168     }
 169
 170     plugin += "<" + URI + ">\n";
 171     plugin += "    a " + get_plugin_type() + " ;\n";
 172
 173     if (filter->hasEditor()) {
 174         plugin += "    lv2ui:ui <" + get_juce_ui_uri() + ">,\n";
 175         plugin += "             <" + get_external_ui_uri() + ">;\n";
 176     }
 177
 178     plugin += "\n";
 179
 180 #if JucePlugin_WantsMidiInput
 181     plugin += "    lv2:port [\n";
 182     plugin += "      a lv2:InputPort, lv2ev:EventPort;\n";
 183     plugin += "      lv2ev:supportsEvent <http://lv2plug.in/ns/ext/midi#MidiEvent>;\n";
 184     plugin += "      lv2:index " + String(port_index++) + ";\n";
 185     plugin += "      lv2:symbol \"midi_in\";\n";
 186     plugin += "      lv2:name \"MIDI Input\";\n";
 187     plugin += "    ] ;\n\n";
 188 #endif
 189
 190 #if JucePlugin_ProducesMidiOutput
 191     plugin += "    lv2:port [\n";
 192     plugin += "      a lv2:OutputPort, lv2ev:EventPort;\n";
 193     plugin += "      lv2ev:supportsEvent <http://lv2plug.in/ns/ext/midi#MidiEvent>;\n";
 194     plugin += "      lv2:index " + String(port_index++) + ";\n";
 195     plugin += "      lv2:symbol \"midi_out\";\n";
 196     plugin += "      lv2:name \"MIDI Output\";\n";
 197     plugin += "    ] ;\n\n";
 198 #endif
 199
 200     for (i=0; i<JucePlugin_MaxNumInputChannels; i++) {
 201         if (i == 0) {
 202             plugin += "    lv2:port [\n";
 203         } else {
 204             plugin += "    [\n";
 205         }
 206
 207         plugin += "      a lv2:InputPort, lv2:AudioPort;\n";
 208         //plugin += "      lv2:datatype lv2:float;\n";
 209         plugin += "      lv2:index " + String(port_index++) + ";\n";
 210         plugin += "      lv2:symbol \"audio_in_" + String(i+1) + "\";\n";
 211         plugin += "      lv2:name \"Audio Input " + String(i+1) + "\";\n";
 212
 213         if (i == JucePlugin_MaxNumInputChannels-1) {
 214             plugin += "    ] ;\n\n";
 215         } else {
 216             plugin += "    ],\n";
 217         }
 218     }
 219
 220     for (i=0; i<JucePlugin_MaxNumOutputChannels; i++) {
 221         if (i == 0) {
 222             plugin += "    lv2:port [\n";
 223         } else {
 224             plugin += "    [\n";
 225         }
 226
 227         plugin += "      a lv2:OutputPort, lv2:AudioPort;\n";
 228         //plugin += "      lv2:datatype lv2:float;\n";
 229         plugin += "      lv2:index " + String(port_index++) + ";\n";
 230         plugin += "      lv2:symbol \"audio_out_" + String(i+1) + "\";\n";
 231         plugin += "      lv2:name \"Audio Output " + String(i+1) + "\";\n";
 232
 233         if (i == JucePlugin_MaxNumOutputChannels-1) {
 234             plugin += "    ] ;\n\n";
 235         } else {
 236             plugin += "    ],\n";
 237         }
 238     }
 239
 240     for (i=0; i < filter->getNumParameters(); i++) {
 241         if (i == 0) {
 242             plugin += "    lv2:port [\n";
 243         } else {
 244             plugin += "    [\n";
 245         }
 246
 247         plugin += "      a lv2:InputPort;\n";
 248         plugin += "      a lv2:ControlPort;\n";
 249         //plugin += "      lv2:datatype lv2:float;\n";
 250         plugin += "      lv2:index " + String(port_index++) + ";\n";
 251         plugin += "      lv2:symbol \"" + name_to_symbol(filter->getParameterName(i), i) + "\";\n";
 252         plugin += "      lv2:name \"" + filter->getParameterName(i) + "\";\n";
 253         plugin += "      lv2:default " + float_to_string(filter->getParameter(i)) + ";\n";
 254         plugin += "      lv2:minimum 0.0;\n";
 255         plugin += "      lv2:maximum 1.0;\n";
 256
 257         if (i == filter->getNumParameters()-1) {
 258             plugin += "    ] ;\n\n";
 259         } else {
 260             plugin += "    ],\n";
 261         }
 262     }
 263
 264     plugin += "    doap:name \"" + String(JucePlugin_Name) + "\" ;\n";
 265     plugin += "    doap:creator \"" + String(JucePlugin_Manufacturer) + "\" .\n";
 266
 267     delete filter;
 268     return plugin;
 269 }
 270
 271 void generate_ttl()
 272 {
 273     String URI = get_uri();
 274     String Binary = get_binary_name();
 275     String BinaryTTL = Binary + ".ttl";
 276
 277     std::cout << "Writing manifest.ttl...";
 278     std::fstream manifest("manifest.ttl", std::ios::out);
 279     manifest << get_manifest_ttl(URI, Binary) << std::endl;
 280     manifest.close();
 281     std::cout << " done!" << std::endl;
 282
 283     std::cout << "Writing " << BinaryTTL << "...";
 284     std::fstream plugin(BinaryTTL.toUTF8(), std::ios::out);
 285     plugin << get_plugin_ttl(URI, Binary) << std::endl;
 286     plugin.close();
 287     std::cout << " done!" << std::endl;
 288 }
 289
 290 //==============================================================================
 291 BEGIN_JUCE_NAMESPACE
 292  //extern void juce_callAnyTimersSynchronously();
 293
 294  #if JUCE_MAC
 295   extern void initialiseMac();
 296  #endif
 297 END_JUCE_NAMESPACE
 298
 299 //==============================================================================
 300 #if JUCE_LINUX
 301
 302 class SharedMessageThread : public Thread
 303 {
 304 public:
 305     SharedMessageThread()
 306       : Thread ("Lv2MessageThread"),
 307         initialised (false)
 308     {
 309         startThread (7);
 310
 311         while (! initialised)
 312             sleep (1);
 313     }
 314
 315     ~SharedMessageThread()
 316     {
 317         signalThreadShouldExit();
 318         JUCEApplication::quit();
 319         waitForThreadToExit (5000);
 320         clearSingletonInstance();
 321     }
 322
 323     void run()
 324     {
 325         initialiseJuce_GUI();
 326         initialised = true;
 327
 328         MessageManager::getInstance()->setCurrentThreadAsMessageThread();
 329
 330         while ((! threadShouldExit()) && MessageManager::getInstance()->runDispatchLoopUntil (250))
 331         {}
 332     }
 333
 334     juce_DeclareSingleton (SharedMessageThread, false);
 335
 336 private:
 337     bool initialised;
 338 };
 339
 340 juce_ImplementSingleton (SharedMessageThread)
 341
 342 #endif
 343
 344 static Array<void*> activePlugins;
 345
 346 //==============================================================================
 347 // Create a new JUCE LV2 Plugin
 348 class JuceLV2Wrapper : private Timer
 349 {
 350 public:
 351     JuceLV2Wrapper(const LV2_Descriptor* descriptor_, double sample_rate_, const LV2_Feature* const* features) :
 352             chunkMemoryTime (0),
 353             numInChans (JucePlugin_MaxNumInputChannels),
 354             numOutChans (JucePlugin_MaxNumOutputChannels),
 355             isProcessing (false),
 356             firstProcessCallback (true),
 357             descriptor (descriptor_),
 358             sample_rate (sample_rate_),
 359             buffer_size (512),
 360             midi_uri_id (0),
 361             port_count (0)
 362     {
 363         printf("JuceLV2Wrapper()\n");
 364
 365         JUCE_AUTORELEASEPOOL;
 366         initialiseJuce_GUI();
 367
 368 #if JUCE_LINUX
 369         MessageManagerLock mmLock;
 370 #endif
 371
 372         filter = createPluginFilter();
 373         jassert(filter != nullptr);
 374
 375         filter->setPlayConfigDetails(numInChans, numOutChans, 0, 0);
 376
 377         // Port count
 378 #if JucePlugin_WantsMidiInput
 379         port_count += 1;
 380 #endif
 381 #if JucePlugin_ProducesMidiOutput
 382         port_count += 1;
 383 #endif
 384         port_count += numInChans;
 385         port_count += numOutChans;
 386         port_count += filter->getNumParameters();
 387
 388         // Set Port data
 389         port_min = nullptr;
 390         port_mout = nullptr;
 391         ports_ctrl.insertMultiple(0, nullptr, filter->getNumParameters());
 392         ports_ctrl_last.insertMultiple(0, 0.0f, filter->getNumParameters());
 393
 394         for (int i=0; i < numInChans; i++) {
 395             ports_ain[i] = nullptr;
 396         }
 397
 398         for (int i=0; i < numOutChans; i++) {
 399             ports_aout[i] = nullptr;
 400         }
 401
 402         for (int i=0; i < filter->getNumParameters(); i++) {
 403             ports_ctrl_last.set(i, filter->getParameter(i));
 404         }
 405
 406         // Get MIDI URI Id
 407         for (uint16_t j = 0; features[j]; j++)
 408         {
 409             if (strcmp(features[j]->URI, LV2_URI_MAP_URI) == 0)
 410             {
 411                 LV2_URI_Map_Feature* uri_feature = (LV2_URI_Map_Feature*)features[j]->data;
 412                 midi_uri_id = uri_feature->uri_to_id(uri_feature->callback_data, LV2_EVENT_URI, "http://lv2plug.in/ns/ext/midi#MidiEvent");
 413                 break;
 414             }
 415         }
 416
 417         activePlugins.add (this);
 418
 419         startTimer(1000);
 420     }
 421
 422     ~JuceLV2Wrapper()
 423     {
 424         JUCE_AUTORELEASEPOOL
 425
 426         {
 427 #if JUCE_LINUX
 428             MessageManagerLock mmLock;
 429 #endif
 430             stopTimer();
 431
 432             delete filter;
 433             filter = nullptr;
 434
 435             channels.free();
 436             deleteTempChannels();
 437
 438             ports_ctrl.clear();
 439             ports_ctrl_last.clear();
 440
 441             jassert (activePlugins.contains (this));
 442             activePlugins.removeValue (this);
 443         }
 444
 445         if (activePlugins.size() == 0)
 446         {
 447 #if JUCE_LINUX
 448             SharedMessageThread::deleteInstance();
 449 #endif
 450             shutdownJuce_GUI();
 451         }
 452     }
 453
 454     //==============================================================================
 455     // LV2 Descriptor Calls
 456     void do_connect_port(uint32_t port, void* data_location)
 457     {
 458         if (port < port_count)
 459         {
 460             int i;
 461             uint32_t index = 0;
 462
 463 #if JucePlugin_WantsMidiInput
 464             if (port == index) {
 465                 port_min = (LV2_Event_Buffer*)data_location;
 466                 return;
 467             }
 468             index += 1;
 469 #endif
 470
 471 #if JucePlugin_ProducesMidiOutput
 472             if (port == index) {
 473                 port_mout = (LV2_Event_Buffer*)data_location;
 474                 return;
 475             }
 476             index += 1;
 477 #endif
 478
 479             for (i=0; i < numInChans; i++) {
 480                 if (port == index) {
 481                     ports_ain[i] = (float*)data_location;
 482                     return;
 483                 }
 484                 index += 1;
 485             }
 486
 487             for (i=0; i < numOutChans; i++) {
 488                 if (port == index) {
 489                     ports_aout[i] = (float*)data_location;
 490                     return;
 491                 }
 492                 index += 1;
 493             }
 494
 495             for (i=0; i < filter->getNumParameters(); i++) {
 496                 if (port == index) {
 497                     ports_ctrl.set(i, (float*)data_location);
 498                     return;
 499                 }
 500                 index += 1;
 501             }
 502         }
 503     }
 504
 505     void do_activate()
 506     {
 507         if (filter != nullptr)
 508         {
 509             isProcessing = true;
 510             channels.calloc (numInChans + numOutChans);
 511
 512             jassert (sample_rate > 0);
 513             if (sample_rate <= 0.0)
 514                 sample_rate = 44100.0;
 515
 516             jassert (buffer_size > 0);
 517
 518             firstProcessCallback = true;
 519
 520             filter->setNonRealtime (false);
 521             filter->setPlayConfigDetails (numInChans, numOutChans, sample_rate, buffer_size);
 522
 523             deleteTempChannels();
 524
 525             filter->prepareToPlay (sample_rate, buffer_size);
 526
 527             midiEvents.ensureSize (2048);
 528             midiEvents.clear();
 529         }
 530     }
 531
 532     void do_deactivate()
 533     {
 534         if (filter != nullptr)
 535         {
 536             filter->releaseResources();
 537
 538             isProcessing = false;
 539             channels.free();
 540
 541             deleteTempChannels();
 542         }
 543     }
 544
 545     void do_run(uint32_t sample_count)
 546     {
 547         if (firstProcessCallback)
 548         {
 549             firstProcessCallback = false;
 550
 551             // if this fails, the host hasn't called resume() before processing
 552             jassert (isProcessing);
 553
 554             // (tragically, some hosts actually need this, although it's stupid to have
 555             //  to do it here..)
 556             if (! isProcessing)
 557                 do_activate();
 558
 559             filter->setNonRealtime (false);
 560
 561            #if JUCE_WINDOWS
 562             if (GetThreadPriority (GetCurrentThread()) <= THREAD_PRIORITY_NORMAL
 563                   && GetThreadPriority (GetCurrentThread()) >= THREAD_PRIORITY_LOWEST)
 564                 filter->setNonRealtime (true);
 565            #endif
 566         }
 567
 568         // Check if buffer size changed
 569         if (buffer_size != sample_count)
 570         {
 571             buffer_size = sample_count;
 572             filter->setPlayConfigDetails(numInChans, numOutChans, sample_rate, buffer_size);
 573             filter->prepareToPlay(sample_rate, buffer_size);
 574         }
 575
 576         // Check for updated parameters
 577         float cur_value;
 578         for (int i = 0; i < ports_ctrl.size(); i++)
 579         {
 580             if (ports_ctrl[i] != nullptr)
 581             {
 582                 cur_value = *(float*)ports_ctrl[i];
 583                 if (ports_ctrl_last[i] != cur_value) {
 584                     filter->setParameter(i, cur_value);
 585                     ports_ctrl_last.setUnchecked(i, cur_value);
 586                 }
 587             }
 588         }
 589
 590         jassert (activePlugins.contains (this));
 591
 592         {
 593             const ScopedLock sl (filter->getCallbackLock());
 594
 595             const int numIn = numInChans;
 596             const int numOut = numOutChans;
 597
 598             if (filter->isSuspended())
 599             {
 600                 for (int i = 0; i < numOut; ++i)
 601                     zeromem (ports_aout[i], sizeof (float) * sample_count);
 602             }
 603             else
 604             {
 605                 int i;
 606                 for (i = 0; i < numOut; ++i)
 607                 {
 608                     float* chan = tempChannels.getUnchecked(i);
 609
 610                     if (chan == 0)
 611                     {
 612                         chan = ports_aout[i];
 613
 614                         // if some output channels are disabled, some hosts supply the same buffer
 615                         // for multiple channels - this buggers up our method of copying the
 616                         // inputs over the outputs, so we need to create unique temp buffers in this case..
 617                         for (int j = i; --j >= 0;)
 618                         {
 619                             if (ports_aout[j] == chan)
 620                             {
 621                                 chan = new float [buffer_size * 2];
 622                                 tempChannels.set (i, chan);
 623                                 break;
 624                             }
 625                         }
 626                     }
 627
 628                     if (i < numIn && chan != ports_ain[i])
 629                         memcpy (chan, ports_ain[i], sizeof (float) * sample_count);
 630
 631                     channels[i] = chan;
 632                 }
 633
 634                 // LV2 MIDI Input
 635                 if (port_min != nullptr)
 636                 {
 637                     LV2_Event_Iterator iter;
 638                     lv2_event_begin(&iter, port_min);
 639
 640                     lv2_event_buffer_reset(port_min, LV2_EVENT_AUDIO_STAMP, (uint8_t*)(port_min + 1));
 641
 642                     for (uint32_t i=0; i < iter.buf->event_count; ++i) {
 643                         uint8_t* data;
 644                         LV2_Event* ev = lv2_event_get(&iter, &data);
 645                         midiEvents.addEvent(data, ev->size, ev->frames);
 646                         lv2_event_increment(&iter);
 647                     }
 648                 }
 649
 650                 for (; i < numIn; ++i)
 651                     channels[i] = ports_ain[i];
 652
 653                 AudioSampleBuffer chans (channels, jmax (numIn, numOut), sample_count);
 654
 655                 filter->processBlock (chans, midiEvents);
 656             }
 657         }
 658
 659         if (! midiEvents.isEmpty() && port_mout != nullptr)
 660         {
 661 #if JucePlugin_ProducesMidiOutput
 662             const int numEvents = midiEvents.getNumEvents();
 663
 664             LV2_Event_Iterator iter;
 665             lv2_event_buffer_reset(port_mout, LV2_EVENT_AUDIO_STAMP, (uint8_t*)(port_mout + 1));
 666             lv2_event_begin(&iter, port_mout);
 667
 668             const JUCE_NAMESPACE::uint8* midiEventData;
 669             int midiEventSize, midiEventPosition;
 670             MidiBuffer::Iterator i (midiEvents);
 671
 672             while (i.getNextEvent (midiEventData, midiEventSize, midiEventPosition))
 673             {
 674                 jassert (midiEventPosition >= 0 && midiEventPosition < sample_count);
 675
 676                 lv2_event_write(&iter, midiEventPosition, 0, midi_uri_id, midiEventSize, midiEventData);
 677             }
 678 #endif
 679             midiEvents.clear();
 680         }
 681     }
 682
 683     void do_cleanup()
 684     {
 685         stopTimer();
 686
 687 #if 0
 688         if (descriptor)
 689         {
 690             free((void*)descriptor->URI);
 691             delete descriptor;
 692         }
 693 #endif
 694     }
 695
 696     //==============================================================================
 697     // JUCE Stuff
 698
 699     AudioProcessor* getFilter() { return filter; }
 700
 701     //==============================================================================
 702     int32_t getChunk (void** data)
 703     {
 704         if (filter == nullptr)
 705             return 0;
 706
 707         chunkMemory.setSize (0);
 708         filter->getCurrentProgramStateInformation (chunkMemory);
 709
 710         *data = (void*) chunkMemory.getData();
 711
 712         // because the chunk is only needed temporarily by the host (or at least you'd
 713         // hope so) we'll give it a while and then free it in the timer callback.
 714         chunkMemoryTime = JUCE_NAMESPACE::Time::getApproximateMillisecondCounter();
 715
 716         return (int32_t) chunkMemory.getSize();
 717     }
 718
 719     void setChunk (void* data, int32_t byteSize)
 720     {
 721         if (filter == nullptr)
 722             return;
 723
 724         chunkMemory.setSize (0);
 725         chunkMemoryTime = 0;
 726
 727         if (byteSize > 0 && data != nullptr)
 728         {
 729             filter->setCurrentProgramStateInformation (data, byteSize);
 730         }
 731     }
 732
 733     void timerCallback()
 734     {
 735         if (chunkMemoryTime > 0 && chunkMemoryTime < JUCE_NAMESPACE::Time::getApproximateMillisecondCounter() - 2000)
 736         {
 737             chunkMemoryTime = 0;
 738             chunkMemory.setSize (0);
 739         }
 740     }
 741
 742     //==============================================================================
 743 private:
 744     AudioProcessor* filter;
 745     JUCE_NAMESPACE::MemoryBlock chunkMemory;
 746     JUCE_NAMESPACE::uint32 chunkMemoryTime;
 747     MidiBuffer midiEvents;
 748     int numInChans, numOutChans;
 749     bool isProcessing, firstProcessCallback;
 750     HeapBlock<float*> channels;
 751     Array<float*> tempChannels;  // see note in do_run()
 752
 753     const LV2_Descriptor* descriptor;
 754
 755     double sample_rate;
 756     int buffer_size;
 757     uint16_t midi_uri_id;
 758     uint32_t port_count;
 759
 760     LV2_Event_Buffer* port_min;
 761     LV2_Event_Buffer* port_mout;
 762     float* ports_ain[JucePlugin_MaxNumInputChannels];
 763     float* ports_aout[JucePlugin_MaxNumOutputChannels];
 764     Array<float*> ports_ctrl;
 765     Array<float> ports_ctrl_last;
 766
 767     //==============================================================================
 768     void deleteTempChannels()
 769     {
 770         for (int i = tempChannels.size(); --i >= 0;)
 771             delete[] (tempChannels.getUnchecked(i));
 772
 773         tempChannels.clear();
 774
 775         if (filter != nullptr)
 776             tempChannels.insertMultiple (0, 0, filter->getNumInputChannels() + filter->getNumOutputChannels());
 777     }
 778
 779     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (JuceLV2Wrapper);
 780 };
 781
 782 class JuceLv2ExternalUI;
 783 static Array<JuceLv2ExternalUI*> activeExternalUIs;
 784
 785 enum JUCE_EXTERNAL_UI_Flags {
 786     JUCE_EXTERNAL_UI_NONE = 0,
 787     JUCE_EXTERNAL_UI_RUN  = 0x1,
 788     JUCE_EXTERNAL_UI_SHOW = 0x2,
 789     JUCE_EXTERNAL_UI_HIDE = 0x4
 790 };
 791
 792 //==============================================================================
 793 // Create a new JUCE External UI
 794 class JuceLv2ExternalUI  : private Timer,
 795                            public DocumentWindow
 796 {
 797 public:
 798     JuceLv2ExternalUI (JuceLV2Wrapper* const wrapper_, AudioProcessorEditor* const editor_, lv2_external_ui_host* external_ui_host_, LV2UI_Controller controller_) :
 799         DocumentWindow("", Colours::white, DocumentWindow::minimiseButton | DocumentWindow::closeButton, true),
 800             wrapper(wrapper_),
 801             editor(editor_),
 802             external_ui_host(external_ui_host_),
 803             controller(controller_),
 804             do_ui_flags(JUCE_EXTERNAL_UI_NONE)
 805     {
 806         setOpaque (true);
 807         editor->setOpaque (true);
 808
 809         String title = external_ui_host->plugin_human_id != nullptr ? String(external_ui_host->plugin_human_id) : wrapper->getFilter()->getName();
 810         setName(title);
 811
 812         setTitleBarHeight (0);
 813         setDropShadowEnabled(false);
 814         setUsingNativeTitleBar(true);
 815
 816         setContentNonOwned(editor, true);
 817
 818         external_ui.run = do_external_ui_run;
 819         external_ui.show = do_external_ui_show;
 820         external_ui.hide = do_external_ui_hide;
 821
 822         activeExternalUIs.add(this);
 823
 824         startTimer(200);
 825     }
 826
 827     ~JuceLv2ExternalUI()
 828     {
 829         activeExternalUIs.removeValue(this);
 830     }
 831
 832     AudioProcessorEditor* getEditorComp() const
 833     {
 834         return dynamic_cast <AudioProcessorEditor*> (getContentComponent());
 835     }
 836
 837     void closeButtonPressed()
 838     {
 839         delete this;
 840         external_ui_host->ui_closed(controller);
 841     }
 842
 843     void timerCallback()
 844     {
 845         if (do_ui_flags & JUCE_EXTERNAL_UI_SHOW)
 846             setVisible(true);
 847
 848         if (do_ui_flags & JUCE_EXTERNAL_UI_HIDE)
 849             setVisible(false);
 850
 851         if (do_ui_flags & JUCE_EXTERNAL_UI_RUN)
 852         {
 853             editor->repaint();
 854             repaint();
 855         }
 856
 857         do_ui_flags = JUCE_EXTERNAL_UI_NONE;
 858     }
 859
 860     //==============================================================================
 861     static void do_external_ui_run(lv2_external_ui* _this_)
 862     {
 863         for (int i = 0; i < activeExternalUIs.size(); i++)
 864         {
 865             JuceLv2ExternalUI* Lv2UI = (JuceLv2ExternalUI*)activeExternalUIs.getUnchecked(i);
 866             if (Lv2UI->getLv2Widget() == _this_)
 867             {
 868                 Lv2UI->setUiFlag(JUCE_EXTERNAL_UI_RUN);
 869                 break;
 870             }
 871         }
 872     }
 873
 874     static void do_external_ui_show(lv2_external_ui* _this_)
 875     {
 876         for (int i = 0; i < activeExternalUIs.size(); i++)
 877         {
 878             JuceLv2ExternalUI* Lv2UI = (JuceLv2ExternalUI*)activeExternalUIs.getUnchecked(i);
 879             if (Lv2UI->getLv2Widget() == _this_)
 880             {
 881                 Lv2UI->setUiFlag(JUCE_EXTERNAL_UI_SHOW);
 882                 break;
 883             }
 884         }
 885     }
 886
 887     static void do_external_ui_hide(lv2_external_ui* _this_)
 888     {
 889         for (int i = 0; i < activeExternalUIs.size(); i++)
 890         {
 891             JuceLv2ExternalUI* Lv2UI = (JuceLv2ExternalUI*)activeExternalUIs.getUnchecked(i);
 892             if (Lv2UI->getLv2Widget() == _this_)
 893             {
 894                 Lv2UI->setUiFlag(JUCE_EXTERNAL_UI_HIDE);
 895                 break;
 896             }
 897         }
 898     }
 899
 900     LV2UI_Widget getLv2Widget()
 901     {
 902         return &external_ui;
 903     }
 904
 905     void setUiFlag(JUCE_EXTERNAL_UI_Flags flags)
 906     {
 907         do_ui_flags = flags;
 908     }
 909
 910 private:
 911     JuceLV2Wrapper* wrapper;
 912     AudioProcessorEditor* editor;
 913
 914     lv2_external_ui external_ui;
 915     lv2_external_ui_host* external_ui_host;
 916     LV2UI_Controller controller;
 917
 918     JUCE_EXTERNAL_UI_Flags do_ui_flags;
 919
 920     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (JuceLv2ExternalUI);
 921 };
 922
 923 //==============================================================================
 924 // Create a new JUCE Editor
 925 class JuceLv2Editor : public AudioProcessorListener
 926 {
 927 public:
 928     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, bool isExternalUI) :
 929             wrapper(wrapper_),
 930             externalUI(nullptr),
 931             ui_descriptor(ui_descriptor_),
 932             write_function(write_function_),
 933             controller(controller_),
 934             editor(nullptr)
 935     {
 936         filter = wrapper->getFilter();
 937         filter->addListener(this);
 938
 939         if (filter != nullptr && filter->hasEditor())
 940         {
 941             printf("TEST - Before\n");
 942             editor = filter->createEditorIfNeeded();
 943             printf("TEST - After\n");
 944         }
 945
 946         if (editor != nullptr)
 947         {
 948             if (isExternalUI)
 949             {
 950                 // External UI
 951                 lv2_external_ui_host* external_ui_host = nullptr;
 952
 953                 for (uint16_t j = 0; features[j]; j++)
 954                 {
 955                     if (strcmp(features[j]->URI, LV2_EXTERNAL_UI_URI) == 0 && features[j]->data != nullptr)
 956                     {
 957                         external_ui_host = (lv2_external_ui_host*)features[j]->data;
 958                         break;
 959                     }
 960                 }
 961
 962                 if (external_ui_host)
 963                 {
 964                     externalUI = new JuceLv2ExternalUI(wrapper, editor, external_ui_host, controller);
 965                     *widget = externalUI->getLv2Widget();
 966                 }
 967                 else
 968                 {
 969                     widget = nullptr;
 970                     std::cerr << "Failed to init external UI" << std::cout;
 971                 }
 972             }
 973             else
 974             {
 975                 // JUCE UI
 976                 editor->setOpaque (true);
 977                 editor->setVisible (true);
 978                 *widget = editor;
 979             }
 980         }
 981         else
 982         {
 983             widget = nullptr;
 984             std::cerr << "Failed to init UI" << std::cout;
 985         }
 986
 987         // Padding for control ports
 988         ctrl_pad = 0;
 989 #if JucePlugin_WantsMidiInput
 990         ctrl_pad += 1;
 991 #endif
 992 #if JucePlugin_ProducesMidiOutput
 993         ctrl_pad += 1;
 994 #endif
 995         ctrl_pad += JucePlugin_MaxNumInputChannels;
 996         ctrl_pad += JucePlugin_MaxNumOutputChannels;
 997     }
 998
 999     ~JuceLv2Editor()
1000     {
1001         JUCE_AUTORELEASEPOOL
1002         PopupMenu::dismissAllActiveMenus();
1003
1004         filter->removeListener(this);
1005         filter->editorBeingDeleted (editor);
1006
1007         if (externalUI != nullptr)
1008             delete externalUI;
1009
1010         //if (editor != nullptr)
1011         //    deleteAndZero (editor);
1012     }
1013
1014     void do_port_event(uint32_t port_index, float value)
1015     {
1016         filter->setParameter(port_index-ctrl_pad, value);
1017     }
1018
1019     void do_cleanup()
1020     {
1021         // We should only do this after UI gets working
1022 #if 0
1023         if (ui_descriptor)
1024         {
1025             free((void*)ui_descriptor->URI);
1026             delete ui_descriptor;
1027         }
1028 #endif
1029     }
1030
1031     //==============================================================================
1032     void audioProcessorParameterChanged (AudioProcessor*, int index, float newValue)
1033     {
1034         if (controller && write_function)
1035             write_function(controller, index+ctrl_pad, sizeof(float), 0, &newValue);
1036     }
1037
1038     void audioProcessorChanged (AudioProcessor*) {}
1039
1040 private:
1041     JuceLV2Wrapper* wrapper;
1042     JuceLv2ExternalUI* externalUI;
1043     AudioProcessor* filter;
1044     AudioProcessorEditor* editor;
1045
1046     const LV2UI_Descriptor* ui_descriptor;
1047     LV2UI_Write_Function write_function;
1048     LV2UI_Controller controller;
1049
1050     int32_t ctrl_pad;
1051
1052     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (JuceLv2Editor);
1053 };
1054
1055 //==============================================================================
1056 // LV2 descriptor functions
1057 LV2_Handle juce_lv2_instantiate(const LV2_Descriptor* descriptor, double sample_rate, const char* bundle_path, const LV2_Feature* const* features)
1058 {
1059     JuceLV2Wrapper* wrapper = new JuceLV2Wrapper(descriptor, sample_rate, features);
1060     return wrapper;
1061 }
1062
1063 void juce_lv2_connect_port(LV2_Handle instance, uint32_t port, void* data_location)
1064 {
1065     JuceLV2Wrapper* wrapper = (JuceLV2Wrapper*)instance;
1066     wrapper->do_connect_port(port, data_location);
1067 }
1068
1069 void juce_lv2_activate(LV2_Handle instance)
1070 {
1071     JuceLV2Wrapper* wrapper = (JuceLV2Wrapper*)instance;
1072     wrapper->do_activate();
1073 }
1074
1075 void juce_lv2_run(LV2_Handle instance, uint32_t sample_count)
1076 {
1077     JuceLV2Wrapper* wrapper = (JuceLV2Wrapper*)instance;
1078     wrapper->do_run(sample_count);
1079 }
1080
1081 void juce_lv2_deactivate(LV2_Handle instance)
1082 {
1083     JuceLV2Wrapper* wrapper = (JuceLV2Wrapper*)instance;
1084     wrapper->do_deactivate();
1085 }
1086
1087 void juce_lv2_cleanup(LV2_Handle instance)
1088 {
1089     JuceLV2Wrapper* wrapper = (JuceLV2Wrapper*)instance;
1090     wrapper->do_cleanup();
1091     delete wrapper;
1092 }
1093
1094 const void* juce_lv2_extension_data(const char* uri)
1095 {
1096     printf("TODO :: juce_lv2_extension_data()\n");
1097     return nullptr;
1098 }
1099
1100 //==============================================================================
1101 LV2UI_Handle juce_lv2ui_instantiate(const LV2UI_Descriptor* descriptor, LV2UI_Write_Function write_function, LV2UI_Controller controller, LV2UI_Widget* widget, const LV2_Feature* const* features, bool isExternalUI)
1102 {
1103     const MessageManagerLock mmLock;
1104
1105     for (uint16_t i = 0; features[i]; i++)
1106     {
1107         if (strcmp(features[i]->URI, LV2_INSTANCE_ACCESS_URI) == 0 && features[i]->data != nullptr)
1108         {
1109             JuceLV2Wrapper* wrapper = (JuceLV2Wrapper*)features[i]->data;
1110             JuceLv2Editor* editor = new JuceLv2Editor(wrapper, descriptor, write_function, controller, widget, features, isExternalUI);
1111             return editor;
1112         }
1113     }
1114
1115     std::cerr << "Host does not support instance data - cannot use UI" << std::cout;
1116     return nullptr;
1117 }
1118
1119 LV2UI_Handle juce_lv2ui_instantiate_JUCE(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)
1120 {
1121     return juce_lv2ui_instantiate(descriptor, write_function, controller, widget, features, false);
1122 }
1123
1124 LV2UI_Handle juce_lv2ui_instantiate_external(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)
1125 {
1126     return juce_lv2ui_instantiate(descriptor, write_function, controller, widget, features, true);
1127 }
1128
1129 void juce_lv2ui_port_event(LV2UI_Handle instance, uint32_t port_index, uint32_t buffer_size, uint32_t format, const void* buffer)
1130 {
1131     const MessageManagerLock mmLock;
1132     JuceLv2Editor* editor = (JuceLv2Editor*)instance;
1133
1134     if (buffer_size == sizeof(float) && format == 0)
1135     {
1136         float value = *(float*)buffer;
1137         editor->do_port_event(port_index, value);
1138     }
1139 }
1140
1141 void juce_lv2ui_cleanup(LV2UI_Handle instance)
1142 {
1143     const MessageManagerLock mmLock;
1144     JuceLv2Editor* editor = (JuceLv2Editor*)instance;
1145     editor->do_cleanup();
1146     delete editor;
1147 }
1148
1149 //==============================================================================
1150 // Create new LV2 objects
1151 LV2_Descriptor* getNewLv2Plugin()
1152 {
1153     LV2_Descriptor* const Lv2Plugin = new LV2_Descriptor;
1154     Lv2Plugin->URI = strdup((const char*) get_uri().toUTF8());
1155     Lv2Plugin->instantiate = juce_lv2_instantiate;
1156     Lv2Plugin->connect_port = juce_lv2_connect_port;
1157     Lv2Plugin->activate = juce_lv2_activate;
1158     Lv2Plugin->run = juce_lv2_run;
1159     Lv2Plugin->deactivate = juce_lv2_deactivate;
1160     Lv2Plugin->cleanup = juce_lv2_cleanup;
1161     Lv2Plugin->extension_data = juce_lv2_extension_data;
1162     return Lv2Plugin;
1163 }
1164
1165 LV2UI_Descriptor* getNewLv2UI_JUCE()
1166 {
1167     LV2UI_Descriptor* Lv2UI = new LV2UI_Descriptor;
1168     Lv2UI->URI = strdup((const char*) get_juce_ui_uri().toUTF8());
1169     Lv2UI->instantiate = juce_lv2ui_instantiate_JUCE;
1170     Lv2UI->cleanup = juce_lv2ui_cleanup;
1171     Lv2UI->port_event = juce_lv2ui_port_event;
1172     Lv2UI->extension_data = juce_lv2_extension_data;
1173     return Lv2UI;
1174 }
1175
1176 LV2UI_Descriptor* getNewLv2UI_External()
1177 {
1178     LV2UI_Descriptor* Lv2UI = new LV2UI_Descriptor;
1179     Lv2UI->URI = strdup((const char*) get_external_ui_uri().toUTF8());
1180     Lv2UI->instantiate = juce_lv2ui_instantiate_external;
1181     Lv2UI->cleanup = juce_lv2ui_cleanup;
1182     Lv2UI->port_event = juce_lv2ui_port_event;
1183     Lv2UI->extension_data = juce_lv2_extension_data;
1184     return Lv2UI;
1185 }
1186
1187 LV2UI_Descriptor* getNewLv2UI(bool external)
1188 {
1189     return external ? getNewLv2UI_External() : getNewLv2UI_JUCE();
1190 }
1191
1192 //==============================================================================
1193 // Mac startup code..
1194 #if JUCE_MAC
1195
1196     extern "C" __attribute__ ((visibility("default"))) void juce_lv2_ttl_generator()
1197     {
1198         generate_ttl();
1199     }
1200
1201     extern "C" __attribute__ ((visibility("default"))) const LV2_Descriptor* lv2_descriptor(uint32_t index)
1202     {
1203         initialiseMac();
1204         return (index == 0) ? getNewLv2Plugin() : nullptr;
1205     }
1206
1207     extern "C" __attribute__ ((visibility("default"))) const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index)
1208     {
1209         return (index <= 1) ? getNewLv2UI((index == 1)) : nullptr;
1210     }
1211
1212 //==============================================================================
1213 // Linux startup code..
1214 #elif JUCE_LINUX
1215
1216     extern "C" __attribute__ ((visibility("default"))) void juce_lv2_ttl_generator()
1217     {
1218         generate_ttl();
1219     }
1220
1221     extern "C" __attribute__ ((visibility("default"))) const LV2_Descriptor* lv2_descriptor(uint32_t index)
1222     {
1223         SharedMessageThread::getInstance();
1224         return (index == 0) ? getNewLv2Plugin() : nullptr;
1225     }
1226
1227     extern "C" __attribute__ ((visibility("default"))) const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index)
1228     {
1229         return (index <= 1) ? getNewLv2UI((index == 1)) : nullptr;
1230     }
1231
1232     // don't put initialiseJuce_GUI or shutdownJuce_GUI in these... it will crash!
1233     __attribute__((constructor)) void myPluginInit() {}
1234     __attribute__((destructor))  void myPluginFini() {}
1235
1236 //==============================================================================
1237 // Win32 startup code..
1238 #else
1239
1240     extern "C" __declspec (dllexport) void juce_lv2_ttl_generator()
1241     {
1242         generate_ttl();
1243     }
1244
1245     extern "C" __declspec (dllexport) const LV2_Descriptor* lv2_descriptor(uint32_t index)
1246     {
1247         return (index == 0) ? getNewLv2Plugin() : nullptr;
1248     }
1249
1250     extern "C" __declspec (dllexport) const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index)
1251     {
1252         return (index <= 1) ? getNewLv2UI((index == 1)) : nullptr;
1253     }
1254
1255 #endif
1256
1257 #endif