source/backend/CarlaStandaloneNSM.cpp

   1 /*
   2  * Carla Standalone
   3  * Copyright (C) 2011-2022 Filipe Coelho <falktx@falktx.com>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of
   8  * the License, or any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * For a full copy of the GNU General Public License see the doc/GPL.txt file.
  16  */
  17
  18 #include "CarlaHostImpl.hpp"
  19
  20 #if defined(HAVE_LIBLO) && !defined(CARLA_OS_WASM)
  21
  22 #define CARLA_ENABLE_STANDALONE_NSM
  23
  24 #define NSM_API_VERSION_MAJOR 1
  25 #define NSM_API_VERSION_MINOR 2
  26
  27 // #define NSM_CLIENT_FEATURES ":switch:"
  28 #define NSM_CLIENT_FEATURES ":switch:optional-gui:"
  29
  30 #include "CarlaOscUtils.hpp"
  31 #include "CarlaString.hpp"
  32
  33 #include "water/files/File.h"
  34
  35 // -------------------------------------------------------------------------------------------------------------------
  36
  37 class CarlaNSM
  38 {
  39 public:
  40     CarlaNSM(CarlaHostStandalone& shandle) noexcept
  41         : gStandalone(shandle),
  42           fReplyAddress(nullptr),
  43           fServer(nullptr),
  44           fServerThread(nullptr),
  45           fServerURL(nullptr),
  46           fClientNameId(),
  47           fProjectPath(),
  48           fHasBroadcast(false),
  49           fHasOptionalGui(false),
  50           fHasServerControl(false),
  51           fStarted(),
  52           fReadyActionOpen(true),
  53           fReadyActionSave(true) {}
  54
  55     ~CarlaNSM()
  56     {
  57         CARLA_SAFE_ASSERT(fReadyActionOpen);
  58         CARLA_SAFE_ASSERT(fReadyActionSave);
  59
  60         if (fServerThread != nullptr)
  61         {
  62             lo_server_thread_stop(fServerThread);
  63             lo_server_thread_free(fServerThread);
  64             fServerThread = nullptr;
  65             fServer = nullptr;
  66         }
  67
  68         if (fServerURL != nullptr)
  69         {
  70             std::free(fServerURL);
  71             fServerURL = nullptr;
  72         }
  73
  74         if (fReplyAddress != nullptr)
  75         {
  76             lo_address_free(fReplyAddress);
  77             fReplyAddress = nullptr;
  78         }
  79     }
  80
  81     bool announce(const uint64_t pid, const char* const executableName)
  82     {
  83         CARLA_SAFE_ASSERT_RETURN(pid != 0, false);
  84         CARLA_SAFE_ASSERT_RETURN(executableName != nullptr && executableName[0] != '\0', false);
  85
  86         const char* const NSM_URL(std::getenv("NSM_URL"));
  87
  88         if (NSM_URL == nullptr)
  89             return false;
  90
  91         const lo_address nsmAddress(lo_address_new_from_url(NSM_URL));
  92         CARLA_SAFE_ASSERT_RETURN(nsmAddress != nullptr, false);
  93
  94         const int proto = lo_address_get_protocol(nsmAddress);
  95
  96         if (fServerThread == nullptr)
  97         {
  98             // create new OSC server
  99             fServerThread = lo_server_thread_new_with_proto(nullptr, proto, _osc_error_handler);
 100             CARLA_SAFE_ASSERT_RETURN(fServerThread != nullptr, false);
 101
 102             // register message handlers
 103             lo_server_thread_add_method(fServerThread, "/error",                       "sis",    _error_handler,     this);
 104             lo_server_thread_add_method(fServerThread, "/reply",                       "ssss",   _reply_handler,     this);
 105             lo_server_thread_add_method(fServerThread, "/nsm/client/open",             "sss",    _open_handler,      this);
 106             lo_server_thread_add_method(fServerThread, "/nsm/client/save",              "",      _save_handler,      this);
 107             lo_server_thread_add_method(fServerThread, "/nsm/client/session_is_loaded", "",      _loaded_handler,    this);
 108             lo_server_thread_add_method(fServerThread, "/nsm/client/show_optional_gui", "",      _show_gui_handler,  this);
 109             lo_server_thread_add_method(fServerThread, "/nsm/client/hide_optional_gui", "",      _hide_gui_handler,  this);
 110             lo_server_thread_add_method(fServerThread, nullptr,                         nullptr, _broadcast_handler, this);
 111
 112             fServer    = lo_server_thread_get_server(fServerThread);
 113             fServerURL = lo_server_thread_get_url(fServerThread);
 114         }
 115
 116         const char* appName = std::getenv("CARLA_NSM_NAME");
 117
 118         if (appName == nullptr)
 119             appName = "Carla";
 120
 121         lo_send_from(nsmAddress, fServer, LO_TT_IMMEDIATE, "/nsm/server/announce", "sssiii",
 122                      appName, NSM_CLIENT_FEATURES, executableName, NSM_API_VERSION_MAJOR, NSM_API_VERSION_MINOR, pid);
 123
 124         lo_address_free(nsmAddress);
 125
 126         if (gStandalone.engineCallback != nullptr)
 127         {
 128             gStandalone.engineCallback(gStandalone.engineCallbackPtr,
 129                                        CB::ENGINE_CALLBACK_NSM,
 130                                        0,
 131                                        CB::NSM_CALLBACK_INIT,
 132                                        0, 0, 0.0f, nullptr);
 133         }
 134
 135         return true;
 136     }
 137
 138     void ready(const NsmCallbackOpcode action)
 139     {
 140         CARLA_SAFE_ASSERT_RETURN(fServerThread != nullptr,);
 141
 142         switch (action)
 143         {
 144         case CB::NSM_CALLBACK_INIT:
 145             CARLA_SAFE_ASSERT_BREAK(! fStarted);
 146             fStarted = true;
 147             lo_server_thread_start(fServerThread);
 148             break;
 149
 150         case CB::NSM_CALLBACK_ERROR:
 151             break;
 152
 153         case CB::NSM_CALLBACK_ANNOUNCE:
 154             break;
 155
 156         case CB::NSM_CALLBACK_OPEN:
 157             fReadyActionOpen = true;
 158             break;
 159
 160         case CB::NSM_CALLBACK_SAVE:
 161             fReadyActionSave = true;
 162             break;
 163
 164         case CB::NSM_CALLBACK_SESSION_IS_LOADED:
 165             break;
 166
 167         case CB::NSM_CALLBACK_SHOW_OPTIONAL_GUI:
 168             CARLA_SAFE_ASSERT_BREAK(fReplyAddress != nullptr);
 169             CARLA_SAFE_ASSERT_BREAK(fServer != nullptr);
 170             {
 171                 // NOTE: lo_send_from is a macro that creates local variables
 172                 lo_send_from(fReplyAddress, fServer, LO_TT_IMMEDIATE, "/nsm/client/gui_is_shown", "");
 173             }
 174             break;
 175
 176         case CB::NSM_CALLBACK_HIDE_OPTIONAL_GUI:
 177             CARLA_SAFE_ASSERT_BREAK(fReplyAddress != nullptr);
 178             CARLA_SAFE_ASSERT_BREAK(fServer != nullptr);
 179             {
 180                 // NOTE: lo_send_from is a macro that creates local variables
 181                 lo_send_from(fReplyAddress, fServer, LO_TT_IMMEDIATE, "/nsm/client/gui_is_hidden", "");
 182             }
 183             break;
 184
 185         case CB::NSM_CALLBACK_SET_CLIENT_NAME_ID:
 186             break;
 187         }
 188     }
 189
 190     static CarlaNSM& getInstance(CarlaHostStandalone& shandle)
 191     {
 192         static CarlaNSM sInstance(shandle);
 193         return sInstance;
 194     }
 195
 196 protected:
 197     int handleError(const char* const method, const int code, const char* const message)
 198     {
 199         carla_stdout("CarlaNSM::handleError(\"%s\", %i, \"%s\")", method, code, message);
 200
 201         if (gStandalone.engineCallback != nullptr)
 202             gStandalone.engineCallback(gStandalone.engineCallbackPtr,
 203                                        CB::ENGINE_CALLBACK_NSM,
 204                                        0,
 205                                        CB::NSM_CALLBACK_ERROR,
 206                                        code,
 207                                        0, 0.0f,
 208                                        message);
 209
 210         return 0;
 211
 212         // may be unused
 213         (void)method;
 214     }
 215
 216     int handleReply(const char* const method, const char* const message, const char* const smName, const char* const features,
 217                     const lo_message msg)
 218     {
 219         CARLA_SAFE_ASSERT_RETURN(fServerThread != nullptr, 1);
 220         carla_stdout("CarlaNSM::handleReply(\"%s\", \"%s\", \"%s\", \"%s\")", method, message, smName, features);
 221
 222         if (std::strcmp(method, "/nsm/server/announce") == 0)
 223         {
 224             const lo_address msgAddress(lo_message_get_source(msg));
 225             CARLA_SAFE_ASSERT_RETURN(msgAddress != nullptr, 0);
 226
 227             char* const msgURL(lo_address_get_url(msgAddress));
 228             CARLA_SAFE_ASSERT_RETURN(msgURL != nullptr, 0);
 229
 230             if (fReplyAddress != nullptr)
 231                 lo_address_free(fReplyAddress);
 232
 233             fReplyAddress = lo_address_new_from_url(msgURL);
 234             CARLA_SAFE_ASSERT_RETURN(fReplyAddress != nullptr, 0);
 235
 236             fHasBroadcast     = std::strstr(features, ":broadcast:")      != nullptr;
 237             fHasOptionalGui   = std::strstr(features, ":optional-gui:")   != nullptr;
 238             fHasServerControl = std::strstr(features, ":server-control:") != nullptr;
 239
 240             // UI starts hidden
 241             if (fHasOptionalGui)
 242             {
 243                 // NOTE: lo_send_from is a macro that creates local variables
 244                 lo_send_from(fReplyAddress, fServer, LO_TT_IMMEDIATE, "/nsm/client/gui_is_hidden", "");
 245             }
 246
 247             carla_stdout("Carla started via '%s', message: %s", smName, message);
 248
 249             if (gStandalone.engineCallback != nullptr)
 250             {
 251                 int flags = 0;
 252
 253                 if (fHasBroadcast)
 254                     flags |= 1 << 0;
 255                 if (fHasOptionalGui)
 256                     flags |= 1 << 1;
 257                 if (fHasServerControl)
 258                     flags |= 1 << 2;
 259
 260                 gStandalone.engineCallback(gStandalone.engineCallbackPtr,
 261                                            CB::ENGINE_CALLBACK_NSM,
 262                                            0,
 263                                            CB::NSM_CALLBACK_ANNOUNCE,
 264                                            flags,
 265                                            0, 0.0f,
 266                                            smName);
 267             }
 268
 269             std::free(msgURL);
 270         }
 271         else
 272         {
 273             carla_stdout("Got unknown NSM reply method '%s'", method);
 274         }
 275
 276         return 0;
 277     }
 278
 279     int handleOpen(const char* const projectPath, const char* const displayName, const char* const clientNameId)
 280     {
 281         CARLA_SAFE_ASSERT_RETURN(fReplyAddress != nullptr, 1);
 282         CARLA_SAFE_ASSERT_RETURN(fServer != nullptr, 1);
 283         carla_stdout("CarlaNSM::handleOpen(\"%s\", \"%s\", \"%s\")", projectPath, displayName, clientNameId);
 284
 285         const CarlaHostHandle handle = (CarlaHostHandle)&gStandalone;
 286
 287         carla_set_engine_option(handle, CB::ENGINE_OPTION_CLIENT_NAME_PREFIX, 0, clientNameId);
 288
 289         if (gStandalone.engineCallback != nullptr)
 290         {
 291             fReadyActionOpen = false;
 292             gStandalone.engineCallback(gStandalone.engineCallbackPtr,
 293                                        CB::ENGINE_CALLBACK_NSM,
 294                                        0,
 295                                        CB::NSM_CALLBACK_SET_CLIENT_NAME_ID,
 296                                        0, 0, 0.0f,
 297                                        clientNameId);
 298             gStandalone.engineCallback(gStandalone.engineCallbackPtr,
 299                                        CB::ENGINE_CALLBACK_NSM,
 300                                        0,
 301                                        CB::NSM_CALLBACK_OPEN,
 302                                        0, 0, 0.0f,
 303                                        projectPath);
 304
 305             for (; ! fReadyActionOpen;)
 306                 carla_msleep(10);
 307         }
 308         else
 309         {
 310             using namespace water;
 311
 312             if (carla_is_engine_running(handle))
 313                 carla_engine_close(handle);
 314
 315             // TODO send error if engine failed to initialize
 316             carla_engine_init(handle, "JACK", clientNameId);
 317
 318             fProjectPath  = projectPath;
 319             fProjectPath += ".carxp";
 320
 321             const String jfilename = String(CharPointer_UTF8(fProjectPath));
 322
 323             if (File(jfilename).existsAsFile())
 324                 carla_load_project(handle, fProjectPath);
 325         }
 326
 327         fClientNameId = clientNameId;
 328
 329         lo_send_from(fReplyAddress, fServer, LO_TT_IMMEDIATE, "/reply", "ss", "/nsm/client/open", "OK");
 330
 331         // Broadcast ourselves
 332         if (fHasBroadcast)
 333         {
 334             const char* appName = std::getenv("CARLA_NSM_NAME");
 335
 336             if (appName == nullptr)
 337                 appName = "Carla";
 338
 339             lo_send_from(fReplyAddress, fServer, LO_TT_IMMEDIATE, "/nsm/server/broadcast", "sssss",
 340                          "/non/hello", fServerURL, appName, CARLA_VERSION_STRING, fClientNameId.buffer());
 341         }
 342
 343         return 0;
 344     }
 345
 346     int handleSave()
 347     {
 348         CARLA_SAFE_ASSERT_RETURN(fReplyAddress != nullptr, 1);
 349         CARLA_SAFE_ASSERT_RETURN(fServer != nullptr, 1);
 350         carla_stdout("CarlaNSM::handleSave()");
 351
 352         if (gStandalone.engineCallback != nullptr)
 353         {
 354             fReadyActionSave = false;
 355             gStandalone.engineCallback(gStandalone.engineCallbackPtr,
 356                                        CB::ENGINE_CALLBACK_NSM,
 357                                        0,
 358                                        CB::NSM_CALLBACK_SAVE,
 359                                        0, 0, 0.0f, nullptr);
 360
 361             for (; ! fReadyActionSave;)
 362                 carla_msleep(10);
 363         }
 364         else
 365         {
 366             CARLA_SAFE_ASSERT_RETURN(fProjectPath.isNotEmpty(), 0);
 367
 368             const CarlaHostHandle handle = (CarlaHostHandle)&gStandalone;
 369
 370             carla_save_project(handle, fProjectPath);
 371         }
 372
 373         lo_send_from(fReplyAddress, fServer, LO_TT_IMMEDIATE, "/reply", "ss", "/nsm/client/save", "OK");
 374
 375         return 0;
 376     }
 377
 378     int handleSessionIsLoaded()
 379     {
 380         CARLA_SAFE_ASSERT_RETURN(fReplyAddress != nullptr, 1);
 381         CARLA_SAFE_ASSERT_RETURN(fServer != nullptr, 1);
 382         carla_stdout("CarlaNSM::handleSessionIsLoaded()");
 383
 384         if (gStandalone.engineCallback != nullptr)
 385             gStandalone.engineCallback(gStandalone.engineCallbackPtr,
 386                                        CB::ENGINE_CALLBACK_NSM,
 387                                        0,
 388                                        CB::NSM_CALLBACK_SESSION_IS_LOADED,
 389                                        0, 0, 0.0f, nullptr);
 390
 391         return 0;
 392     }
 393
 394     int handleShowOptionalGui()
 395     {
 396         CARLA_SAFE_ASSERT_RETURN(fReplyAddress != nullptr, 1);
 397         CARLA_SAFE_ASSERT_RETURN(fServer != nullptr, 1);
 398         carla_stdout("CarlaNSM::handleShowOptionalGui()");
 399
 400         if (gStandalone.engineCallback != nullptr)
 401             gStandalone.engineCallback(gStandalone.engineCallbackPtr,
 402                                        CB::ENGINE_CALLBACK_NSM,
 403                                        0,
 404                                        CB::NSM_CALLBACK_SHOW_OPTIONAL_GUI,
 405                                        0, 0, 0.0f, nullptr);
 406
 407         return 0;
 408     }
 409
 410     int handleHideOptionalGui()
 411     {
 412         CARLA_SAFE_ASSERT_RETURN(fReplyAddress != nullptr, 1);
 413         CARLA_SAFE_ASSERT_RETURN(fServer != nullptr, 1);
 414         carla_stdout("CarlaNSM::handleHideOptionalGui()");
 415
 416         if (gStandalone.engineCallback != nullptr)
 417             gStandalone.engineCallback(gStandalone.engineCallbackPtr,
 418                                        CB::ENGINE_CALLBACK_NSM,
 419                                        0,
 420                                        CB::NSM_CALLBACK_HIDE_OPTIONAL_GUI,
 421                                        0, 0, 0.0f, nullptr);
 422
 423         return 0;
 424     }
 425
 426     int handleBroadcast(const char* const path, const char* const types, lo_arg** const argv, const int argc,
 427                         const lo_message msg)
 428     {
 429         CARLA_SAFE_ASSERT_RETURN(fReplyAddress != nullptr, 1);
 430         CARLA_SAFE_ASSERT_RETURN(fServer != nullptr, 1);
 431         CARLA_SAFE_ASSERT_RETURN(argc >= 0, 0);
 432         carla_stdout("CarlaNSM::handleBroadcast(%s, %s, %p, %i)", path, types, argv, argc);
 433
 434 #if 0
 435         if (std::strcmp(path, "/non/hello") == 0)
 436         {
 437             CARLA_SAFE_ASSERT_RETURN(argc == 4, 0);
 438             CARLA_SAFE_ASSERT_RETURN(std::strcmp(types, "ssss") == 0, 0);
 439
 440             const char* const url  = &argv[0]->s;
 441             //const char* const name     = &argv[1]->s;
 442             //const char* const version  = &argv[2]->s;
 443             //const char* const clientId = &argv[3]->s;
 444
 445             const lo_address targetAddress(lo_address_new_from_url(url));
 446             CARLA_SAFE_ASSERT_RETURN(targetAddress != nullptr, 0);
 447
 448             lo_send_from(targetAddress, fServer, LO_TT_IMMEDIATE, "/signal/hello", "ss",
 449                          fClientNameId.buffer(), fServerURL);
 450
 451             lo_address_free(targetAddress);
 452
 453             return 0;
 454         }
 455
 456         if (std::strcmp(path, "/signal/hello") == 0)
 457         {
 458             //const char* const name = &argv[0]->s;
 459             const char* const url  = &argv[1]->s;
 460
 461             const lo_address targetAddress(lo_address_new_from_url(url));
 462             CARLA_SAFE_ASSERT_RETURN(targetAddress != nullptr, 0);
 463
 464             lo_send_from(targetAddress, fServer, LO_TT_IMMEDIATE, "/signal/hello", "ss",
 465                          fClientNameId.buffer(), fServerURL);
 466
 467             lo_address_free(targetAddress);
 468
 469             return 0;
 470         }
 471
 472         if (std::strcmp(path, "/signal/list") == 0)
 473         {
 474             carla_stdout("CarlaNSM::handleBroadcast - got list");
 475             CARLA_SAFE_ASSERT_RETURN(carla_is_engine_running(), 0);
 476
 477             const char* prefix = nullptr;
 478
 479             if (argc > 0)
 480                 prefix = &argv[0]->s;
 481
 482             const lo_address msgAddress(lo_message_get_source(msg));
 483             CARLA_SAFE_ASSERT_RETURN(msgAddress != nullptr, 0);
 484
 485             for (uint32_t i = 0, pluginCount = carla_get_current_plugin_count(); i < pluginCount; ++i)
 486             {
 487                 const CarlaPluginInfo* const pluginInfo(carla_get_plugin_info(i));
 488                 CARLA_SAFE_ASSERT_CONTINUE(pluginInfo != nullptr);
 489
 490                 /*const*/ CarlaString pluginNameId(fClientNameId + "/" + CarlaString(pluginInfo->name).replace('/','_') + "/");
 491
 492                 for (uint32_t j=0, paramCount = carla_get_parameter_count(i); j < paramCount; ++j)
 493                 {
 494                     const CarlaParameterInfo* const paramInfo(carla_get_parameter_info(i, j));
 495                     CARLA_SAFE_ASSERT_CONTINUE(paramInfo != nullptr);
 496
 497                     const ParameterData* const paramData(carla_get_parameter_data(i, j));
 498                     CARLA_SAFE_ASSERT_CONTINUE(paramData != nullptr);
 499
 500                     const ParameterRanges* const paramRanges(carla_get_parameter_ranges(i, j));
 501                     CARLA_SAFE_ASSERT_CONTINUE(paramRanges != nullptr);
 502
 503                     if (paramData->type != CB::PARAMETER_INPUT /*&& paramData->type != CB::PARAMETER_OUTPUT*/)
 504                         continue;
 505                     if ((paramData->hints & CB::PARAMETER_IS_ENABLED) == 0)
 506                         continue;
 507                     if ((paramData->hints & CB::PARAMETER_IS_AUTOMATABLE) == 0)
 508                         continue;
 509                     if (paramData->hints & CB::PARAMETER_IS_READ_ONLY)
 510                         continue;
 511
 512                     const char* const dir         = paramData->type == CB::PARAMETER_INPUT ? "in" : "out";
 513                     const CarlaString paramNameId = pluginNameId + CarlaString(paramInfo->name).replace('/','_');
 514
 515                     const float defNorm = paramRanges->getNormalizedValue(paramRanges->def);
 516
 517                     if (prefix == nullptr || std::strncmp(paramNameId, prefix, std::strlen(prefix)) == 0)
 518                     {
 519                         lo_send_from(msgAddress, fServer, LO_TT_IMMEDIATE, "/reply", "sssfff",
 520                                      path, paramNameId.buffer(), dir, 0.0f, 1.0f, defNorm);
 521                     }
 522                 }
 523             }
 524
 525             lo_send_from(msgAddress, fServer, LO_TT_IMMEDIATE, "/reply", "s", path);
 526
 527             //return 0;
 528         }
 529
 530         for (int i=0; i<argc; ++i)
 531             if (types[i] == 's')
 532                 carla_stdout("%i: %s", i+1, &argv[i]->s);
 533 #endif
 534
 535         return 0;
 536
 537         // unused
 538         (void)msg;
 539     }
 540
 541 private:
 542     CarlaHostStandalone& gStandalone;
 543
 544     lo_address       fReplyAddress;
 545     lo_server        fServer;
 546     lo_server_thread fServerThread;
 547     char*            fServerURL;
 548
 549     CarlaString fClientNameId;
 550     CarlaString fProjectPath;
 551
 552     bool fHasBroadcast;
 553     bool fHasOptionalGui;
 554     bool fHasServerControl;
 555     bool fStarted;
 556
 557     volatile bool fReadyActionOpen;
 558     volatile bool fReadyActionSave;
 559
 560     #define handlePtr ((CarlaNSM*)data)
 561
 562     static void _osc_error_handler(int num, const char* msg, const char* path)
 563     {
 564         carla_stderr2("CarlaNSM::_osc_error_handler(%i, \"%s\", \"%s\")", num, msg, path);
 565     }
 566
 567     static int _error_handler(const char*, const char* types, lo_arg** argv, int argc, lo_message, void* data)
 568     {
 569         CARLA_SAFE_ASSERT_RETURN(argc == 3, 1);
 570         CARLA_SAFE_ASSERT_RETURN(std::strcmp(types, "sis") == 0, 1);
 571
 572         const char* const method  = &argv[0]->s;
 573         const int         code    =  argv[1]->i;
 574         const char* const message = &argv[2]->s;
 575
 576         return handlePtr->handleError(method, code, message);
 577     }
 578
 579     static int _reply_handler(const char*, const char* types, lo_arg** argv, int argc, lo_message msg, void* data)
 580     {
 581         CARLA_SAFE_ASSERT_RETURN(argc == 4, 1);
 582         CARLA_SAFE_ASSERT_RETURN(std::strcmp(types, "ssss") == 0, 1);
 583
 584         const char* const method   = &argv[0]->s;
 585         const char* const message  = &argv[1]->s;
 586         const char* const smName   = &argv[2]->s;
 587         const char* const features = &argv[3]->s;
 588
 589         return handlePtr->handleReply(method, message, smName, features, msg);
 590     }
 591
 592     static int _open_handler(const char*, const char* types, lo_arg** argv, int argc, lo_message, void* data)
 593     {
 594         CARLA_SAFE_ASSERT_RETURN(argc == 3, 1);
 595         CARLA_SAFE_ASSERT_RETURN(std::strcmp(types, "sss") == 0, 1);
 596
 597         const char* const projectPath  = &argv[0]->s;
 598         const char* const displayName  = &argv[1]->s;
 599         const char* const clientNameId = &argv[2]->s;
 600
 601         return handlePtr->handleOpen(projectPath, displayName, clientNameId);
 602     }
 603
 604     static int _save_handler(const char*, const char*, lo_arg**, int argc, lo_message, void* data)
 605     {
 606         CARLA_SAFE_ASSERT_RETURN(argc == 0, 1);
 607
 608         return handlePtr->handleSave();
 609     }
 610
 611     static int _loaded_handler(const char*, const char*, lo_arg**, int argc, lo_message, void* data)
 612     {
 613         CARLA_SAFE_ASSERT_RETURN(argc == 0, 1);
 614
 615         return handlePtr->handleSessionIsLoaded();
 616     }
 617
 618     static int _show_gui_handler(const char*, const char*, lo_arg**, int argc, lo_message, void* data)
 619     {
 620         CARLA_SAFE_ASSERT_RETURN(argc == 0, 1);
 621
 622         return handlePtr->handleShowOptionalGui();
 623     }
 624
 625     static int _hide_gui_handler(const char*, const char*, lo_arg**, int argc, lo_message, void* data)
 626     {
 627         CARLA_SAFE_ASSERT_RETURN(argc == 0, 1);
 628
 629         return handlePtr->handleHideOptionalGui();
 630     }
 631
 632     static int _broadcast_handler(const char* path, const char* types, lo_arg** argv, int argc, lo_message msg, void* data)
 633     {
 634         return handlePtr->handleBroadcast(path, types, argv, argc, msg);
 635     }
 636
 637     #undef handlePtr
 638
 639     CARLA_PREVENT_HEAP_ALLOCATION
 640     CARLA_DECLARE_NON_COPYABLE(CarlaNSM)
 641 };
 642
 643 #endif // CARLA_ENABLE_STANDALONE_NSM
 644
 645 // -------------------------------------------------------------------------------------------------------------------
 646
 647 bool carla_nsm_init(CarlaHostHandle handle, uint64_t pid, const char* executableName)
 648 {
 649     CARLA_SAFE_ASSERT_RETURN(handle->isStandalone, false);
 650
 651    #ifdef CARLA_ENABLE_STANDALONE_NSM
 652     return CarlaNSM::getInstance(*(CarlaHostStandalone*)handle).announce(pid, executableName);
 653    #else
 654     return false;
 655
 656     // unused
 657     (void)pid; (void)executableName;
 658    #endif
 659 }
 660
 661 void carla_nsm_ready(CarlaHostHandle handle, NsmCallbackOpcode action)
 662 {
 663     CARLA_SAFE_ASSERT_RETURN(handle->isStandalone,);
 664
 665    #ifdef CARLA_ENABLE_STANDALONE_NSM
 666     CarlaNSM::getInstance(*(CarlaHostStandalone*)handle).ready(action);
 667    #else
 668     // unused
 669     return; (void)action;
 670    #endif
 671 }
 672
 673 // -------------------------------------------------------------------------------------------------------------------