libs/vamp-sdk/src/vamp-hostsdk/PluginLoader.cpp

   1 /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
   2
   3 /*
   4     Vamp
   5
   6     An API for audio analysis and feature extraction plugins.
   7
   8     Centre for Digital Music, Queen Mary, University of London.
   9     Copyright 2006-2009 Chris Cannam and QMUL.
  10
  11     Permission is hereby granted, free of charge, to any person
  12     obtaining a copy of this software and associated documentation
  13     files (the "Software"), to deal in the Software without
  14     restriction, including without limitation the rights to use, copy,
  15     modify, merge, publish, distribute, sublicense, and/or sell copies
  16     of the Software, and to permit persons to whom the Software is
  17     furnished to do so, subject to the following conditions:
  18
  19     The above copyright notice and this permission notice shall be
  20     included in all copies or substantial portions of the Software.
  21
  22     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
  26     ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
  27     CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28     WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29
  30     Except as contained in this notice, the names of the Centre for
  31     Digital Music; Queen Mary, University of London; and Chris Cannam
  32     shall not be used in advertising or otherwise to promote the sale,
  33     use or other dealings in this Software without prior written
  34     authorization.
  35 */
  36
  37 #include "vamp-hostsdk/PluginHostAdapter.h"
  38 #include "vamp-hostsdk/PluginLoader.h"
  39 #include "vamp-hostsdk/PluginInputDomainAdapter.h"
  40 #include "vamp-hostsdk/PluginChannelAdapter.h"
  41 #include "vamp-hostsdk/PluginBufferingAdapter.h"
  42
  43 #include <fstream>
  44 #include <cctype> // tolower
  45
  46 #include <cstring>
  47
  48 #ifdef _WIN32
  49
  50 #include <windows.h>
  51 #include <tchar.h>
  52 #define PLUGIN_SUFFIX "dll"
  53
  54 #else /* ! _WIN32 */
  55
  56 #include <dirent.h>
  57 #include <dlfcn.h>
  58
  59 #ifdef __APPLE__
  60 #define PLUGIN_SUFFIX "dylib"
  61 #else /* ! __APPLE__ */
  62 #define PLUGIN_SUFFIX "so"
  63 #endif /* ! __APPLE__ */
  64
  65 #endif /* ! _WIN32 */
  66
  67 using namespace std;
  68
  69 _VAMP_SDK_HOSTSPACE_BEGIN(PluginLoader.cpp)
  70
  71 namespace Vamp {
  72
  73 namespace HostExt {
  74
  75 class PluginLoader::Impl
  76 {
  77 public:
  78     Impl();
  79     virtual ~Impl();
  80
  81     PluginKeyList listPlugins();
  82
  83     Plugin *loadPlugin(PluginKey key,
  84                        float inputSampleRate,
  85                        int adapterFlags);
  86
  87     PluginKey composePluginKey(string libraryName, string identifier);
  88
  89     PluginCategoryHierarchy getPluginCategory(PluginKey key);
  90
  91     string getLibraryPathForPlugin(PluginKey key);
  92
  93     static void setInstanceToClean(PluginLoader *instance);
  94
  95 protected:
  96     class PluginDeletionNotifyAdapter : public PluginWrapper {
  97     public:
  98         PluginDeletionNotifyAdapter(Plugin *plugin, Impl *loader);
  99         virtual ~PluginDeletionNotifyAdapter();
 100     protected:
 101         Impl *m_loader;
 102     };
 103
 104     class InstanceCleaner {
 105     public:
 106         InstanceCleaner() : m_instance(0) { }
 107         ~InstanceCleaner() { delete m_instance; }
 108         void setInstance(PluginLoader *instance) { m_instance = instance; }
 109     protected:
 110         PluginLoader *m_instance;
 111     };
 112
 113     virtual void pluginDeleted(PluginDeletionNotifyAdapter *adapter);
 114
 115     map<PluginKey, string> m_pluginLibraryNameMap;
 116     bool m_allPluginsEnumerated;
 117     void enumeratePlugins(PluginKey forPlugin = "");
 118
 119     map<PluginKey, PluginCategoryHierarchy> m_taxonomy;
 120     void generateTaxonomy();
 121
 122     map<Plugin *, void *> m_pluginLibraryHandleMap;
 123
 124     bool decomposePluginKey(PluginKey key,
 125                             string &libraryName, string &identifier);
 126
 127     void *loadLibrary(string path);
 128     void unloadLibrary(void *handle);
 129     void *lookupInLibrary(void *handle, const char *symbol);
 130
 131     string splicePath(string a, string b);
 132     vector<string> listFiles(string dir, string ext);
 133
 134     static InstanceCleaner m_cleaner;
 135 };
 136
 137 PluginLoader *
 138 PluginLoader::m_instance = 0;
 139
 140 PluginLoader::Impl::InstanceCleaner
 141 PluginLoader::Impl::m_cleaner;
 142
 143 PluginLoader::PluginLoader()
 144 {
 145     m_impl = new Impl();
 146 }
 147
 148 PluginLoader::~PluginLoader()
 149 {
 150     delete m_impl;
 151 }
 152
 153 PluginLoader *
 154 PluginLoader::getInstance()
 155 {
 156     if (!m_instance) {
 157         // The cleaner doesn't own the instance, because we leave the
 158         // instance pointer in the base class for binary backwards
 159         // compatibility reasons and to avoid waste
 160         m_instance = new PluginLoader();
 161         Impl::setInstanceToClean(m_instance);
 162     }
 163     return m_instance;
 164 }
 165
 166 vector<PluginLoader::PluginKey>
 167 PluginLoader::listPlugins()
 168 {
 169     return m_impl->listPlugins();
 170 }
 171
 172 Plugin *
 173 PluginLoader::loadPlugin(PluginKey key,
 174                          float inputSampleRate,
 175                          int adapterFlags)
 176 {
 177     return m_impl->loadPlugin(key, inputSampleRate, adapterFlags);
 178 }
 179
 180 PluginLoader::PluginKey
 181 PluginLoader::composePluginKey(string libraryName, string identifier)
 182 {
 183     return m_impl->composePluginKey(libraryName, identifier);
 184 }
 185
 186 PluginLoader::PluginCategoryHierarchy
 187 PluginLoader::getPluginCategory(PluginKey key)
 188 {
 189     return m_impl->getPluginCategory(key);
 190 }
 191
 192 string
 193 PluginLoader::getLibraryPathForPlugin(PluginKey key)
 194 {
 195     return m_impl->getLibraryPathForPlugin(key);
 196 }
 197
 198 PluginLoader::Impl::Impl() :
 199     m_allPluginsEnumerated(false)
 200 {
 201 }
 202
 203 PluginLoader::Impl::~Impl()
 204 {
 205 }
 206
 207 void
 208 PluginLoader::Impl::setInstanceToClean(PluginLoader *instance)
 209 {
 210     m_cleaner.setInstance(instance);
 211 }
 212
 213 vector<PluginLoader::PluginKey>
 214 PluginLoader::Impl::listPlugins()
 215 {
 216     if (!m_allPluginsEnumerated) enumeratePlugins();
 217
 218     vector<PluginKey> plugins;
 219     for (map<PluginKey, string>::iterator mi = m_pluginLibraryNameMap.begin();
 220          mi != m_pluginLibraryNameMap.end(); ++mi) {
 221         plugins.push_back(mi->first);
 222     }
 223
 224     return plugins;
 225 }
 226
 227 void
 228 PluginLoader::Impl::enumeratePlugins(PluginKey forPlugin)
 229 {
 230     vector<string> path = PluginHostAdapter::getPluginPath();
 231
 232     string libraryName, identifier;
 233     if (forPlugin != "") {
 234         if (!decomposePluginKey(forPlugin, libraryName, identifier)) {
 235             std::cerr << "WARNING: Vamp::HostExt::PluginLoader: Invalid plugin key \""
 236                       << forPlugin << "\" in enumerate" << std::endl;
 237             return;
 238         }
 239     }
 240
 241     for (size_t i = 0; i < path.size(); ++i) {
 242
 243         vector<string> files = listFiles(path[i], PLUGIN_SUFFIX);
 244
 245         for (vector<string>::iterator fi = files.begin();
 246              fi != files.end(); ++fi) {
 247
 248             if (libraryName != "") {
 249                 // libraryName is lowercased and lacking an extension,
 250                 // as it came from the plugin key
 251                 string temp = *fi;
 252                 for (size_t i = 0; i < temp.length(); ++i) {
 253                     temp[i] = tolower(temp[i]);
 254                 }
 255                 string::size_type pi = temp.find('.');
 256                 if (pi == string::npos) {
 257                     if (libraryName != temp) continue;
 258                 } else {
 259                     if (libraryName != temp.substr(0, pi)) continue;
 260                 }
 261             }
 262
 263             string fullPath = path[i];
 264             fullPath = splicePath(fullPath, *fi);
 265             void *handle = loadLibrary(fullPath);
 266             if (!handle) continue;
 267
 268             VampGetPluginDescriptorFunction fn =
 269                 (VampGetPluginDescriptorFunction)lookupInLibrary
 270                 (handle, "vampGetPluginDescriptor");
 271
 272             if (!fn) {
 273                 if (forPlugin != "") {
 274                     cerr << "Vamp::HostExt::PluginLoader: No vampGetPluginDescriptor function found in library \""
 275                          << fullPath << "\"" << endl;
 276                 }
 277                 unloadLibrary(handle);
 278                 continue;
 279             }
 280
 281             int index = 0;
 282             const VampPluginDescriptor *descriptor = 0;
 283             bool found = false;
 284
 285             while ((descriptor = fn(VAMP_API_VERSION, index))) {
 286                 ++index;
 287                 if (identifier != "") {
 288                     if (descriptor->identifier != identifier) continue;
 289                 }
 290
 291                 found = true;
 292                 PluginKey key = composePluginKey(*fi, descriptor->identifier);
 293
 294                 if (m_pluginLibraryNameMap.find(key) ==
 295                     m_pluginLibraryNameMap.end()) {
 296                     m_pluginLibraryNameMap[key] = fullPath;
 297                 }
 298             }
 299
 300             if (!found && forPlugin != "") {
 301                 cerr << "Vamp::HostExt::PluginLoader: Plugin \""
 302                      << identifier << "\" not found in library \""
 303                      << fullPath << "\"" << endl;
 304             }
 305
 306             unloadLibrary(handle);
 307         }
 308     }
 309
 310     if (forPlugin == "") m_allPluginsEnumerated = true;
 311 }
 312
 313 PluginLoader::PluginKey
 314 PluginLoader::Impl::composePluginKey(string libraryName, string identifier)
 315 {
 316     string basename = libraryName;
 317
 318     string::size_type li = basename.rfind('/');
 319     if (li != string::npos) basename = basename.substr(li + 1);
 320
 321     li = basename.find('.');
 322     if (li != string::npos) basename = basename.substr(0, li);
 323
 324     for (size_t i = 0; i < basename.length(); ++i) {
 325         basename[i] = tolower(basename[i]);
 326     }
 327
 328     return basename + ":" + identifier;
 329 }
 330
 331 bool
 332 PluginLoader::Impl::decomposePluginKey(PluginKey key,
 333                                        string &libraryName,
 334                                        string &identifier)
 335 {
 336     string::size_type ki = key.find(':');
 337     if (ki == string::npos) {
 338         return false;
 339     }
 340
 341     libraryName = key.substr(0, ki);
 342     identifier = key.substr(ki + 1);
 343     return true;
 344 }
 345
 346 PluginLoader::PluginCategoryHierarchy
 347 PluginLoader::Impl::getPluginCategory(PluginKey plugin)
 348 {
 349     if (m_taxonomy.empty()) generateTaxonomy();
 350     if (m_taxonomy.find(plugin) == m_taxonomy.end()) {
 351         return PluginCategoryHierarchy();
 352     }
 353     return m_taxonomy[plugin];
 354 }
 355
 356 string
 357 PluginLoader::Impl::getLibraryPathForPlugin(PluginKey plugin)
 358 {
 359     if (m_pluginLibraryNameMap.find(plugin) == m_pluginLibraryNameMap.end()) {
 360         if (m_allPluginsEnumerated) return "";
 361         cerr << "plug " << plugin << " not found enumerate" << endl;
 362         enumeratePlugins(plugin);
 363     }
 364     if (m_pluginLibraryNameMap.find(plugin) == m_pluginLibraryNameMap.end()) {
 365         cerr << "plug " << plugin << " not found enumerate" << endl;
 366         return "";
 367     }
 368     cerr << "Did find plugin " << plugin << endl;
 369     return m_pluginLibraryNameMap[plugin];
 370 }
 371
 372 Plugin *
 373 PluginLoader::Impl::loadPlugin(PluginKey key,
 374                                float inputSampleRate, int adapterFlags)
 375 {
 376     string libname, identifier;
 377     if (!decomposePluginKey(key, libname, identifier)) {
 378         std::cerr << "Vamp::HostExt::PluginLoader: Invalid plugin key \""
 379                   << key << "\" in loadPlugin" << std::endl;
 380         return 0;
 381     }
 382
 383     string fullPath = getLibraryPathForPlugin(key);
 384     if (fullPath == "") {
 385         std::cerr << "Vamp::HostExt::PluginLoader: No library found in Vamp path for plugin \"" << key << "\"" << std::endl;
 386         return 0;
 387     }
 388
 389     void *handle = loadLibrary(fullPath);
 390     if (!handle) return 0;
 391
 392     VampGetPluginDescriptorFunction fn =
 393         (VampGetPluginDescriptorFunction)lookupInLibrary
 394         (handle, "vampGetPluginDescriptor");
 395
 396     if (!fn) {
 397         cerr << "Vamp::HostExt::PluginLoader: No vampGetPluginDescriptor function found in library \""
 398              << fullPath << "\"" << endl;
 399         unloadLibrary(handle);
 400         return 0;
 401     }
 402
 403     int index = 0;
 404     const VampPluginDescriptor *descriptor = 0;
 405
 406     while ((descriptor = fn(VAMP_API_VERSION, index))) {
 407
 408         if (string(descriptor->identifier) == identifier) {
 409
 410             Vamp::PluginHostAdapter *plugin =
 411                 new Vamp::PluginHostAdapter(descriptor, inputSampleRate);
 412
 413             Plugin *adapter = new PluginDeletionNotifyAdapter(plugin, this);
 414
 415             m_pluginLibraryHandleMap[adapter] = handle;
 416
 417             if (adapterFlags & ADAPT_BUFFER_SIZE) {
 418                 PluginBufferingAdapter* a = new PluginBufferingAdapter(adapter);
 419                 adapter = a;
 420             }
 421
 422             if (adapterFlags & ADAPT_INPUT_DOMAIN) {
 423                 if (adapter->getInputDomain() == Plugin::FrequencyDomain) {
 424                     adapter = new PluginInputDomainAdapter(adapter);
 425                 }
 426             }
 427
 428             if (adapterFlags & ADAPT_CHANNEL_COUNT) {
 429                 adapter = new PluginChannelAdapter(adapter);
 430             }
 431
 432             return adapter;
 433         }
 434
 435         ++index;
 436     }
 437
 438     cerr << "Vamp::HostExt::PluginLoader: Plugin \""
 439          << identifier << "\" not found in library \""
 440          << fullPath << "\"" << endl;
 441
 442     return 0;
 443 }
 444
 445 void
 446 PluginLoader::Impl::generateTaxonomy()
 447 {
 448 //    cerr << "PluginLoader::Impl::generateTaxonomy" << endl;
 449
 450     vector<string> path = PluginHostAdapter::getPluginPath();
 451     string libfragment = "/lib/";
 452     vector<string> catpath;
 453
 454     string suffix = "cat";
 455
 456     for (vector<string>::iterator i = path.begin();
 457          i != path.end(); ++i) {
 458
 459         // It doesn't matter that we're using literal forward-slash in
 460         // this bit, as it's only relevant if the path contains
 461         // "/lib/", which is only meaningful and only plausible on
 462         // systems with forward-slash delimiters
 463
 464         string dir = *i;
 465         string::size_type li = dir.find(libfragment);
 466
 467         if (li != string::npos) {
 468             catpath.push_back
 469                 (dir.substr(0, li)
 470                  + "/share/"
 471                  + dir.substr(li + libfragment.length()));
 472         }
 473
 474         catpath.push_back(dir);
 475     }
 476
 477     char buffer[1024];
 478
 479     for (vector<string>::iterator i = catpath.begin();
 480          i != catpath.end(); ++i) {
 481
 482         vector<string> files = listFiles(*i, suffix);
 483
 484         for (vector<string>::iterator fi = files.begin();
 485              fi != files.end(); ++fi) {
 486
 487             string filepath = splicePath(*i, *fi);
 488             ifstream is(filepath.c_str(), ifstream::in | ifstream::binary);
 489
 490             if (is.fail()) {
 491 //                cerr << "failed to open: " << filepath << endl;
 492                 continue;
 493             }
 494
 495 //            cerr << "opened: " << filepath << endl;
 496
 497             while (!!is.getline(buffer, 1024)) {
 498
 499                 string line(buffer);
 500
 501 //                cerr << "line = " << line << endl;
 502
 503                 string::size_type di = line.find("::");
 504                 if (di == string::npos) continue;
 505
 506                 string id = line.substr(0, di);
 507                 string encodedCat = line.substr(di + 2);
 508
 509                 if (id.substr(0, 5) != "vamp:") continue;
 510                 id = id.substr(5);
 511
 512                 while (encodedCat.length() >= 1 &&
 513                        encodedCat[encodedCat.length()-1] == '\r') {
 514                     encodedCat = encodedCat.substr(0, encodedCat.length()-1);
 515                 }
 516
 517 //                cerr << "id = " << id << ", cat = " << encodedCat << endl;
 518
 519                 PluginCategoryHierarchy category;
 520                 string::size_type ai;
 521                 while ((ai = encodedCat.find(" > ")) != string::npos) {
 522                     category.push_back(encodedCat.substr(0, ai));
 523                     encodedCat = encodedCat.substr(ai + 3);
 524                 }
 525                 if (encodedCat != "") category.push_back(encodedCat);
 526
 527                 m_taxonomy[id] = category;
 528             }
 529         }
 530     }
 531 }
 532
 533 void *
 534 PluginLoader::Impl::loadLibrary(string path)
 535 {
 536     void *handle = 0;
 537 #ifdef _WIN32
 538 #ifdef UNICODE
 539     int len = path.length(); // cannot be more wchars than length in bytes of utf8 string
 540     wchar_t *buffer = new wchar_t[len];
 541     int rv = MultiByteToWideChar(CP_UTF8, 0, path.c_str(), len, buffer, len);
 542     if (rv <= 0) {
 543         cerr << "Vamp::HostExt::PluginLoader: Unable to convert library path \""
 544              << path << "\" to wide characters " << endl;
 545         delete[] buffer;
 546         return handle;
 547     }
 548     handle = LoadLibrary(buffer);
 549     delete[] buffer;
 550 #else
 551     handle = LoadLibrary(path.c_str());
 552 #endif
 553     if (!handle) {
 554         cerr << "Vamp::HostExt::PluginLoader: Unable to load library \""
 555              << path << "\"" << endl;
 556     }
 557 #else
 558     handle = dlopen(path.c_str(), RTLD_LAZY | RTLD_LOCAL);
 559     if (!handle) {
 560         cerr << "Vamp::HostExt::PluginLoader: Unable to load library \""
 561              << path << "\": " << dlerror() << endl;
 562     }
 563 #endif
 564     return handle;
 565 }
 566
 567 void
 568 PluginLoader::Impl::unloadLibrary(void *handle)
 569 {
 570 #ifdef _WIN32
 571     FreeLibrary((HINSTANCE)handle);
 572 #else
 573     dlclose(handle);
 574 #endif
 575 }
 576
 577 void *
 578 PluginLoader::Impl::lookupInLibrary(void *handle, const char *symbol)
 579 {
 580 #ifdef _WIN32
 581     return (void *)GetProcAddress((HINSTANCE)handle, symbol);
 582 #else
 583     return (void *)dlsym(handle, symbol);
 584 #endif
 585 }
 586
 587 string
 588 PluginLoader::Impl::splicePath(string a, string b)
 589 {
 590 #ifdef _WIN32
 591     return a + "\\" + b;
 592 #else
 593     return a + "/" + b;
 594 #endif
 595 }
 596
 597 vector<string>
 598 PluginLoader::Impl::listFiles(string dir, string extension)
 599 {
 600     vector<string> files;
 601
 602 #ifdef _WIN32
 603     string expression = dir + "\\*." + extension;
 604 #ifdef UNICODE
 605     int len = expression.length(); // cannot be more wchars than length in bytes of utf8 string
 606     wchar_t *buffer = new wchar_t[len];
 607     int rv = MultiByteToWideChar(CP_UTF8, 0, expression.c_str(), len, buffer, len);
 608     if (rv <= 0) {
 609         cerr << "Vamp::HostExt::PluginLoader: Unable to convert wildcard path \""
 610              << expression << "\" to wide characters" << endl;
 611         delete[] buffer;
 612         return files;
 613     }
 614     WIN32_FIND_DATA data;
 615     HANDLE fh = FindFirstFile(buffer, &data);
 616     if (fh == INVALID_HANDLE_VALUE) {
 617         delete[] buffer;
 618         return files;
 619     }
 620
 621     bool ok = true;
 622     while (ok) {
 623         wchar_t *fn = data.cFileName;
 624         int wlen = wcslen(fn);
 625         int maxlen = wlen * 6;
 626         char *conv = new char[maxlen];
 627         int rv = WideCharToMultiByte(CP_UTF8, 0, fn, wlen, conv, maxlen, 0, 0);
 628         if (rv > 0) {
 629             files.push_back(conv);
 630         }
 631         delete[] conv;
 632         ok = FindNextFile(fh, &data);
 633     }
 634
 635     FindClose(fh);
 636     delete[] buffer;
 637 #else
 638     WIN32_FIND_DATA data;
 639     HANDLE fh = FindFirstFile(expression.c_str(), &data);
 640     if (fh == INVALID_HANDLE_VALUE) return files;
 641
 642     bool ok = true;
 643     while (ok) {
 644         files.push_back(data.cFileName);
 645         ok = FindNextFile(fh, &data);
 646     }
 647
 648     FindClose(fh);
 649 #endif
 650 #else
 651
 652     size_t extlen = extension.length();
 653     DIR *d = opendir(dir.c_str());
 654     if (!d) return files;
 655
 656     struct dirent *e = 0;
 657     while ((e = readdir(d))) {
 658
 659         if (!e->d_name) continue;
 660
 661         size_t len = strlen(e->d_name);
 662         if (len < extlen + 2 ||
 663             e->d_name + len - extlen - 1 != "." + extension) {
 664             continue;
 665         }
 666
 667         files.push_back(e->d_name);
 668     }
 669
 670     closedir(d);
 671 #endif
 672
 673     return files;
 674 }
 675
 676 void
 677 PluginLoader::Impl::pluginDeleted(PluginDeletionNotifyAdapter *adapter)
 678 {
 679     void *handle = m_pluginLibraryHandleMap[adapter];
 680     if (handle) unloadLibrary(handle);
 681     m_pluginLibraryHandleMap.erase(adapter);
 682 }
 683
 684 PluginLoader::Impl::PluginDeletionNotifyAdapter::PluginDeletionNotifyAdapter(Plugin *plugin,
 685                                                                              Impl *loader) :
 686     PluginWrapper(plugin),
 687     m_loader(loader)
 688 {
 689 }
 690
 691 PluginLoader::Impl::PluginDeletionNotifyAdapter::~PluginDeletionNotifyAdapter()
 692 {
 693     // We need to delete the plugin before calling pluginDeleted, as
 694     // the delete call may require calling through to the descriptor
 695     // (for e.g. cleanup) but pluginDeleted may unload the required
 696     // library for the call.  To prevent a double deletion when our
 697     // parent's destructor runs (after this one), be sure to set
 698     // m_plugin to 0 after deletion.
 699     delete m_plugin;
 700     m_plugin = 0;
 701
 702     if (m_loader) m_loader->pluginDeleted(this);
 703 }
 704
 705 }
 706
 707 }
 708
 709 _VAMP_SDK_HOSTSPACE_END(PluginLoader.cpp)
 710