juce/source/src/audio/plugin_client/VST/juce_VST_Wrapper.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #ifdef _MSC_VER
  27   #pragma warning (disable : 4996 4100)
  28 #endif
  29
  30 #ifdef _WIN32
  31  #include <windows.h>
  32 #elif defined (LINUX)
  33  #include <X11/Xlib.h>
  34  #include <X11/Xutil.h>
  35  #include <X11/Xatom.h>
  36  #undef KeyPress
  37 #else
  38  #include <Carbon/Carbon.h>
  39 #endif
  40
  41 #ifdef PRAGMA_ALIGN_SUPPORTED
  42  #undef PRAGMA_ALIGN_SUPPORTED
  43  #define PRAGMA_ALIGN_SUPPORTED 1
  44 #endif
  45
  46 #include "../juce_IncludeCharacteristics.h"
  47
  48 #if JucePlugin_Build_VST || 1
  49
  50 //==============================================================================
  51 /*  These files come with the Steinberg VST SDK - to get them, you'll need to
  52     visit the Steinberg website and jump through some hoops to sign up as a
  53     VST developer.
  54
  55     Then, you'll need to make sure your include path contains your "vstsdk2.3" or
  56     "vstsdk2.4" directory.
  57
  58     Note that the JUCE_USE_VSTSDK_2_4 macro should be defined in JucePluginCharacteristics.h
  59 */
  60 #if JUCE_USE_VSTSDK_2_4
  61  #ifdef __GNUC__
  62   #define __cdecl
  63  #endif
  64
  65  // VSTSDK V2.4 includes..
  66  #include <public.sdk/source/vst2.x/audioeffectx.h>
  67  #include <public.sdk/source/vst2.x/aeffeditor.h>
  68  #include <public.sdk/source/vst2.x/audioeffectx.cpp>
  69  #include <public.sdk/source/vst2.x/audioeffect.cpp>
  70
  71  #if ! VST_2_4_EXTENSIONS
  72   #error "You're probably trying to include the wrong VSTSDK version - make sure your include path matches the JUCE_USE_VSTSDK_2_4 flag"
  73  #endif
  74
  75 #else
  76  // VSTSDK V2.3 includes..
  77  #include <source/common/audioeffectx.h>
  78  #include <source/common/AEffEditor.hpp>
  79  #include <source/common/audioeffectx.cpp>
  80  #include <source/common/AudioEffect.cpp>
  81
  82  #if (! VST_2_3_EXTENSIONS) || VST_2_4_EXTENSIONS
  83   #error "You're probably trying to include the wrong VSTSDK version - make sure your include path matches the JUCE_USE_VSTSDK_2_4 flag"
  84  #endif
  85
  86  #define __aeffect__  // (needed for juce_VSTMidiEventList.h to work)
  87
  88  typedef long VstInt32;
  89  typedef long VstIntPtr;
  90
  91  enum Vst2StringConstants
  92  {
  93     kVstMaxNameLen       = 64,
  94     kVstMaxLabelLen      = 64,
  95     kVstMaxShortLabelLen = 8,
  96     kVstMaxCategLabelLen = 24,
  97     kVstMaxFileNameLen   = 100
  98  };
  99
 100  enum VstSmpteFrameRate
 101  {
 102     kVstSmpte24fps    = 0,  // 24 fps
 103     kVstSmpte25fps    = 1,  // 25 fps
 104     kVstSmpte2997fps  = 2,  // 29.97 fps
 105     kVstSmpte30fps    = 3,  // 30 fps
 106     kVstSmpte2997dfps = 4,  // 29.97 drop
 107     kVstSmpte30dfps   = 5,  // 30 drop
 108     kVstSmpteFilm16mm = 6,  // Film 16mm
 109     kVstSmpteFilm35mm = 7,  // Film 35mm
 110     kVstSmpte239fps   = 10, // HDTV: 23.976 fps
 111     kVstSmpte249fps   = 11, // HDTV: 24.976 fps
 112     kVstSmpte599fps   = 12, // HDTV: 59.94 fps
 113     kVstSmpte60fps    = 13  // HDTV: 60 fps
 114  };
 115
 116  struct VstMidiSysexEvent
 117  {
 118     VstInt32 type;          // #kVstSysexType
 119     VstInt32 byteSize;      // sizeof (VstMidiSysexEvent)
 120     VstInt32 deltaFrames;   // sample frames related to the current block start sample position
 121     VstInt32 flags;         // none defined yet (should be zero)
 122     VstInt32 dumpBytes;     // byte size of sysexDump
 123     VstIntPtr resvd1;       // zero (Reserved for future use)
 124     char* sysexDump;        // sysex dump
 125     VstIntPtr resvd2;       // zero (Reserved for future use)
 126  };
 127
 128  typedef int VstSpeakerArrangementType;
 129 #endif
 130
 131 //==============================================================================
 132 #ifdef _MSC_VER
 133  #pragma pack (push, 8)
 134 #endif
 135
 136 #include "../juce_PluginHeaders.h"
 137 #include "../juce_PluginHostType.h"
 138
 139 #ifdef _MSC_VER
 140  #pragma pack (pop)
 141 #endif
 142
 143 #undef MemoryBlock
 144
 145 class JuceVSTWrapper;
 146 static bool recursionCheck = false;
 147 static JUCE_NAMESPACE::uint32 lastMasterIdleCall = 0;
 148
 149 BEGIN_JUCE_NAMESPACE
 150  extern void juce_callAnyTimersSynchronously();
 151
 152  #if JUCE_MAC
 153   extern void initialiseMac();
 154   extern void* attachComponentToWindowRef (Component* component, void* windowRef);
 155   extern void detachComponentFromWindowRef (Component* component, void* nsWindow);
 156   extern void setNativeHostWindowSize (void* nsWindow, Component* editorComp, int newWidth, int newHeight, const PluginHostType& host);
 157   extern void checkWindowVisibility (void* nsWindow, Component* component);
 158   extern void forwardCurrentKeyEventToHost (Component* component);
 159  #endif
 160
 161  #if JUCE_LINUX
 162   extern Display* display;
 163  #endif
 164 END_JUCE_NAMESPACE
 165
 166
 167 //==============================================================================
 168 #if JUCE_WINDOWS
 169
 170 namespace
 171 {
 172     HWND findMDIParentOf (HWND w)
 173     {
 174         const int frameThickness = GetSystemMetrics (SM_CYFIXEDFRAME);
 175
 176         while (w != 0)
 177         {
 178             HWND parent = GetParent (w);
 179
 180             if (parent == 0)
 181                 break;
 182
 183             TCHAR windowType[32] = { 0 };
 184             GetClassName (parent, windowType, 31);
 185
 186             if (String (windowType).equalsIgnoreCase ("MDIClient"))
 187                 return parent;
 188
 189             RECT windowPos, parentPos;
 190             GetWindowRect (w, &windowPos);
 191             GetWindowRect (parent, &parentPos);
 192
 193             const int dw = (parentPos.right - parentPos.left) - (windowPos.right - windowPos.left);
 194             const int dh = (parentPos.bottom - parentPos.top) - (windowPos.bottom - windowPos.top);
 195
 196             if (dw > 100 || dh > 100)
 197                 break;
 198
 199             w = parent;
 200
 201             if (dw == 2 * frameThickness)
 202                 break;
 203         }
 204
 205         return w;
 206     }
 207
 208     //==============================================================================
 209     static HHOOK mouseWheelHook = 0;
 210     static int mouseHookUsers = 0;
 211
 212     LRESULT CALLBACK mouseWheelHookCallback (int nCode, WPARAM wParam, LPARAM lParam)
 213     {
 214         if (nCode >= 0 && wParam == WM_MOUSEWHEEL)
 215         {
 216             const MOUSEHOOKSTRUCTEX& hs = *(MOUSEHOOKSTRUCTEX*) lParam;
 217
 218             Component* const comp = Desktop::getInstance().findComponentAt (Point<int> (hs.pt.x,
 219                                                                                         hs.pt.y));
 220             if (comp != nullptr && comp->getWindowHandle() != 0)
 221                 return PostMessage ((HWND) comp->getWindowHandle(), WM_MOUSEWHEEL,
 222                                     hs.mouseData & 0xffff0000, (hs.pt.x & 0xffff) | (hs.pt.y << 16));
 223         }
 224
 225         return CallNextHookEx (mouseWheelHook, nCode, wParam, lParam);
 226     }
 227
 228     void registerMouseWheelHook()
 229     {
 230         if (mouseHookUsers++ == 0)
 231             mouseWheelHook = SetWindowsHookEx (WH_MOUSE, mouseWheelHookCallback,
 232                                                (HINSTANCE) PlatformUtilities::getCurrentModuleInstanceHandle(),
 233                                                GetCurrentThreadId());
 234     }
 235
 236     void unregisterMouseWheelHook()
 237     {
 238         if (--mouseHookUsers == 0 && mouseWheelHook != 0)
 239         {
 240             UnhookWindowsHookEx (mouseWheelHook);
 241             mouseWheelHook = 0;
 242         }
 243     }
 244 }
 245
 246 //==============================================================================
 247 #elif JUCE_LINUX
 248
 249 class SharedMessageThread : public Thread
 250 {
 251 public:
 252     SharedMessageThread()
 253       : Thread ("VstMessageThread"),
 254         initialised (false)
 255     {
 256         startThread (7);
 257
 258         while (! initialised)
 259             sleep (1);
 260     }
 261
 262     ~SharedMessageThread()
 263     {
 264         signalThreadShouldExit();
 265         JUCEApplication::quit();
 266         waitForThreadToExit (5000);
 267         clearSingletonInstance();
 268     }
 269
 270     void run()
 271     {
 272         initialiseJuce_GUI();
 273         initialised = true;
 274
 275         MessageManager::getInstance()->setCurrentThreadAsMessageThread();
 276
 277         while ((! threadShouldExit()) && MessageManager::getInstance()->runDispatchLoopUntil (250))
 278         {}
 279     }
 280
 281     juce_DeclareSingleton (SharedMessageThread, false);
 282
 283 private:
 284     bool initialised;
 285 };
 286
 287 juce_ImplementSingleton (SharedMessageThread)
 288
 289 #endif
 290
 291 static Array<void*> activePlugins;
 292
 293 //==============================================================================
 294 /**
 295     This is an AudioEffectX object that holds and wraps our AudioProcessor...
 296 */
 297 class JuceVSTWrapper  : public AudioEffectX,
 298                         private Timer,
 299                         public AudioProcessorListener,
 300                         public AudioPlayHead
 301 {
 302 public:
 303     //==============================================================================
 304     JuceVSTWrapper (audioMasterCallback audioMaster, AudioProcessor* const filter_)
 305        : AudioEffectX (audioMaster, filter_->getNumPrograms(), filter_->getNumParameters()),
 306          filter (filter_),
 307          chunkMemoryTime (0),
 308          speakerIn (kSpeakerArrEmpty),
 309          speakerOut (kSpeakerArrEmpty),
 310          numInChans (JucePlugin_MaxNumInputChannels),
 311          numOutChans (JucePlugin_MaxNumOutputChannels),
 312          isProcessing (false),
 313          hasShutdown (false),
 314          firstProcessCallback (true),
 315          shouldDeleteEditor (false),
 316          hostWindow (0)
 317     {
 318         filter->setPlayConfigDetails (numInChans, numOutChans, 0, 0);
 319         filter->setPlayHead (this);
 320         filter->addListener (this);
 321
 322         cEffect.flags |= effFlagsHasEditor;
 323         cEffect.version = (long) (JucePlugin_VersionCode);
 324
 325         setUniqueID ((int) (JucePlugin_VSTUniqueID));
 326
 327        #if JucePlugin_WantsMidiInput && ! JUCE_USE_VSTSDK_2_4
 328         wantEvents();
 329        #endif
 330
 331         setNumInputs (numInChans);
 332         setNumOutputs (numOutChans);
 333
 334         canProcessReplacing (true);
 335
 336        #if ! JUCE_USE_VSTSDK_2_4
 337         hasVu (false);
 338         hasClip (false);
 339        #endif
 340
 341         isSynth ((JucePlugin_IsSynth) != 0);
 342         noTail (((JucePlugin_SilenceInProducesSilenceOut) != 0) && (JucePlugin_TailLengthSeconds <= 0));
 343         setInitialDelay (filter->getLatencySamples());
 344         programsAreChunks (true);
 345
 346         activePlugins.add (this);
 347     }
 348
 349     ~JuceVSTWrapper()
 350     {
 351         JUCE_AUTORELEASEPOOL
 352
 353         {
 354            #if JUCE_LINUX
 355             MessageManagerLock mmLock;
 356            #endif
 357             stopTimer();
 358             deleteEditor (false);
 359
 360             hasShutdown = true;
 361
 362             delete filter;
 363             filter = 0;
 364
 365             jassert (editorComp == 0);
 366
 367             channels.free();
 368             deleteTempChannels();
 369
 370             jassert (activePlugins.contains (this));
 371             activePlugins.removeValue (this);
 372         }
 373
 374         if (activePlugins.size() == 0)
 375         {
 376            #if JUCE_LINUX
 377             SharedMessageThread::deleteInstance();
 378            #endif
 379             shutdownJuce_GUI();
 380         }
 381     }
 382
 383     void open()
 384     {
 385         // Note: most hosts call this on the UI thread, but wavelab doesn't, so be careful in here.
 386         if (filter->hasEditor())
 387             cEffect.flags |= effFlagsHasEditor;
 388         else
 389             cEffect.flags &= ~effFlagsHasEditor;
 390     }
 391
 392     void close()
 393     {
 394         // Note: most hosts call this on the UI thread, but wavelab doesn't, so be careful in here.
 395         stopTimer();
 396
 397         if (MessageManager::getInstance()->isThisTheMessageThread())
 398             deleteEditor (false);
 399     }
 400
 401     //==============================================================================
 402     bool getEffectName (char* name)
 403     {
 404         String (JucePlugin_Name).copyToUTF8 (name, 64);
 405         return true;
 406     }
 407
 408     bool getVendorString (char* text)
 409     {
 410         String (JucePlugin_Manufacturer).copyToUTF8 (text, 64);
 411         return true;
 412     }
 413
 414     bool getProductString (char* text)  { return getEffectName (text); }
 415     VstInt32 getVendorVersion()         { return JucePlugin_VersionCode; }
 416     VstPlugCategory getPlugCategory()   { return JucePlugin_VSTCategory; }
 417     bool keysRequired()                 { return (JucePlugin_EditorRequiresKeyboardFocus) != 0; }
 418
 419     VstInt32 canDo (char* text)
 420     {
 421         VstInt32 result = 0;
 422
 423         if (strcmp (text, "receiveVstEvents") == 0
 424             || strcmp (text, "receiveVstMidiEvent") == 0
 425             || strcmp (text, "receiveVstMidiEvents") == 0)
 426         {
 427            #if JucePlugin_WantsMidiInput
 428             result = 1;
 429            #else
 430             result = -1;
 431            #endif
 432         }
 433         else if (strcmp (text, "sendVstEvents") == 0
 434                  || strcmp (text, "sendVstMidiEvent") == 0
 435                  || strcmp (text, "sendVstMidiEvents") == 0)
 436         {
 437            #if JucePlugin_ProducesMidiOutput
 438             result = 1;
 439            #else
 440             result = -1;
 441            #endif
 442         }
 443         else if (strcmp (text, "receiveVstTimeInfo") == 0
 444                  || strcmp (text, "conformsToWindowRules") == 0)
 445         {
 446             result = 1;
 447         }
 448         else if (strcmp (text, "openCloseAnyThread") == 0)
 449         {
 450             // This tells Wavelab to use the UI thread to invoke open/close,
 451             // like all other hosts do.
 452             result = -1;
 453         }
 454
 455         return result;
 456     }
 457
 458     bool getInputProperties (VstInt32 index, VstPinProperties* properties)
 459     {
 460         if (filter == nullptr || index >= JucePlugin_MaxNumInputChannels)
 461             return false;
 462
 463         setPinProperties (*properties, filter->getInputChannelName ((int) index),
 464                           speakerIn, filter->isInputChannelStereoPair ((int) index));
 465         return true;
 466     }
 467
 468     bool getOutputProperties (VstInt32 index, VstPinProperties* properties)
 469     {
 470         if (filter == nullptr || index >= JucePlugin_MaxNumOutputChannels)
 471             return false;
 472
 473         setPinProperties (*properties, filter->getOutputChannelName ((int) index),
 474                           speakerOut, filter->isOutputChannelStereoPair ((int) index));
 475         return true;
 476     }
 477
 478     static void setPinProperties (VstPinProperties& properties, const String& name,
 479                                   VstSpeakerArrangementType type, const bool isPair)
 480     {
 481         name.copyToUTF8 (properties.label, kVstMaxLabelLen - 1);
 482         name.copyToUTF8 (properties.shortLabel, kVstMaxShortLabelLen - 1);
 483
 484         if (type != kSpeakerArrEmpty)
 485         {
 486             properties.flags = kVstPinUseSpeaker;
 487             properties.arrangementType = type;
 488         }
 489         else
 490         {
 491             properties.flags = kVstPinIsActive;
 492             properties.arrangementType = 0;
 493
 494             if (isPair)
 495                 properties.flags |= kVstPinIsStereo;
 496         }
 497     }
 498
 499     //==============================================================================
 500     VstInt32 processEvents (VstEvents* events)
 501     {
 502        #if JucePlugin_WantsMidiInput
 503         VSTMidiEventList::addEventsToMidiBuffer (events, midiEvents);
 504         return 1;
 505        #else
 506         return 0;
 507        #endif
 508     }
 509
 510     void process (float** inputs, float** outputs, VstInt32 numSamples)
 511     {
 512         const int numIn = numInChans;
 513         const int numOut = numOutChans;
 514
 515         AudioSampleBuffer temp (numIn, numSamples);
 516         int i;
 517         for (i = numIn; --i >= 0;)
 518             memcpy (temp.getSampleData (i), outputs[i], sizeof (float) * numSamples);
 519
 520         processReplacing (inputs, outputs, numSamples);
 521
 522         AudioSampleBuffer dest (outputs, numOut, numSamples);
 523
 524         for (i = jmin (numIn, numOut); --i >= 0;)
 525             dest.addFrom (i, 0, temp, i, 0, numSamples);
 526     }
 527
 528     void processReplacing (float** inputs, float** outputs, VstInt32 numSamples)
 529     {
 530         if (firstProcessCallback)
 531         {
 532             firstProcessCallback = false;
 533
 534             // if this fails, the host hasn't called resume() before processing
 535             jassert (isProcessing);
 536
 537             // (tragically, some hosts actually need this, although it's stupid to have
 538             //  to do it here..)
 539             if (! isProcessing)
 540                 resume();
 541
 542             filter->setNonRealtime (getCurrentProcessLevel() == 4 /* kVstProcessLevelOffline */);
 543
 544            #if JUCE_WINDOWS
 545             if (GetThreadPriority (GetCurrentThread()) <= THREAD_PRIORITY_NORMAL
 546                   && GetThreadPriority (GetCurrentThread()) >= THREAD_PRIORITY_LOWEST)
 547                 filter->setNonRealtime (true);
 548            #endif
 549         }
 550
 551        #if JUCE_DEBUG && ! JucePlugin_ProducesMidiOutput
 552         const int numMidiEventsComingIn = midiEvents.getNumEvents();
 553        #endif
 554
 555         jassert (activePlugins.contains (this));
 556
 557         {
 558             const ScopedLock sl (filter->getCallbackLock());
 559
 560             const int numIn = numInChans;
 561             const int numOut = numOutChans;
 562
 563             if (filter->isSuspended())
 564             {
 565                 for (int i = 0; i < numOut; ++i)
 566                     zeromem (outputs[i], sizeof (float) * numSamples);
 567             }
 568             else
 569             {
 570                 int i;
 571                 for (i = 0; i < numOut; ++i)
 572                 {
 573                     float* chan = tempChannels.getUnchecked(i);
 574
 575                     if (chan == 0)
 576                     {
 577                         chan = outputs[i];
 578
 579                         // if some output channels are disabled, some hosts supply the same buffer
 580                         // for multiple channels - this buggers up our method of copying the
 581                         // inputs over the outputs, so we need to create unique temp buffers in this case..
 582                         for (int j = i; --j >= 0;)
 583                         {
 584                             if (outputs[j] == chan)
 585                             {
 586                                 chan = new float [blockSize * 2];
 587                                 tempChannels.set (i, chan);
 588                                 break;
 589                             }
 590                         }
 591                     }
 592
 593                     if (i < numIn && chan != inputs[i])
 594                         memcpy (chan, inputs[i], sizeof (float) * numSamples);
 595
 596                     channels[i] = chan;
 597                 }
 598
 599                 for (; i < numIn; ++i)
 600                     channels[i] = inputs[i];
 601
 602                 AudioSampleBuffer chans (channels, jmax (numIn, numOut), numSamples);
 603
 604                 filter->processBlock (chans, midiEvents);
 605             }
 606         }
 607
 608         if (! midiEvents.isEmpty())
 609         {
 610            #if JucePlugin_ProducesMidiOutput
 611             const int numEvents = midiEvents.getNumEvents();
 612
 613             outgoingEvents.ensureSize (numEvents);
 614             outgoingEvents.clear();
 615
 616             const JUCE_NAMESPACE::uint8* midiEventData;
 617             int midiEventSize, midiEventPosition;
 618             MidiBuffer::Iterator i (midiEvents);
 619
 620             while (i.getNextEvent (midiEventData, midiEventSize, midiEventPosition))
 621             {
 622                 jassert (midiEventPosition >= 0 && midiEventPosition < numSamples);
 623
 624                 outgoingEvents.addEvent (midiEventData, midiEventSize, midiEventPosition);
 625             }
 626
 627             sendVstEventsToHost (outgoingEvents.events);
 628            #else
 629             /*  This assertion is caused when you've added some events to the
 630                 midiMessages array in your processBlock() method, which usually means
 631                 that you're trying to send them somewhere. But in this case they're
 632                 getting thrown away.
 633
 634                 If your plugin does want to send midi messages, you'll need to set
 635                 the JucePlugin_ProducesMidiOutput macro to 1 in your
 636                 JucePluginCharacteristics.h file.
 637
 638                 If you don't want to produce any midi output, then you should clear the
 639                 midiMessages array at the end of your processBlock() method, to
 640                 indicate that you don't want any of the events to be passed through
 641                 to the output.
 642             */
 643             jassert (midiEvents.getNumEvents() <= numMidiEventsComingIn);
 644            #endif
 645
 646             midiEvents.clear();
 647         }
 648     }
 649
 650     //==============================================================================
 651     VstInt32 startProcess()  { return 0; }
 652     VstInt32 stopProcess()   { return 0; }
 653
 654     void resume()
 655     {
 656         if (filter != nullptr)
 657         {
 658             isProcessing = true;
 659             channels.calloc (numInChans + numOutChans);
 660
 661             double rate = getSampleRate();
 662             jassert (rate > 0);
 663             if (rate <= 0.0)
 664                 rate = 44100.0;
 665
 666             const int blockSize = getBlockSize();
 667             jassert (blockSize > 0);
 668
 669             firstProcessCallback = true;
 670
 671             filter->setNonRealtime (getCurrentProcessLevel() == 4 /* kVstProcessLevelOffline */);
 672             filter->setPlayConfigDetails (numInChans, numOutChans, rate, blockSize);
 673
 674             deleteTempChannels();
 675
 676             filter->prepareToPlay (rate, blockSize);
 677
 678             midiEvents.ensureSize (2048);
 679             midiEvents.clear();
 680
 681             setInitialDelay (filter->getLatencySamples());
 682
 683             AudioEffectX::resume();
 684
 685            #if JucePlugin_ProducesMidiOutput
 686             outgoingEvents.ensureSize (512);
 687            #endif
 688
 689            #if JucePlugin_WantsMidiInput && ! JUCE_USE_VSTSDK_2_4
 690             wantEvents();
 691            #endif
 692         }
 693     }
 694
 695     void suspend()
 696     {
 697         if (filter != nullptr)
 698         {
 699             AudioEffectX::suspend();
 700
 701             filter->releaseResources();
 702             outgoingEvents.freeEvents();
 703
 704             isProcessing = false;
 705             channels.free();
 706
 707             deleteTempChannels();
 708         }
 709     }
 710
 711     bool getCurrentPosition (AudioPlayHead::CurrentPositionInfo& info)
 712     {
 713         const VstTimeInfo* const ti = getTimeInfo (kVstPpqPosValid | kVstTempoValid | kVstBarsValid //| kVstCyclePosValid
 714                                                    | kVstTimeSigValid | kVstSmpteValid | kVstClockValid);
 715
 716         if (ti == nullptr || ti->sampleRate <= 0)
 717             return false;
 718
 719         info.bpm = (ti->flags & kVstTempoValid) != 0 ? ti->tempo : 0.0;
 720
 721         if ((ti->flags & kVstTimeSigValid) != 0)
 722         {
 723             info.timeSigNumerator = ti->timeSigNumerator;
 724             info.timeSigDenominator = ti->timeSigDenominator;
 725         }
 726         else
 727         {
 728             info.timeSigNumerator = 4;
 729             info.timeSigDenominator = 4;
 730         }
 731
 732         info.timeInSeconds = ti->samplePos / ti->sampleRate;
 733         info.ppqPosition = (ti->flags & kVstPpqPosValid) != 0 ? ti->ppqPos : 0.0;
 734         info.ppqPositionOfLastBarStart = (ti->flags & kVstBarsValid) != 0 ? ti->barStartPos : 0.0;
 735
 736         if ((ti->flags & kVstSmpteValid) != 0)
 737         {
 738             AudioPlayHead::FrameRateType rate = AudioPlayHead::fpsUnknown;
 739             double fps = 1.0;
 740
 741             switch (ti->smpteFrameRate)
 742             {
 743                 case kVstSmpte24fps:        rate = AudioPlayHead::fps24;       fps = 24.0;  break;
 744                 case kVstSmpte25fps:        rate = AudioPlayHead::fps25;       fps = 25.0;  break;
 745                 case kVstSmpte2997fps:      rate = AudioPlayHead::fps2997;     fps = 29.97; break;
 746                 case kVstSmpte30fps:        rate = AudioPlayHead::fps30;       fps = 30.0;  break;
 747                 case kVstSmpte2997dfps:     rate = AudioPlayHead::fps2997drop; fps = 29.97; break;
 748                 case kVstSmpte30dfps:       rate = AudioPlayHead::fps30drop;   fps = 30.0;  break;
 749
 750                 case kVstSmpteFilm16mm:
 751                 case kVstSmpteFilm35mm:     fps = 24.0; break;
 752
 753                 case kVstSmpte239fps:       fps = 23.976; break;
 754                 case kVstSmpte249fps:       fps = 24.976; break;
 755                 case kVstSmpte599fps:       fps = 59.94; break;
 756                 case kVstSmpte60fps:        fps = 60; break;
 757
 758                 default:                    jassertfalse; // unknown frame-rate..
 759             }
 760
 761             info.frameRate = rate;
 762             info.editOriginTime = ti->smpteOffset / (80.0 * fps);
 763         }
 764         else
 765         {
 766             info.frameRate = AudioPlayHead::fpsUnknown;
 767             info.editOriginTime = 0;
 768         }
 769
 770         info.isRecording = (ti->flags & kVstTransportRecording) != 0;
 771         info.isPlaying   = (ti->flags & kVstTransportPlaying) != 0 || info.isRecording;
 772
 773         return true;
 774     }
 775
 776     //==============================================================================
 777     VstInt32 getProgram()
 778     {
 779         return filter != nullptr ? filter->getCurrentProgram() : 0;
 780     }
 781
 782     void setProgram (VstInt32 program)
 783     {
 784         if (filter != nullptr)
 785             filter->setCurrentProgram (program);
 786     }
 787
 788     void setProgramName (char* name)
 789     {
 790         if (filter != nullptr)
 791             filter->changeProgramName (filter->getCurrentProgram(), name);
 792     }
 793
 794     void getProgramName (char* name)
 795     {
 796         if (filter != nullptr)
 797             filter->getProgramName (filter->getCurrentProgram()).copyToUTF8 (name, 24);
 798     }
 799
 800     bool getProgramNameIndexed (VstInt32 /*category*/, VstInt32 index, char* text)
 801     {
 802         if (filter != nullptr && isPositiveAndBelow (index, filter->getNumPrograms()))
 803         {
 804             filter->getProgramName (index).copyToUTF8 (text, 24);
 805             return true;
 806         }
 807
 808         return false;
 809     }
 810
 811     //==============================================================================
 812     float getParameter (VstInt32 index)
 813     {
 814         if (filter == nullptr)
 815             return 0.0f;
 816
 817         jassert (isPositiveAndBelow (index, filter->getNumParameters()));
 818         return filter->getParameter (index);
 819     }
 820
 821     void setParameter (VstInt32 index, float value)
 822     {
 823         if (filter != nullptr)
 824         {
 825             jassert (isPositiveAndBelow (index, filter->getNumParameters()));
 826             filter->setParameter (index, value);
 827         }
 828     }
 829
 830     void getParameterDisplay (VstInt32 index, char* text)
 831     {
 832         if (filter != nullptr)
 833         {
 834             jassert (isPositiveAndBelow (index, filter->getNumParameters()));
 835             filter->getParameterText (index).copyToUTF8 (text, 24); // length should technically be kVstMaxParamStrLen, which is 8, but hosts will normally allow a bit more.
 836         }
 837     }
 838
 839     void getParameterName (VstInt32 index, char* text)
 840     {
 841         if (filter != nullptr)
 842         {
 843             jassert (isPositiveAndBelow (index, filter->getNumParameters()));
 844             filter->getParameterName (index).copyToUTF8 (text, 16); // length should technically be kVstMaxParamStrLen, which is 8, but hosts will normally allow a bit more.
 845         }
 846     }
 847
 848     void audioProcessorParameterChanged (AudioProcessor*, int index, float newValue)
 849     {
 850         setParameterAutomated (index, newValue);
 851     }
 852
 853     void audioProcessorParameterChangeGestureBegin (AudioProcessor*, int index)   { beginEdit (index); }
 854     void audioProcessorParameterChangeGestureEnd (AudioProcessor*, int index)     { endEdit (index); }
 855
 856     void audioProcessorChanged (AudioProcessor*)
 857     {
 858         updateDisplay();
 859     }
 860
 861     bool canParameterBeAutomated (VstInt32 index)
 862     {
 863         return filter != nullptr && filter->isParameterAutomatable ((int) index);
 864     }
 865
 866     class ChannelConfigComparator
 867     {
 868     public:
 869         static int compareElements (const short* const first, const short* const second) noexcept
 870         {
 871             if (first[0] < second[0])       return -1;
 872             else if (first[0] > second[0])  return 1;
 873             else if (first[1] < second[1])  return -1;
 874             else if (first[1] > second[1])  return 1;
 875
 876             return 0;
 877         }
 878     };
 879
 880     bool setSpeakerArrangement (VstSpeakerArrangement* pluginInput,
 881                                 VstSpeakerArrangement* pluginOutput)
 882     {
 883         short channelConfigs[][2] = { JucePlugin_PreferredChannelConfigurations };
 884
 885         Array <short*> channelConfigsSorted;
 886         ChannelConfigComparator comp;
 887
 888         for (int i = 0; i < numElementsInArray (channelConfigs); ++i)
 889             channelConfigsSorted.addSorted (comp, channelConfigs[i]);
 890
 891         for (int i = channelConfigsSorted.size(); --i >= 0;)
 892         {
 893             const short* const config = channelConfigsSorted.getUnchecked(i);
 894             bool inCountMatches  = (config[0] == pluginInput->numChannels);
 895             bool outCountMatches = (config[1] == pluginOutput->numChannels);
 896
 897             if (inCountMatches && outCountMatches)
 898             {
 899                 speakerIn = (VstSpeakerArrangementType) pluginInput->type;
 900                 speakerOut = (VstSpeakerArrangementType) pluginOutput->type;
 901                 numInChans = pluginInput->numChannels;
 902                 numOutChans = pluginOutput->numChannels;
 903
 904                 filter->setPlayConfigDetails (numInChans, numOutChans,
 905                                               filter->getSampleRate(),
 906                                               filter->getBlockSize());
 907                 return true;
 908             }
 909         }
 910
 911         return false;
 912     }
 913
 914     //==============================================================================
 915     VstInt32 getChunk (void** data, bool onlyStoreCurrentProgramData)
 916     {
 917         if (filter == nullptr)
 918             return 0;
 919
 920         chunkMemory.setSize (0);
 921         if (onlyStoreCurrentProgramData)
 922             filter->getCurrentProgramStateInformation (chunkMemory);
 923         else
 924             filter->getStateInformation (chunkMemory);
 925
 926         *data = (void*) chunkMemory.getData();
 927
 928         // because the chunk is only needed temporarily by the host (or at least you'd
 929         // hope so) we'll give it a while and then free it in the timer callback.
 930         chunkMemoryTime = JUCE_NAMESPACE::Time::getApproximateMillisecondCounter();
 931
 932         return (VstInt32) chunkMemory.getSize();
 933     }
 934
 935     VstInt32 setChunk (void* data, VstInt32 byteSize, bool onlyRestoreCurrentProgramData)
 936     {
 937         if (filter == nullptr)
 938             return 0;
 939
 940         chunkMemory.setSize (0);
 941         chunkMemoryTime = 0;
 942
 943         if (byteSize > 0 && data != nullptr)
 944         {
 945             if (onlyRestoreCurrentProgramData)
 946                 filter->setCurrentProgramStateInformation (data, byteSize);
 947             else
 948                 filter->setStateInformation (data, byteSize);
 949         }
 950
 951         return 0;
 952     }
 953
 954     void timerCallback()
 955     {
 956         if (shouldDeleteEditor)
 957         {
 958             shouldDeleteEditor = false;
 959             deleteEditor (true);
 960         }
 961
 962         if (chunkMemoryTime > 0
 963              && chunkMemoryTime < JUCE_NAMESPACE::Time::getApproximateMillisecondCounter() - 2000
 964              && ! recursionCheck)
 965         {
 966             chunkMemoryTime = 0;
 967             chunkMemory.setSize (0);
 968         }
 969
 970        #if JUCE_MAC
 971         if (hostWindow != 0)
 972             checkWindowVisibility (hostWindow, editorComp);
 973        #endif
 974
 975         tryMasterIdle();
 976     }
 977
 978     void tryMasterIdle()
 979     {
 980         if (Component::isMouseButtonDownAnywhere() && ! recursionCheck)
 981         {
 982             const JUCE_NAMESPACE::uint32 now = JUCE_NAMESPACE::Time::getMillisecondCounter();
 983
 984             if (now > lastMasterIdleCall + 20 && editorComp != nullptr)
 985             {
 986                 lastMasterIdleCall = now;
 987
 988                 recursionCheck = true;
 989                 masterIdle();
 990                 recursionCheck = false;
 991             }
 992         }
 993     }
 994
 995     void doIdleCallback()
 996     {
 997         // (wavelab calls this on a separate thread and causes a deadlock)..
 998         if (MessageManager::getInstance()->isThisTheMessageThread()
 999              && ! recursionCheck)
1000         {
1001             recursionCheck = true;
1002
1003             JUCE_AUTORELEASEPOOL
1004             juce_callAnyTimersSynchronously();
1005
1006             for (int i = ComponentPeer::getNumPeers(); --i >= 0;)
1007                 ComponentPeer::getPeer (i)->performAnyPendingRepaintsNow();
1008
1009             recursionCheck = false;
1010         }
1011     }
1012
1013     void createEditorComp()
1014     {
1015         if (hasShutdown || filter == nullptr)
1016             return;
1017
1018         if (editorComp == nullptr)
1019         {
1020             AudioProcessorEditor* const ed = filter->createEditorIfNeeded();
1021
1022             if (ed != nullptr)
1023             {
1024                 cEffect.flags |= effFlagsHasEditor;
1025                 ed->setOpaque (true);
1026                 ed->setVisible (true);
1027
1028                 editorComp = new EditorCompWrapper (*this, ed);
1029             }
1030             else
1031             {
1032                 cEffect.flags &= ~effFlagsHasEditor;
1033             }
1034         }
1035
1036         shouldDeleteEditor = false;
1037     }
1038
1039     void deleteEditor (bool canDeleteLaterIfModal)
1040     {
1041         JUCE_AUTORELEASEPOOL
1042         PopupMenu::dismissAllActiveMenus();
1043
1044         jassert (! recursionCheck);
1045         recursionCheck = true;
1046
1047         if (editorComp != nullptr)
1048         {
1049             Component* const modalComponent = Component::getCurrentlyModalComponent();
1050             if (modalComponent != nullptr)
1051             {
1052                 modalComponent->exitModalState (0);
1053
1054                 if (canDeleteLaterIfModal)
1055                 {
1056                     shouldDeleteEditor = true;
1057                     recursionCheck = false;
1058                     return;
1059                 }
1060             }
1061
1062            #if JUCE_MAC
1063             if (hostWindow != 0)
1064             {
1065                 detachComponentFromWindowRef (editorComp, hostWindow);
1066                 hostWindow = 0;
1067             }
1068            #endif
1069
1070             filter->editorBeingDeleted (editorComp->getEditorComp());
1071
1072             editorComp = nullptr;
1073
1074             // there's some kind of component currently modal, but the host
1075             // is trying to delete our plugin. You should try to avoid this happening..
1076             jassert (Component::getCurrentlyModalComponent() == nullptr);
1077         }
1078
1079        #if JUCE_LINUX
1080         hostWindow = 0;
1081        #endif
1082
1083         recursionCheck = false;
1084     }
1085
1086     VstIntPtr dispatcher (VstInt32 opCode, VstInt32 index, VstIntPtr value, void* ptr, float opt)
1087     {
1088         if (hasShutdown)
1089             return 0;
1090
1091         if (opCode == effEditIdle)
1092         {
1093             doIdleCallback();
1094             return 0;
1095         }
1096         else if (opCode == effEditOpen)
1097         {
1098             checkWhetherMessageThreadIsCorrect();
1099             const MessageManagerLock mmLock;
1100             jassert (! recursionCheck);
1101
1102             startTimer (1000 / 4); // performs misc housekeeping chores
1103
1104             deleteEditor (true);
1105             createEditorComp();
1106
1107             if (editorComp != nullptr)
1108             {
1109                 editorComp->setOpaque (true);
1110                 editorComp->setVisible (false);
1111
1112               #if JUCE_WINDOWS
1113                 editorComp->addToDesktop (0, ptr);
1114                 hostWindow = (HWND) ptr;
1115               #elif JUCE_LINUX
1116                 editorComp->addToDesktop (0);
1117                 hostWindow = (Window) ptr;
1118                 Window editorWnd = (Window) editorComp->getWindowHandle();
1119                 XReparentWindow (display, editorWnd, hostWindow, 0, 0);
1120               #else
1121                 hostWindow = attachComponentToWindowRef (editorComp, (WindowRef) ptr);
1122               #endif
1123                 editorComp->setVisible (true);
1124
1125                 return 1;
1126             }
1127         }
1128         else if (opCode == effEditClose)
1129         {
1130             checkWhetherMessageThreadIsCorrect();
1131             const MessageManagerLock mmLock;
1132             deleteEditor (true);
1133             return 0;
1134         }
1135         else if (opCode == effEditGetRect)
1136         {
1137             checkWhetherMessageThreadIsCorrect();
1138             const MessageManagerLock mmLock;
1139             createEditorComp();
1140
1141             if (editorComp != nullptr)
1142             {
1143                 editorSize.left = 0;
1144                 editorSize.top = 0;
1145                 editorSize.right = (VstInt16) editorComp->getWidth();
1146                 editorSize.bottom = (VstInt16) editorComp->getHeight();
1147
1148                 *((ERect**) ptr) = &editorSize;
1149
1150                 return (VstIntPtr) (pointer_sized_int) &editorSize;
1151             }
1152             else
1153             {
1154                 return 0;
1155             }
1156         }
1157
1158         return AudioEffectX::dispatcher (opCode, index, value, ptr, opt);
1159     }
1160
1161     void resizeHostWindow (int newWidth, int newHeight)
1162     {
1163         if (editorComp != nullptr)
1164         {
1165             if (! (canHostDo (const_cast <char*> ("sizeWindow")) && sizeWindow (newWidth, newHeight)))
1166             {
1167                 // some hosts don't support the sizeWindow call, so do it manually..
1168                #if JUCE_MAC
1169                 setNativeHostWindowSize (hostWindow, editorComp, newWidth, newHeight, getHostType());
1170
1171                #elif JUCE_LINUX
1172                 // (Currently, all linux hosts support sizeWindow, so this should never need to happen)
1173                 editorComp->setSize (newWidth, newHeight);
1174
1175                #else
1176                 int dw = 0;
1177                 int dh = 0;
1178                 const int frameThickness = GetSystemMetrics (SM_CYFIXEDFRAME);
1179
1180                 HWND w = (HWND) editorComp->getWindowHandle();
1181
1182                 while (w != 0)
1183                 {
1184                     HWND parent = GetParent (w);
1185
1186                     if (parent == 0)
1187                         break;
1188
1189                     TCHAR windowType [32] = { 0 };
1190                     GetClassName (parent, windowType, 31);
1191
1192                     if (String (windowType).equalsIgnoreCase ("MDIClient"))
1193                         break;
1194
1195                     RECT windowPos, parentPos;
1196                     GetWindowRect (w, &windowPos);
1197                     GetWindowRect (parent, &parentPos);
1198
1199                     SetWindowPos (w, 0, 0, 0, newWidth + dw, newHeight + dh,
1200                                   SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOOWNERZORDER);
1201
1202                     dw = (parentPos.right - parentPos.left) - (windowPos.right - windowPos.left);
1203                     dh = (parentPos.bottom - parentPos.top) - (windowPos.bottom - windowPos.top);
1204
1205                     w = parent;
1206
1207                     if (dw == 2 * frameThickness)
1208                         break;
1209
1210                     if (dw > 100 || dh > 100)
1211                         w = 0;
1212                 }
1213
1214                 if (w != 0)
1215                     SetWindowPos (w, 0, 0, 0, newWidth + dw, newHeight + dh,
1216                                   SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOOWNERZORDER);
1217                #endif
1218             }
1219
1220             if (editorComp->getPeer() != nullptr)
1221                 editorComp->getPeer()->handleMovedOrResized();
1222         }
1223     }
1224
1225     static PluginHostType& getHostType()
1226     {
1227         static PluginHostType hostType;
1228         return hostType;
1229     }
1230
1231     //==============================================================================
1232     // A component to hold the AudioProcessorEditor, and cope with some housekeeping
1233     // chores when it changes or repaints.
1234     class EditorCompWrapper  : public Component,
1235                                public AsyncUpdater
1236     {
1237     public:
1238         EditorCompWrapper (JuceVSTWrapper& wrapper_, AudioProcessorEditor* editor)
1239             : wrapper (wrapper_)
1240         {
1241             setOpaque (true);
1242             editor->setOpaque (true);
1243
1244             setBounds (editor->getBounds());
1245             editor->setTopLeftPosition (0, 0);
1246             addAndMakeVisible (editor);
1247
1248           #if JUCE_WINDOWS
1249             if (! getHostType().isReceptor())
1250                 addMouseListener (this, true);
1251
1252             registerMouseWheelHook();
1253           #endif
1254         }
1255
1256         ~EditorCompWrapper()
1257         {
1258           #if JUCE_WINDOWS
1259             unregisterMouseWheelHook();
1260           #endif
1261
1262             deleteAllChildren(); // note that we can't use a ScopedPointer because the editor may
1263                                  // have been transferred to another parent which takes over ownership.
1264         }
1265
1266         void paint (Graphics&) {}
1267
1268         void paintOverChildren (Graphics&)
1269         {
1270             // this causes an async call to masterIdle() to help
1271             // creaky old DAWs like Nuendo repaint themselves while we're
1272             // repainting. Otherwise they just seem to give up and sit there
1273             // waiting.
1274             triggerAsyncUpdate();
1275         }
1276
1277        #if JUCE_MAC
1278         bool keyPressed (const KeyPress& kp)
1279         {
1280             // If we have an unused keypress, move the key-focus to a host window
1281             // and re-inject the event..
1282             forwardCurrentKeyEventToHost (this);
1283             return true;
1284         }
1285        #endif
1286
1287         AudioProcessorEditor* getEditorComp() const
1288         {
1289             return dynamic_cast <AudioProcessorEditor*> (getChildComponent (0));
1290         }
1291
1292         void resized()
1293         {
1294             Component* const editor = getChildComponent(0);
1295
1296             if (editor != nullptr)
1297                 editor->setBounds (getLocalBounds());
1298         }
1299
1300         void childBoundsChanged (Component* child)
1301         {
1302             child->setTopLeftPosition (0, 0);
1303
1304             const int cw = child->getWidth();
1305             const int ch = child->getHeight();
1306
1307             wrapper.resizeHostWindow (cw, ch);
1308
1309            #if ! JUCE_LINUX // setSize() on linux causes renoise and energyxt to fail.
1310             setSize (cw, ch);
1311            #else
1312             XResizeWindow (display, (Window) getWindowHandle(), cw, ch);
1313            #endif
1314
1315            #if JUCE_MAC
1316             wrapper.resizeHostWindow (cw, ch);  // (doing this a second time seems to be necessary in tracktion)
1317            #endif
1318         }
1319
1320         void handleAsyncUpdate()
1321         {
1322             wrapper.tryMasterIdle();
1323         }
1324
1325        #if JUCE_WINDOWS
1326         void mouseDown (const MouseEvent&)
1327         {
1328             broughtToFront();
1329         }
1330
1331         void broughtToFront()
1332         {
1333             // for hosts like nuendo, need to also pop the MDI container to the
1334             // front when our comp is clicked on.
1335             HWND parent = findMDIParentOf ((HWND) getWindowHandle());
1336
1337             if (parent != 0)
1338                 SetWindowPos (parent, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
1339         }
1340        #endif
1341
1342     private:
1343         //==============================================================================
1344         JuceVSTWrapper& wrapper;
1345         FakeMouseMoveGenerator fakeMouseGenerator;
1346
1347         JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (EditorCompWrapper);
1348     };
1349
1350     //==============================================================================
1351 private:
1352     AudioProcessor* filter;
1353     JUCE_NAMESPACE::MemoryBlock chunkMemory;
1354     JUCE_NAMESPACE::uint32 chunkMemoryTime;
1355     ScopedPointer<EditorCompWrapper> editorComp;
1356     ERect editorSize;
1357     MidiBuffer midiEvents;
1358     VSTMidiEventList outgoingEvents;
1359     VstSpeakerArrangementType speakerIn, speakerOut;
1360     int numInChans, numOutChans;
1361     bool isProcessing, hasShutdown, firstProcessCallback, shouldDeleteEditor;
1362     HeapBlock<float*> channels;
1363     Array<float*> tempChannels;  // see note in processReplacing()
1364
1365    #if JUCE_MAC
1366     void* hostWindow;
1367    #elif JUCE_LINUX
1368     Window hostWindow;
1369    #else
1370     HWND hostWindow;
1371    #endif
1372
1373     //==============================================================================
1374    #if JUCE_WINDOWS
1375     // Workarounds for Wavelab's happy-go-lucky use of threads.
1376     static void checkWhetherMessageThreadIsCorrect()
1377     {
1378         if (getHostType().isWavelab() || getHostType().isCubaseBridged())
1379         {
1380             static bool messageThreadIsDefinitelyCorrect = false;
1381
1382             if (! messageThreadIsDefinitelyCorrect)
1383             {
1384                 MessageManager::getInstance()->setCurrentThreadAsMessageThread();
1385
1386                 class MessageThreadCallback  : public CallbackMessage
1387                 {
1388                 public:
1389                     MessageThreadCallback (bool& triggered_) : triggered (triggered_) {}
1390
1391                     void messageCallback()
1392                     {
1393                         triggered = true;
1394                     }
1395
1396                 private:
1397                     bool& triggered;
1398                 };
1399
1400                 (new MessageThreadCallback (messageThreadIsDefinitelyCorrect))->post();
1401             }
1402         }
1403     }
1404    #else
1405     static void checkWhetherMessageThreadIsCorrect() {}
1406    #endif
1407
1408     //==============================================================================
1409     void deleteTempChannels()
1410     {
1411         for (int i = tempChannels.size(); --i >= 0;)
1412             delete[] (tempChannels.getUnchecked(i));
1413
1414         tempChannels.clear();
1415
1416         if (filter != nullptr)
1417             tempChannels.insertMultiple (0, 0, filter->getNumInputChannels() + filter->getNumOutputChannels());
1418     }
1419
1420     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (JuceVSTWrapper);
1421 };
1422
1423 //==============================================================================
1424 /** Somewhere in the codebase of your plugin, you need to implement this function
1425     and make it create an instance of the filter subclass that you're building.
1426 */
1427 extern AudioProcessor* JUCE_CALLTYPE createPluginFilter();
1428
1429
1430 //==============================================================================
1431 namespace
1432 {
1433     AEffect* pluginEntryPoint (audioMasterCallback audioMaster)
1434     {
1435         JUCE_AUTORELEASEPOOL
1436         initialiseJuce_GUI();
1437
1438         try
1439         {
1440             if (audioMaster (0, audioMasterVersion, 0, 0, 0, 0) != 0)
1441             {
1442                #if JUCE_LINUX
1443                 MessageManagerLock mmLock;
1444                #endif
1445
1446                 AudioProcessor* const filter = createPluginFilter();
1447
1448                 if (filter != nullptr)
1449                 {
1450                     JuceVSTWrapper* const wrapper = new JuceVSTWrapper (audioMaster, filter);
1451                     return wrapper->getAeffect();
1452                 }
1453             }
1454         }
1455         catch (...)
1456         {}
1457
1458         return nullptr;
1459     }
1460 }
1461
1462 //==============================================================================
1463 // Mac startup code..
1464 #if JUCE_MAC
1465
1466     extern "C" __attribute__ ((visibility("default"))) AEffect* VSTPluginMain (audioMasterCallback audioMaster)
1467     {
1468         initialiseMac();
1469         return pluginEntryPoint (audioMaster);
1470     }
1471
1472     extern "C" __attribute__ ((visibility("default"))) AEffect* main_macho (audioMasterCallback audioMaster)
1473     {
1474         initialiseMac();
1475         return pluginEntryPoint (audioMaster);
1476     }
1477
1478 //==============================================================================
1479 // Linux startup code..
1480 #elif JUCE_LINUX
1481
1482     extern "C" __attribute__ ((visibility("default"))) AEffect* VSTPluginMain (audioMasterCallback audioMaster)
1483     {
1484         SharedMessageThread::getInstance();
1485         return pluginEntryPoint (audioMaster);
1486     }
1487
1488     extern "C" __attribute__ ((visibility("default"))) AEffect* main_plugin (audioMasterCallback audioMaster) asm ("main");
1489
1490     extern "C" __attribute__ ((visibility("default"))) AEffect* main_plugin (audioMasterCallback audioMaster)
1491     {
1492         return VSTPluginMain (audioMaster);
1493     }
1494
1495     // don't put initialiseJuce_GUI or shutdownJuce_GUI in these... it will crash!
1496     __attribute__((constructor)) void myPluginInit() {}
1497     __attribute__((destructor))  void myPluginFini() {}
1498
1499 //==============================================================================
1500 // Win32 startup code..
1501 #else
1502
1503     extern "C" __declspec (dllexport) AEffect* VSTPluginMain (audioMasterCallback audioMaster)
1504     {
1505         return pluginEntryPoint (audioMaster);
1506     }
1507
1508    #ifndef _WIN64 // (can't compile this on win64, but it's not needed anyway with VST2.4)
1509     extern "C" __declspec (dllexport) void* main (audioMasterCallback audioMaster)
1510     {
1511         return (void*) pluginEntryPoint (audioMaster);
1512     }
1513    #endif
1514
1515    #if JucePlugin_Build_RTAS
1516     BOOL WINAPI DllMainVST (HINSTANCE instance, DWORD dwReason, LPVOID)
1517    #else
1518     extern "C" BOOL WINAPI DllMain (HINSTANCE instance, DWORD dwReason, LPVOID)
1519    #endif
1520     {
1521         if (dwReason == DLL_PROCESS_ATTACH)
1522             PlatformUtilities::setCurrentModuleInstanceHandle (instance);
1523
1524         return TRUE;
1525     }
1526 #endif
1527
1528 #endif