source/bridges-plugin/CarlaBridgePlugin.cpp

   1 // SPDX-FileCopyrightText: 2011-2024 Filipe Coelho <falktx@falktx.com>
   2 // SPDX-License-Identifier: GPL-2.0-or-later
   3
   4 #ifndef BUILD_BRIDGE
   5 # error This file should not be compiled if not building bridge
   6 #endif
   7
   8 #include "CarlaEngine.hpp"
   9 #include "CarlaHost.h"
  10 #include "CarlaUtils.h"
  11
  12 #include "CarlaBackendUtils.hpp"
  13 #include "CarlaJuceUtils.hpp"
  14 #include "CarlaMainLoop.hpp"
  15 #include "CarlaTimeUtils.hpp"
  16
  17 #include "CarlaMIDI.h"
  18
  19 #ifdef CARLA_OS_MAC
  20 # include "CarlaMacUtils.hpp"
  21 #endif
  22
  23 #ifdef CARLA_OS_UNIX
  24 # include <signal.h>
  25 #endif
  26
  27 #ifdef CARLA_OS_LINUX
  28 # include <sched.h>
  29 # define SCHED_RESET_ON_FORK 0x40000000
  30 #endif
  31
  32 #ifdef CARLA_OS_WIN
  33 # include <pthread.h>
  34 # include <objbase.h>
  35 #endif
  36
  37 #ifdef HAVE_X11
  38 # include <X11/Xlib.h>
  39 #endif
  40
  41 #include "water/files/File.h"
  42 #include "water/misc/Time.h"
  43
  44 // must be last
  45 #include "jackbridge/JackBridge.hpp"
  46
  47 using CARLA_BACKEND_NAMESPACE::CarlaEngine;
  48 using CARLA_BACKEND_NAMESPACE::EngineCallbackOpcode;
  49 using CARLA_BACKEND_NAMESPACE::EngineCallbackOpcode2Str;
  50 using CARLA_BACKEND_NAMESPACE::runMainLoopOnce;
  51
  52 using water::CharPointer_UTF8;
  53 using water::File;
  54 using water::String;
  55
  56 // -------------------------------------------------------------------------
  57
  58 static bool gIsInitiated = false;
  59 static volatile bool gCloseBridge = false;
  60 static volatile bool gCloseSignal = false;
  61 static volatile bool gSaveNow  = false;
  62
  63 #if defined(CARLA_OS_UNIX)
  64 static void closeSignalHandler(int) noexcept
  65 {
  66     gCloseSignal = true;
  67 }
  68 static void saveSignalHandler(int) noexcept
  69 {
  70     gSaveNow = true;
  71 }
  72 #elif defined(CARLA_OS_WIN)
  73 static LONG WINAPI winExceptionFilter(_EXCEPTION_POINTERS*)
  74 {
  75     return EXCEPTION_EXECUTE_HANDLER;
  76 }
  77
  78 static BOOL WINAPI winSignalHandler(DWORD dwCtrlType) noexcept
  79 {
  80     if (dwCtrlType == CTRL_C_EVENT)
  81     {
  82         gCloseSignal = true;
  83         return TRUE;
  84     }
  85     return FALSE;
  86 }
  87 #endif
  88
  89 static void initSignalHandler()
  90 {
  91 #if defined(CARLA_OS_UNIX)
  92     struct sigaction sig;
  93     carla_zeroStruct(sig);
  94
  95     sig.sa_handler = closeSignalHandler;
  96     sig.sa_flags   = SA_RESTART;
  97     sigemptyset(&sig.sa_mask);
  98     sigaction(SIGTERM, &sig, nullptr);
  99     sigaction(SIGINT, &sig, nullptr);
 100
 101     sig.sa_handler = saveSignalHandler;
 102     sig.sa_flags   = SA_RESTART;
 103     sigemptyset(&sig.sa_mask);
 104     sigaction(SIGUSR1, &sig, nullptr);
 105 #elif defined(CARLA_OS_WIN)
 106     SetConsoleCtrlHandler(winSignalHandler, TRUE);
 107     SetErrorMode(SEM_NOGPFAULTERRORBOX);
 108     SetUnhandledExceptionFilter(winExceptionFilter);
 109 #endif
 110 }
 111
 112 // -------------------------------------------------------------------------
 113
 114 static String gProjectFilename;
 115 static CarlaHostHandle gHostHandle;
 116
 117 static void gIdle()
 118 {
 119     carla_engine_idle(gHostHandle);
 120
 121     if (gSaveNow)
 122     {
 123         gSaveNow = false;
 124
 125         if (gProjectFilename.isNotEmpty())
 126         {
 127             if (! carla_save_plugin_state(gHostHandle, 0, gProjectFilename.toRawUTF8()))
 128                 carla_stderr("Plugin preset save failed, error was:\n%s", carla_get_last_error(gHostHandle));
 129         }
 130     }
 131 }
 132
 133 // -------------------------------------------------------------------------
 134
 135 class CarlaBridgePlugin
 136 {
 137 public:
 138     CarlaBridgePlugin(const bool useBridge, const char* const clientName, const char* const audioPoolBaseName,
 139                       const char* const rtClientBaseName, const char* const nonRtClientBaseName, const char* const nonRtServerBaseName)
 140         : fEngine(nullptr),
 141           fUsingBridge(false),
 142           fUsingExec(false)
 143     {
 144         CARLA_ASSERT(clientName != nullptr && clientName[0] != '\0');
 145         carla_debug("CarlaBridgePlugin::CarlaBridgePlugin(%s, \"%s\", %s, %s, %s, %s)",
 146                     bool2str(useBridge), clientName, audioPoolBaseName, rtClientBaseName, nonRtClientBaseName, nonRtServerBaseName);
 147
 148         carla_set_engine_callback(gHostHandle, callback, this);
 149
 150         if (useBridge)
 151         {
 152             carla_engine_init_bridge(gHostHandle,
 153                                      audioPoolBaseName,
 154                                      rtClientBaseName,
 155                                      nonRtClientBaseName,
 156                                      nonRtServerBaseName,
 157                                      clientName);
 158         }
 159         else if (std::getenv("CARLA_BRIDGE_DUMMY") != nullptr)
 160         {
 161             carla_engine_init(gHostHandle, "Dummy", clientName);
 162         }
 163         else
 164         {
 165             carla_engine_init(gHostHandle, "JACK", clientName);
 166         }
 167
 168         fEngine = carla_get_engine_from_handle(gHostHandle);
 169     }
 170
 171     ~CarlaBridgePlugin()
 172     {
 173         carla_debug("CarlaBridgePlugin::~CarlaBridgePlugin()");
 174
 175         if (fEngine != nullptr && ! fUsingExec)
 176             carla_engine_close(gHostHandle);
 177     }
 178
 179     bool isOk() const noexcept
 180     {
 181         return (fEngine != nullptr);
 182     }
 183
 184     // ---------------------------------------------------------------------
 185
 186     void exec(const bool useBridge)
 187     {
 188         fUsingBridge = useBridge;
 189         fUsingExec   = true;
 190
 191         const bool testing = std::getenv("CARLA_BRIDGE_TESTING") != nullptr;
 192
 193         if (! useBridge && ! testing)
 194         {
 195             const CarlaPluginInfo* const pInfo = carla_get_plugin_info(gHostHandle, 0);
 196             CARLA_SAFE_ASSERT_RETURN(pInfo != nullptr,);
 197
 198             gProjectFilename  = CharPointer_UTF8(pInfo->name);
 199             gProjectFilename += ".carxs";
 200
 201             if (! File::isAbsolutePath(gProjectFilename))
 202                 gProjectFilename = File::getCurrentWorkingDirectory().getChildFile(gProjectFilename).getFullPathName();
 203
 204             if (File(gProjectFilename.toRawUTF8()).existsAsFile())
 205             {
 206                 if (carla_load_plugin_state(gHostHandle, 0, gProjectFilename.toRawUTF8()))
 207                     carla_stdout("Plugin state loaded successfully");
 208                 else
 209                     carla_stderr("Plugin state load failed, error was:\n%s", carla_get_last_error(gHostHandle));
 210             }
 211             else
 212             {
 213                 carla_stdout("Previous plugin state in '%s' is non-existent, will start from default state",
 214                              gProjectFilename.toRawUTF8());
 215             }
 216         }
 217
 218         gIsInitiated = true;
 219
 220         int64_t timeToEnd = 0;
 221
 222         if (testing)
 223         {
 224             timeToEnd = water::Time::currentTimeMillis() + 5 * 1000;
 225             fEngine->transportPlay();
 226         }
 227
 228         for (; runMainLoopOnce() && ! gCloseBridge;)
 229         {
 230             gIdle();
 231            #if defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN)
 232             // MacOS and Win32 have event-loops to run, so minimize sleep time
 233             carla_msleep(1);
 234            #else
 235             carla_msleep(5);
 236            #endif
 237             if (testing && timeToEnd - water::Time::currentTimeMillis() < 0)
 238                 break;
 239             if (gCloseSignal && ! fUsingBridge)
 240                 break;
 241         }
 242
 243         carla_engine_close(gHostHandle);
 244     }
 245
 246     // ---------------------------------------------------------------------
 247
 248 protected:
 249     void handleCallback(const EngineCallbackOpcode action,
 250                         const int value1,
 251                         const int, const int, const float, const char* const)
 252     {
 253         CARLA_BACKEND_USE_NAMESPACE;
 254
 255         switch (action)
 256         {
 257         case ENGINE_CALLBACK_ENGINE_STOPPED:
 258         case ENGINE_CALLBACK_PLUGIN_REMOVED:
 259         case ENGINE_CALLBACK_QUIT:
 260             gCloseBridge = gCloseSignal = true;
 261             break;
 262
 263         case ENGINE_CALLBACK_UI_STATE_CHANGED:
 264             if (gIsInitiated && value1 != 1 && ! fUsingBridge)
 265                 gCloseBridge = gCloseSignal = true;
 266             break;
 267
 268         default:
 269             break;
 270         }
 271     }
 272
 273 private:
 274     CarlaEngine* fEngine;
 275
 276     bool fUsingBridge;
 277     bool fUsingExec;
 278
 279     static void callback(void* ptr, EngineCallbackOpcode action, unsigned int pluginId,
 280                          int value1, int value2, int value3,
 281                          float valuef, const char* valueStr)
 282     {
 283         carla_debug("CarlaBridgePlugin::callback(%p, %i:%s, %i, %i, %i, %i, %f, \"%s\")",
 284                     ptr, action, EngineCallbackOpcode2Str(action),
 285                     pluginId, value1, value2, value3, static_cast<double>(valuef), valueStr);
 286
 287         // ptr must not be null
 288         CARLA_SAFE_ASSERT_RETURN(ptr != nullptr,);
 289
 290 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
 291         // pluginId must be 0 (first), except for patchbay things
 292         if (action < CARLA_BACKEND_NAMESPACE::ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED ||
 293             action > CARLA_BACKEND_NAMESPACE::ENGINE_CALLBACK_PATCHBAY_CONNECTION_REMOVED)
 294 #endif
 295         {
 296             CARLA_SAFE_ASSERT_UINT_RETURN(pluginId == 0, pluginId,);
 297         }
 298
 299         return ((CarlaBridgePlugin*)ptr)->handleCallback(action, value1, value2, value3, valuef, valueStr);
 300     }
 301
 302     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaBridgePlugin)
 303 };
 304
 305 // -------------------------------------------------------------------------
 306
 307 int main(int argc, char* argv[])
 308 {
 309     // ---------------------------------------------------------------------
 310     // Check argument count
 311
 312     if (argc != 4 && argc != 5)
 313     {
 314         carla_stdout("usage: %s <type> <filename> <label> [uniqueId]", argv[0]);
 315         return 1;
 316     }
 317
 318 #if defined(CARLA_OS_WIN) && defined(BUILDING_CARLA_FOR_WINE)
 319     // ---------------------------------------------------------------------
 320     // Test if bridge is working
 321
 322     if (! jackbridge_is_ok())
 323     {
 324         carla_stderr("A JACK or Wine library is missing, cannot continue");
 325         return 1;
 326     }
 327 #endif
 328
 329     // ---------------------------------------------------------------------
 330     // Get args
 331
 332     const char* const stype    = argv[1];
 333     const char*       filename = argv[2];
 334     const char*       label    = argv[3];
 335     const int64_t     uniqueId = (argc == 5) ? static_cast<int64_t>(std::atoll(argv[4])) : 0;
 336
 337     if (filename[0] == '\0' || std::strcmp(filename, "(none)") == 0)
 338         filename = nullptr;
 339
 340     if (label[0] == '\0' || std::strcmp(label, "(none)") == 0)
 341         label = nullptr;
 342
 343     // ---------------------------------------------------------------------
 344     // Check binary type
 345
 346     CARLA_BACKEND_NAMESPACE::BinaryType btype = CARLA_BACKEND_NAMESPACE::BINARY_NATIVE;
 347
 348     if (const char* const binaryTypeStr = std::getenv("CARLA_BRIDGE_PLUGIN_BINARY_TYPE"))
 349         btype = CARLA_BACKEND_NAMESPACE::getBinaryTypeFromString(binaryTypeStr);
 350
 351     if (btype == CARLA_BACKEND_NAMESPACE::BINARY_NONE)
 352     {
 353         carla_stderr("Invalid binary type '%i'", btype);
 354         return 1;
 355     }
 356
 357     // ---------------------------------------------------------------------
 358     // Check plugin type
 359
 360     CARLA_BACKEND_NAMESPACE::PluginType itype = CARLA_BACKEND_NAMESPACE::getPluginTypeFromString(stype);
 361
 362     if (itype == CARLA_BACKEND_NAMESPACE::PLUGIN_NONE)
 363     {
 364         carla_stderr("Invalid plugin type '%s'", stype);
 365         return 1;
 366     }
 367
 368     // ---------------------------------------------------------------------
 369     // Set file
 370
 371     const File file(filename != nullptr ? filename : "");
 372
 373     // ---------------------------------------------------------------------
 374     // Set name
 375
 376     const char* name(std::getenv("CARLA_CLIENT_NAME"));
 377
 378     if (name != nullptr && (name[0] == '\0' || std::strcmp(name, "(none)") == 0))
 379         name = nullptr;
 380
 381     // ---------------------------------------------------------------------
 382     // Setup options
 383
 384     const char* const shmIds(std::getenv("ENGINE_BRIDGE_SHM_IDS"));
 385
 386     const bool useBridge = (shmIds != nullptr);
 387
 388     // ---------------------------------------------------------------------
 389     // Setup bridge ids
 390
 391     char audioPoolBaseName[6+1];
 392     char rtClientBaseName[6+1];
 393     char nonRtClientBaseName[6+1];
 394     char nonRtServerBaseName[6+1];
 395
 396     if (useBridge)
 397     {
 398         CARLA_SAFE_ASSERT_RETURN(std::strlen(shmIds) == 6*4, 1);
 399         std::strncpy(audioPoolBaseName,   shmIds+6*0, 6);
 400         std::strncpy(rtClientBaseName,    shmIds+6*1, 6);
 401         std::strncpy(nonRtClientBaseName, shmIds+6*2, 6);
 402         std::strncpy(nonRtServerBaseName, shmIds+6*3, 6);
 403         audioPoolBaseName[6]   = '\0';
 404         rtClientBaseName[6]    = '\0';
 405         nonRtClientBaseName[6] = '\0';
 406         nonRtServerBaseName[6] = '\0';
 407         jackbridge_parent_deathsig(false);
 408     }
 409     else
 410     {
 411         audioPoolBaseName[0]   = '\0';
 412         rtClientBaseName[0]    = '\0';
 413         nonRtClientBaseName[0] = '\0';
 414         nonRtServerBaseName[0] = '\0';
 415         jackbridge_init();
 416     }
 417
 418     // ---------------------------------------------------------------------
 419     // Set client name
 420
 421     CarlaString clientName;
 422
 423     if (name != nullptr)
 424     {
 425         clientName = name;
 426     }
 427     else if (itype == CARLA_BACKEND_NAMESPACE::PLUGIN_LV2)
 428     {
 429         // LV2 requires URI
 430         CARLA_SAFE_ASSERT_RETURN(label != nullptr && label[0] != '\0', 1);
 431
 432         // LV2 URI is not usable as client name, create a usable name from URI
 433         CarlaString label2(label);
 434
 435         // truncate until last valid char
 436         for (std::size_t i=label2.length()-1; i != 0; --i)
 437         {
 438             if (! std::isalnum(label2[i]))
 439                 continue;
 440
 441             label2.truncate(i+1);
 442             break;
 443         }
 444
 445         // get last used separator
 446         bool found;
 447         std::size_t septmp, sep = 0;
 448
 449         septmp = label2.rfind('#', &found)+1;
 450         if (found && septmp > sep)
 451             sep = septmp;
 452
 453         septmp = label2.rfind('/', &found)+1;
 454         if (found && septmp > sep)
 455             sep = septmp;
 456
 457         septmp = label2.rfind('=', &found)+1;
 458         if (found && septmp > sep)
 459             sep = septmp;
 460
 461         septmp = label2.rfind(':', &found)+1;
 462         if (found && septmp > sep)
 463             sep = septmp;
 464
 465         // make name starting from the separator and first valid char
 466         const char* name2 = label2.buffer() + sep;
 467         for (; *name2 != '\0' && ! std::isalnum(*name2); ++name2) {}
 468
 469         if (*name2 != '\0')
 470             clientName = name2;
 471     }
 472     else if (label != nullptr)
 473     {
 474         clientName = label;
 475     }
 476     else
 477     {
 478         clientName = file.getFileNameWithoutExtension().toRawUTF8();
 479     }
 480
 481     // if we still have no client name by now, use a dummy one
 482     if (clientName.isEmpty())
 483         clientName = "carla-plugin";
 484
 485     // just to be safe
 486     clientName.toBasic();
 487
 488     // ---------------------------------------------------------------------
 489     // Set extraStuff
 490
 491     const void* extraStuff = nullptr;
 492
 493     if (itype == CARLA_BACKEND_NAMESPACE::PLUGIN_SF2)
 494     {
 495         if (label == nullptr)
 496             label = clientName;
 497
 498         if (std::strstr(label, " (16 outs)") != nullptr)
 499             extraStuff = "true";
 500     }
 501
 502     // ---------------------------------------------------------------------
 503     // Initialize OS features
 504
 505     const bool dummy = std::getenv("CARLA_BRIDGE_DUMMY") != nullptr;
 506     const bool testing = std::getenv("CARLA_BRIDGE_TESTING") != nullptr;
 507
 508 #ifdef CARLA_OS_MAC
 509     CARLA_BACKEND_NAMESPACE::initStandaloneApplication();
 510 #endif
 511
 512 #ifdef CARLA_OS_WIN
 513     OleInitialize(nullptr);
 514     CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
 515 # ifndef __WINPTHREADS_VERSION
 516     // (non-portable) initialization of statically linked pthread library
 517     pthread_win32_process_attach_np();
 518     pthread_win32_thread_attach_np();
 519 # endif
 520 #endif
 521
 522 #ifdef HAVE_X11
 523     if (std::getenv("DISPLAY") != nullptr)
 524         XInitThreads();
 525 #endif
 526
 527     // ---------------------------------------------------------------------
 528     // Set ourselves with high priority
 529
 530     if (!dummy && !testing)
 531     {
 532 #ifdef CARLA_OS_LINUX
 533         // reset scheduler to normal mode
 534         struct sched_param sparam;
 535         carla_zeroStruct(sparam);
 536         sched_setscheduler(0, SCHED_OTHER|SCHED_RESET_ON_FORK, &sparam);
 537
 538         // try niceness first, if it fails, try SCHED_RR
 539         if (nice(-5) < 0)
 540         {
 541             sparam.sched_priority = (sched_get_priority_max(SCHED_RR) + sched_get_priority_min(SCHED_RR*7)) / 8;
 542
 543             if (sparam.sched_priority > 0)
 544             {
 545                 if (sched_setscheduler(0, SCHED_RR|SCHED_RESET_ON_FORK, &sparam) < 0)
 546                 {
 547                     CarlaString error(std::strerror(errno));
 548                     carla_stderr("Failed to set high priority, error %i: %s", errno, error.buffer());
 549                 }
 550             }
 551         }
 552 #endif
 553
 554 #ifdef CARLA_OS_WIN
 555         if (! SetPriorityClass(GetCurrentProcess(), ABOVE_NORMAL_PRIORITY_CLASS))
 556             carla_stderr("Failed to set high priority.");
 557 #endif
 558     }
 559
 560     // ---------------------------------------------------------------------
 561     // Listen for ctrl+c or sigint/sigterm events
 562
 563     initSignalHandler();
 564
 565     // ---------------------------------------------------------------------
 566     // Init plugin bridge
 567
 568     int ret;
 569
 570     {
 571         gHostHandle = carla_standalone_host_init();
 572
 573         CarlaBridgePlugin bridge(useBridge, clientName,
 574                                  audioPoolBaseName, rtClientBaseName, nonRtClientBaseName, nonRtServerBaseName);
 575
 576         if (! bridge.isOk())
 577         {
 578             carla_stderr("Failed to init engine, error was:\n%s", carla_get_last_error(gHostHandle));
 579             return 1;
 580         }
 581
 582         if (! useBridge && ! testing)
 583         {
 584 #ifdef HAVE_X11
 585             if (std::getenv("DISPLAY") != nullptr)
 586 #endif
 587                 carla_set_engine_option(gHostHandle,
 588                                         CARLA_BACKEND_NAMESPACE::ENGINE_OPTION_FRONTEND_UI_SCALE,
 589                                         static_cast<int>(carla_get_desktop_scale_factor()*1000+0.5),
 590                                         nullptr);
 591         }
 592
 593         // -----------------------------------------------------------------
 594         // Init plugin
 595
 596         if (carla_add_plugin(gHostHandle,
 597                              btype, itype,
 598                              file.getFullPathName().toRawUTF8(), name, label, uniqueId, extraStuff,
 599                              CARLA_BACKEND_NAMESPACE::PLUGIN_OPTIONS_NULL))
 600         {
 601             ret = 0;
 602
 603             if (! useBridge)
 604             {
 605                 carla_set_active(gHostHandle, 0, true);
 606                 carla_set_engine_option(gHostHandle, CARLA_BACKEND_NAMESPACE::ENGINE_OPTION_PLUGINS_ARE_STANDALONE, 1, nullptr);
 607
 608                 if (const CarlaPluginInfo* const pluginInfo = carla_get_plugin_info(gHostHandle, 0))
 609                 {
 610                     if (itype == CARLA_BACKEND_NAMESPACE::PLUGIN_INTERNAL && (std::strcmp(label, "audiofile") == 0 || std::strcmp(label, "midifile") == 0))
 611                     {
 612                         if (file.exists())
 613                             carla_set_custom_data(gHostHandle, 0,
 614                                                   CARLA_BACKEND_NAMESPACE::CUSTOM_DATA_TYPE_STRING,
 615                                                   "file", file.getFullPathName().toRawUTF8());
 616                     }
 617                     else if (pluginInfo->hints & CARLA_BACKEND_NAMESPACE::PLUGIN_HAS_CUSTOM_UI)
 618                     {
 619 #ifdef HAVE_X11
 620                         if (std::getenv("DISPLAY") != nullptr)
 621 #endif
 622                             if (! testing)
 623                                 carla_show_custom_ui(gHostHandle, 0, true);
 624                     }
 625
 626                     // on standalone usage, enable everything that makes sense
 627                     const uint optsAvailable = pluginInfo->optionsAvailable;
 628                     if (optsAvailable & CARLA_BACKEND_NAMESPACE::PLUGIN_OPTION_FIXED_BUFFERS)
 629                         carla_set_option(gHostHandle, 0, CARLA_BACKEND_NAMESPACE::PLUGIN_OPTION_FIXED_BUFFERS, true);
 630                 }
 631             }
 632
 633             bridge.exec(useBridge);
 634         }
 635         else
 636         {
 637             ret = 1;
 638
 639             const char* const lastError(carla_get_last_error(gHostHandle));
 640             carla_stderr("Plugin failed to load, error was:\n%s", lastError);
 641
 642             if (useBridge)
 643             {
 644                 // do a single idle so that we can send error message to server
 645                 gIdle();
 646
 647 #ifdef CARLA_OS_UNIX
 648                 // kill ourselves now if we can't load plugin in bridge mode
 649                 ::kill(::getpid(), SIGKILL);
 650 #endif
 651             }
 652         }
 653     }
 654
 655 #ifdef CARLA_OS_WIN
 656 #ifndef __WINPTHREADS_VERSION
 657     pthread_win32_thread_detach_np();
 658     pthread_win32_process_detach_np();
 659 #endif
 660     CoUninitialize();
 661     OleUninitialize();
 662 #endif
 663
 664     return ret;
 665 }