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 #if 0
 162         plugin += "<" + get_juce_ui_uri() + ">\n";
 163         plugin += "    a lv2ui:JUCEUI ;\n";
 164         plugin += "    lv2ui:binary <" + Binary + ".so> .\n";
 165 #endif
 166         plugin += "<" + get_external_ui_uri() + ">\n";
 167         plugin += "    a lv2ui:external ;\n";
 168         plugin += "    lv2ui:binary <" + Binary + ".so> .\n";
 169         plugin += "\n";
 170     }
 171
 172     plugin += "<" + URI + ">\n";
 173     plugin += "    a " + get_plugin_type() + " ;\n";
 174
 175     if (filter->hasEditor()) {
 176 #if 0
 177         plugin += "    lv2ui:ui <" + get_juce_ui_uri() + ">;\n";
 178 #endif
 179         plugin += "    lv2ui:ui <" + get_external_ui_uri() + ">;\n";
 180     }
 181
 182     plugin += "\n";
 183
 184 #if JucePlugin_WantsMidiInput
 185     plugin += "    lv2:port [\n";
 186     plugin += "      a lv2:InputPort, lv2ev:EventPort;\n";
 187     plugin += "      lv2ev:supportsEvent <http://lv2plug.in/ns/ext/midi#MidiEvent> ;\n";
 188     plugin += "      lv2:index " + String(port_index++) + ";\n";
 189     plugin += "      lv2:symbol \"midi_in\";\n";
 190     plugin += "      lv2:name \"MIDI Input\";\n";
 191     plugin += "    ] ;\n\n";
 192 #endif
 193
 194 #if JucePlugin_ProducesMidiOutput
 195     plugin += "    lv2:port [\n";
 196     plugin += "      a lv2:OutputPort, lv2ev:EventPort;\n";
 197     plugin += "      lv2ev:supportsEvent <http://lv2plug.in/ns/ext/midi#MidiEvent> ;\n";
 198     plugin += "      lv2:index " + String(port_index++) + ";\n";
 199     plugin += "      lv2:symbol \"midi_out\";\n";
 200     plugin += "      lv2:name \"MIDI Output\";\n";
 201     plugin += "    ] ;\n\n";
 202 #endif
 203
 204     for (i=0; i<JucePlugin_MaxNumInputChannels; i++) {
 205         if (i == 0) {
 206             plugin += "    lv2:port [\n";
 207         } else {
 208             plugin += "    [\n";
 209         }
 210
 211         plugin += "      a lv2:InputPort, lv2:AudioPort;\n";
 212         //plugin += "      lv2:datatype lv2:float;\n";
 213         plugin += "      lv2:index " + String(port_index++) + ";\n";
 214         plugin += "      lv2:symbol \"audio_in_" + String(i+1) + "\";\n";
 215         plugin += "      lv2:name \"Audio Input " + String(i+1) + "\";\n";
 216
 217         if (i == JucePlugin_MaxNumInputChannels-1) {
 218             plugin += "    ] ;\n\n";
 219         } else {
 220             plugin += "    ],\n";
 221         }
 222     }
 223
 224     for (i=0; i<JucePlugin_MaxNumOutputChannels; i++) {
 225         if (i == 0) {
 226             plugin += "    lv2:port [\n";
 227         } else {
 228             plugin += "    [\n";
 229         }
 230
 231         plugin += "      a lv2:OutputPort, lv2:AudioPort;\n";
 232         //plugin += "      lv2:datatype lv2:float;\n";
 233         plugin += "      lv2:index " + String(port_index++) + ";\n";
 234         plugin += "      lv2:symbol \"audio_out_" + String(i+1) + "\";\n";
 235         plugin += "      lv2:name \"Audio Output " + String(i+1) + "\";\n";
 236
 237         if (i == JucePlugin_MaxNumOutputChannels-1) {
 238             plugin += "    ] ;\n\n";
 239         } else {
 240             plugin += "    ],\n";
 241         }
 242     }
 243
 244     for (i=0; i < filter->getNumParameters(); i++) {
 245         if (i == 0) {
 246             plugin += "    lv2:port [\n";
 247         } else {
 248             plugin += "    [\n";
 249         }
 250
 251         plugin += "      a lv2:InputPort;\n";
 252         plugin += "      a lv2:ControlPort;\n";
 253         //plugin += "      lv2:datatype lv2:float;\n";
 254         plugin += "      lv2:index " + String(port_index++) + ";\n";
 255         plugin += "      lv2:symbol \"" + name_to_symbol(filter->getParameterName(i), i) + "\";\n";
 256         plugin += "      lv2:name \"" + filter->getParameterName(i) + "\";\n";
 257         plugin += "      lv2:default " + float_to_string(filter->getParameter(i)) + ";\n";
 258         plugin += "      lv2:minimum 0.0;\n";
 259         plugin += "      lv2:maximum 1.0;\n";
 260
 261         if (i == filter->getNumParameters()-1) {
 262             plugin += "    ] ;\n\n";
 263         } else {
 264             plugin += "    ],\n";
 265         }
 266
 267         port_index++;
 268     }
 269
 270     plugin += "    doap:name \"" + String(JucePlugin_Name) + "\" ;\n";
 271     plugin += "    doap:creator \"" + String(JucePlugin_Manufacturer) + "\" .\n";
 272
 273     delete filter;
 274     return plugin;
 275 }
 276
 277 void generate_ttl()
 278 {
 279     String URI = get_uri();
 280     String Binary = get_binary_name();
 281     String BinaryTTL = Binary + ".ttl";
 282
 283     std::cout << "Writing manifest.ttl...";
 284     std::fstream manifest("manifest.ttl", std::ios::out);
 285     manifest << get_manifest_ttl(URI, Binary) << std::endl;
 286     manifest.close();
 287     std::cout << " done!" << std::endl;
 288
 289     std::cout << "Writing " << BinaryTTL << "...";
 290     std::fstream plugin(BinaryTTL.toUTF8(), std::ios::out);
 291     plugin << get_plugin_ttl(URI, Binary) << std::endl;
 292     plugin.close();
 293     std::cout << " done!" << std::endl;
 294 }
 295
 296 //==============================================================================
 297 BEGIN_JUCE_NAMESPACE
 298  extern void juce_callAnyTimersSynchronously();
 299
 300  #if JUCE_MAC
 301   extern void initialiseMac();
 302  #endif
 303 END_JUCE_NAMESPACE
 304
 305 //==============================================================================
 306 #if JUCE_LINUX
 307
 308 class SharedMessageThread : public Thread
 309 {
 310 public:
 311     SharedMessageThread()
 312       : Thread ("Lv2MessageThread"),
 313         initialised (false)
 314     {
 315         startThread (7);
 316
 317         while (! initialised)
 318             sleep (1);
 319     }
 320
 321     ~SharedMessageThread()
 322     {
 323         signalThreadShouldExit();
 324         JUCEApplication::quit();
 325         waitForThreadToExit (5000);
 326         clearSingletonInstance();
 327     }
 328
 329     void run()
 330     {
 331         initialiseJuce_GUI();
 332         initialised = true;
 333
 334         MessageManager::getInstance()->setCurrentThreadAsMessageThread();
 335
 336         while ((! threadShouldExit()) && MessageManager::getInstance()->runDispatchLoopUntil (250))
 337         {}
 338     }
 339
 340     juce_DeclareSingleton (SharedMessageThread, false);
 341
 342 private:
 343     bool initialised;
 344 };
 345
 346 juce_ImplementSingleton (SharedMessageThread)
 347
 348 #endif
 349
 350 static Array<void*> activePlugins;
 351
 352 //==============================================================================
 353 // Create a new JUCE LV2 Plugin
 354 class JuceLV2Wrapper :
 355         private Timer,
 356         public AudioProcessorListener
 357 {
 358 public:
 359     JuceLV2Wrapper(const LV2_Descriptor* descriptor_, double sample_rate_, const LV2_Feature* const* features) :
 360             chunkMemoryTime (0),
 361             numInChans (JucePlugin_MaxNumInputChannels),
 362             numOutChans (JucePlugin_MaxNumOutputChannels),
 363             isProcessing (false),
 364             firstProcessCallback (true),
 365             descriptor (descriptor_),
 366             sample_rate (sample_rate_),
 367             buffer_size (512),
 368             midi_uri_id (0),
 369             port_count (0)
 370     {
 371         printf("JuceLV2Wrapper()\n");
 372
 373         filter = createPluginFilter();
 374         jassert(filter != nullptr);
 375
 376         filter->setPlayConfigDetails(numInChans, numOutChans, 0, 0);
 377
 378         // Port count
 379 #if JucePlugin_WantsMidiInput
 380         port_count += 1;
 381 #endif
 382 #if JucePlugin_ProducesMidiOutput
 383         port_count += 1;
 384 #endif
 385         port_count += numInChans;
 386         port_count += numOutChans;
 387         port_count += filter->getNumParameters();
 388
 389         // Set Port data
 390         port_min = nullptr;
 391         port_mout = nullptr;
 392         ports_ctrl.insertMultiple(0, nullptr, filter->getNumParameters());
 393         ports_ctrl_last.insertMultiple(0, 0.0f, filter->getNumParameters());
 394
 395         for (int i=0; i < numInChans; i++) {
 396             ports_ain[i] = nullptr;
 397         }
 398
 399         for (int i=0; i < numOutChans; i++) {
 400             ports_aout[i] = nullptr;
 401         }
 402
 403         for (int i=0; i < filter->getNumParameters(); i++) {
 404             ports_ctrl_last.set(i, filter->getParameter(i));
 405         }
 406
 407         // Get MIDI URI Id
 408         for (uint16_t j = 0; features[j]; j++)
 409         {
 410             if (strcmp(features[j]->URI, LV2_URI_MAP_URI) == 0)
 411             {
 412                 LV2_URI_Map_Feature* uri_feature = (LV2_URI_Map_Feature*)features[j]->data;
 413                 midi_uri_id = uri_feature->uri_to_id(uri_feature->callback_data, LV2_EVENT_URI, "http://lv2plug.in/ns/ext/midi#MidiEvent");
 414                 break;
 415             }
 416         }
 417
 418         activePlugins.add (this);
 419
 420         startTimer(1000);
 421     }
 422
 423     ~JuceLV2Wrapper()
 424     {
 425         stopTimer();
 426
 427         delete filter;
 428         filter = nullptr;
 429
 430         channels.free();
 431         deleteTempChannels();
 432
 433         ports_ctrl.clear();
 434         ports_ctrl_last.clear();
 435
 436         jassert (activePlugins.contains (this));
 437         activePlugins.removeValue (this);
 438     }
 439
 440     //==============================================================================
 441     // LV2 Descriptor Calls
 442     void do_connect_port(uint32_t port, void* data_location)
 443     {
 444         if (port < port_count)
 445         {
 446             int i;
 447             uint32_t index = 0;
 448
 449 #if JucePlugin_WantsMidiInput
 450             if (port == index) {
 451                 port_min = (LV2_Event_Buffer*)data_location;
 452                 return;
 453             }
 454             index += 1;
 455 #endif
 456
 457 #if JucePlugin_ProducesMidiOutput
 458             if (port == index) {
 459                 port_mout = (LV2_Event_Buffer*)data_location;
 460                 return;
 461             }
 462             index += 1;
 463 #endif
 464
 465             for (i=0; i < numInChans; i++) {
 466                 if (port == index) {
 467                     ports_ain[i] = (float*)data_location;
 468                     return;
 469                 }
 470                 index += 1;
 471             }
 472
 473             for (i=0; i < numOutChans; i++) {
 474                 if (port == index) {
 475                     ports_aout[i] = (float*)data_location;
 476                     return;
 477                 }
 478                 index += 1;
 479             }
 480
 481             for (i=0; i < filter->getNumParameters(); i++) {
 482                 if (port == index) {
 483                     ports_ctrl.set(i, (float*)data_location);
 484                     return;
 485                 }
 486                 index += 1;
 487             }
 488         }
 489     }
 490
 491     void do_activate()
 492     {
 493         if (filter != nullptr)
 494         {
 495             isProcessing = true;
 496             channels.calloc (numInChans + numOutChans);
 497
 498             jassert (sample_rate > 0);
 499             if (sample_rate <= 0.0)
 500                 sample_rate = 44100.0;
 501
 502             jassert (buffer_size > 0);
 503
 504             firstProcessCallback = true;
 505
 506             filter->setNonRealtime (false);
 507             filter->setPlayConfigDetails (numInChans, numOutChans, sample_rate, buffer_size);
 508
 509             deleteTempChannels();
 510
 511             filter->prepareToPlay (sample_rate, buffer_size);
 512
 513             midiEvents.ensureSize (2048);
 514             midiEvents.clear();
 515         }
 516     }
 517
 518     void do_deactivate()
 519     {
 520         if (filter != nullptr)
 521         {
 522             filter->releaseResources();
 523
 524             isProcessing = false;
 525             channels.free();
 526
 527             deleteTempChannels();
 528         }
 529     }
 530
 531     void do_run(uint32_t sample_count)
 532     {
 533         if (firstProcessCallback)
 534         {
 535             firstProcessCallback = false;
 536
 537             // if this fails, the host hasn't called resume() before processing
 538             jassert (isProcessing);
 539
 540             // (tragically, some hosts actually need this, although it's stupid to have
 541             //  to do it here..)
 542             if (! isProcessing)
 543                 do_activate();
 544
 545             filter->setNonRealtime (false);
 546
 547            #if JUCE_WINDOWS
 548             if (GetThreadPriority (GetCurrentThread()) <= THREAD_PRIORITY_NORMAL
 549                   && GetThreadPriority (GetCurrentThread()) >= THREAD_PRIORITY_LOWEST)
 550                 filter->setNonRealtime (true);
 551            #endif
 552         }
 553
 554         // Check if buffer size changed
 555         if (buffer_size != sample_count)
 556         {
 557             buffer_size = sample_count;
 558             filter->setPlayConfigDetails(numInChans, numOutChans, sample_rate, buffer_size);
 559             filter->prepareToPlay(sample_rate, buffer_size);
 560         }
 561
 562         // Check for updated parameters
 563         float cur_value;
 564         for (int i = 0; i < ports_ctrl.size(); i++)
 565         {
 566             if (ports_ctrl[i] != nullptr)
 567             {
 568                 cur_value = *(float*)ports_ctrl[i];
 569                 if (ports_ctrl_last[i] != cur_value) {
 570                     filter->setParameter(i, cur_value);
 571                     ports_ctrl_last.setUnchecked(i, cur_value);
 572                 }
 573             }
 574         }
 575
 576         jassert (activePlugins.contains (this));
 577
 578         {
 579             const ScopedLock sl (filter->getCallbackLock());
 580
 581             const int numIn = numInChans;
 582             const int numOut = numOutChans;
 583
 584             if (filter->isSuspended())
 585             {
 586                 for (int i = 0; i < numOut; ++i)
 587                     zeromem (ports_aout[i], sizeof (float) * sample_count);
 588             }
 589             else
 590             {
 591                 int i;
 592                 for (i = 0; i < numOut; ++i)
 593                 {
 594                     float* chan = tempChannels.getUnchecked(i);
 595
 596                     if (chan == 0)
 597                     {
 598                         chan = ports_aout[i];
 599
 600                         // if some output channels are disabled, some hosts supply the same buffer
 601                         // for multiple channels - this buggers up our method of copying the
 602                         // inputs over the outputs, so we need to create unique temp buffers in this case..
 603                         for (int j = i; --j >= 0;)
 604                         {
 605                             if (ports_aout[j] == chan)
 606                             {
 607                                 chan = new float [buffer_size * 2];
 608                                 tempChannels.set (i, chan);
 609                                 break;
 610                             }
 611                         }
 612                     }
 613
 614                     if (i < numIn && chan != ports_ain[i])
 615                         memcpy (chan, ports_ain[i], sizeof (float) * sample_count);
 616
 617                     channels[i] = chan;
 618                 }
 619
 620                 // LV2 MIDI Input
 621                 if (port_min != nullptr)
 622                 {
 623                     LV2_Event_Iterator iter;
 624                     lv2_event_begin(&iter, port_min);
 625
 626                     lv2_event_buffer_reset(port_min, LV2_EVENT_AUDIO_STAMP, (uint8_t*)(port_min + 1));
 627
 628                     for (uint32_t i=0; i < iter.buf->event_count; ++i) {
 629                         uint8_t* data;
 630                         LV2_Event* ev = lv2_event_get(&iter, &data);
 631                         midiEvents.addEvent(data, ev->size, ev->frames);
 632                         lv2_event_increment(&iter);
 633                     }
 634                 }
 635
 636                 for (; i < numIn; ++i)
 637                     channels[i] = ports_ain[i];
 638
 639                 AudioSampleBuffer chans (channels, jmax (numIn, numOut), sample_count);
 640
 641                 filter->processBlock (chans, midiEvents);
 642             }
 643         }
 644
 645         if (! midiEvents.isEmpty() && port_mout != nullptr)
 646         {
 647 #if JucePlugin_ProducesMidiOutput
 648             const int numEvents = midiEvents.getNumEvents();
 649
 650             LV2_Event_Iterator iter;
 651             lv2_event_buffer_reset(port_mout, LV2_EVENT_AUDIO_STAMP, (uint8_t*)(port_mout + 1));
 652             lv2_event_begin(&iter, port_mout);
 653
 654             const JUCE_NAMESPACE::uint8* midiEventData;
 655             int midiEventSize, midiEventPosition;
 656             MidiBuffer::Iterator i (midiEvents);
 657
 658             while (i.getNextEvent (midiEventData, midiEventSize, midiEventPosition))
 659             {
 660                 jassert (midiEventPosition >= 0 && midiEventPosition < sample_count);
 661
 662                 lv2_event_write(&iter, midiEventPosition, 0, midi_uri_id, midiEventSize, midiEventData);
 663             }
 664 #endif
 665             midiEvents.clear();
 666         }
 667     }
 668
 669     void do_cleanup()
 670     {
 671         stopTimer();
 672
 673         //if (descriptor)
 674         //{
 675         //    free((void*)descriptor->URI);
 676         //    delete descriptor;
 677         //}
 678     }
 679
 680     //==============================================================================
 681     // JUCE Stuff
 682
 683     AudioProcessor* getFilter() { return filter; }
 684
 685     void audioProcessorParameterChanged (AudioProcessor*, int index, float newValue)
 686     {
 687         // TODO
 688     }
 689
 690     void audioProcessorChanged (AudioProcessor*)
 691     {
 692         // TODO
 693     }
 694
 695     //==============================================================================
 696     int32_t getChunk (void** data)
 697     {
 698         if (filter == nullptr)
 699             return 0;
 700
 701         chunkMemory.setSize (0);
 702         filter->getCurrentProgramStateInformation (chunkMemory);
 703
 704         *data = (void*) chunkMemory.getData();
 705
 706         // because the chunk is only needed temporarily by the host (or at least you'd
 707         // hope so) we'll give it a while and then free it in the timer callback.
 708         chunkMemoryTime = JUCE_NAMESPACE::Time::getApproximateMillisecondCounter();
 709
 710         return (int32_t) chunkMemory.getSize();
 711     }
 712
 713     void setChunk (void* data, int32_t byteSize)
 714     {
 715         if (filter == nullptr)
 716             return;
 717
 718         chunkMemory.setSize (0);
 719         chunkMemoryTime = 0;
 720
 721         if (byteSize > 0 && data != nullptr)
 722         {
 723             filter->setCurrentProgramStateInformation (data, byteSize);
 724         }
 725     }
 726
 727     void timerCallback()
 728     {
 729         if (chunkMemoryTime > 0 && chunkMemoryTime < JUCE_NAMESPACE::Time::getApproximateMillisecondCounter() - 2000)
 730         {
 731             chunkMemoryTime = 0;
 732             chunkMemory.setSize (0);
 733         }
 734     }
 735
 736     void doIdleCallback()
 737     {
 738         if (MessageManager::getInstance()->isThisTheMessageThread())
 739         {
 740             JUCE_AUTORELEASEPOOL
 741             juce_callAnyTimersSynchronously();
 742
 743             for (int i = ComponentPeer::getNumPeers(); --i >= 0;)
 744                 ComponentPeer::getPeer (i)->performAnyPendingRepaintsNow();
 745         }
 746     }
 747
 748     //==============================================================================
 749 private:
 750     AudioProcessor* filter;
 751     JUCE_NAMESPACE::MemoryBlock chunkMemory;
 752     JUCE_NAMESPACE::uint32 chunkMemoryTime;
 753     MidiBuffer midiEvents;
 754     int numInChans, numOutChans;
 755     bool isProcessing, firstProcessCallback;
 756     HeapBlock<float*> channels;
 757     Array<float*> tempChannels;  // see note in do_run()
 758
 759     const LV2_Descriptor* descriptor;
 760
 761     double sample_rate;
 762     int buffer_size;
 763     uint16_t midi_uri_id;
 764     uint32_t port_count;
 765
 766     LV2_Event_Buffer* port_min;
 767     LV2_Event_Buffer* port_mout;
 768     float* ports_ain[JucePlugin_MaxNumInputChannels];
 769     float* ports_aout[JucePlugin_MaxNumOutputChannels];
 770     Array<float*> ports_ctrl;
 771     Array<float> ports_ctrl_last;
 772
 773     //==============================================================================
 774     void deleteTempChannels()
 775     {
 776         for (int i = tempChannels.size(); --i >= 0;)
 777             delete[] (tempChannels.getUnchecked(i));
 778
 779         tempChannels.clear();
 780
 781         if (filter != nullptr)
 782             tempChannels.insertMultiple (0, 0, filter->getNumInputChannels() + filter->getNumOutputChannels());
 783     }
 784
 785     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (JuceLV2Wrapper);
 786 };
 787
 788 //==============================================================================
 789 // LV2 descriptor functions
 790 LV2_Handle juce_lv2_instantiate(const LV2_Descriptor* descriptor, double sample_rate, const char* bundle_path, const LV2_Feature* const* features)
 791 {
 792     JUCE_AUTORELEASEPOOL;
 793     initialiseJuce_GUI();
 794
 795 #if JUCE_LINUX
 796     MessageManagerLock mmLock;
 797 #endif
 798
 799     JuceLV2Wrapper* wrapper = new JuceLV2Wrapper(descriptor, sample_rate, features);
 800     return wrapper;
 801 }
 802
 803 void juce_lv2_connect_port(LV2_Handle instance, uint32_t port, void* data_location)
 804 {
 805     JuceLV2Wrapper* wrapper = (JuceLV2Wrapper*)instance;
 806     wrapper->do_connect_port(port, data_location);
 807 }
 808
 809 void juce_lv2_activate(LV2_Handle instance)
 810 {
 811     JuceLV2Wrapper* wrapper = (JuceLV2Wrapper*)instance;
 812     wrapper->do_activate();
 813 }
 814
 815 void juce_lv2_run(LV2_Handle instance, uint32_t sample_count)
 816 {
 817     JuceLV2Wrapper* wrapper = (JuceLV2Wrapper*)instance;
 818     wrapper->do_run(sample_count);
 819 }
 820
 821 void juce_lv2_deactivate(LV2_Handle instance)
 822 {
 823     JuceLV2Wrapper* wrapper = (JuceLV2Wrapper*)instance;
 824     wrapper->do_deactivate();
 825 }
 826
 827 void juce_lv2_cleanup(LV2_Handle instance)
 828 {
 829     JUCE_AUTORELEASEPOOL;
 830
 831 #if JUCE_LINUX
 832     MessageManagerLock mmLock;
 833 #endif
 834
 835     JuceLV2Wrapper* wrapper = (JuceLV2Wrapper*)instance;
 836     wrapper->do_cleanup();
 837     delete wrapper;
 838
 839     if (activePlugins.size() == 0)
 840     {
 841        #if JUCE_LINUX
 842         SharedMessageThread::deleteInstance();
 843        #endif
 844         shutdownJuce_GUI();
 845     }
 846 }
 847
 848 const void* juce_lv2_extension_data(const char* uri)
 849 {
 850     printf("TODO :: juce_lv2_extension_data()\n");
 851     return nullptr;
 852 }
 853
 854 //==============================================================================
 855 // Create new LV2 objects
 856 LV2_Descriptor* getNewLv2Plugin()
 857 {
 858     LV2_Descriptor* const Lv2Plugin = new LV2_Descriptor;
 859     Lv2Plugin->URI = strdup((const char*)get_uri().toUTF8());
 860     Lv2Plugin->instantiate = juce_lv2_instantiate;
 861     Lv2Plugin->connect_port = juce_lv2_connect_port;
 862     Lv2Plugin->activate = juce_lv2_activate;
 863     Lv2Plugin->run = juce_lv2_run;
 864     Lv2Plugin->deactivate = juce_lv2_deactivate;
 865     Lv2Plugin->cleanup = juce_lv2_cleanup;
 866     Lv2Plugin->extension_data = juce_lv2_extension_data;
 867     return Lv2Plugin;
 868 }
 869
 870 //==============================================================================
 871 // Mac startup code..
 872 #if JUCE_MAC
 873
 874     extern "C" __attribute__ ((visibility("default"))) void juce_lv2_ttl_generator()
 875     {
 876         generate_ttl();
 877     }
 878
 879     extern "C" __attribute__ ((visibility("default"))) const LV2_Descriptor* lv2_descriptor(uint32_t index)
 880     {
 881         initialiseMac();
 882         return (index == 0) ? getNewLv2Plugin() : nullptr;
 883     }
 884
 885 //==============================================================================
 886 // Linux startup code..
 887 #elif JUCE_LINUX
 888
 889     extern "C" __attribute__ ((visibility("default"))) void juce_lv2_ttl_generator()
 890     {
 891         generate_ttl();
 892     }
 893
 894     extern "C" __attribute__ ((visibility("default"))) const LV2_Descriptor* lv2_descriptor(uint32_t index)
 895     {
 896         SharedMessageThread::getInstance();
 897         return (index == 0) ? getNewLv2Plugin() : nullptr;
 898     }
 899
 900     // don't put initialiseJuce_GUI or shutdownJuce_GUI in these... it will crash!
 901     __attribute__((constructor)) void myPluginInit() {}
 902     __attribute__((destructor))  void myPluginFini() {}
 903
 904 //==============================================================================
 905 // Win32 startup code..
 906 #else
 907
 908     extern "C" __declspec (dllexport) void juce_lv2_ttl_generator()
 909     {
 910         generate_ttl();
 911     }
 912
 913     extern "C" __declspec (dllexport) const LV2_Descriptor* lv2_descriptor(uint32_t index)
 914     {
 915         return (index == 0) ? getNewLv2Plugin() : nullptr;
 916     }
 917
 918 #endif
 919
 920 #endif