falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
465 Commits
16 Branches
451MB
Tree: 1a13fe4119
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1a13fe4119'
${ noResults }
Carla/source/libs/jackbridge/JackBridge.cpp

881 lines
28KB
Raw Blame History 

  1. /*

  2.  * JackBridge

  3.  * Copyright (C) 2013 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 Lesser General Public

  7.  * License as published by the Free Software Foundation.

  8.  *

  9.  * This program is distributed in the hope that it will be useful,

  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  12.  * GNU Lesser General Public License for more details.

  13.  *

  14.  * For a full copy of the license see the LGPL.txt file

  15.  */

  16. 

  17. #include "JackBridge.hpp"

  18. 

  19. #include <stdlib.h>

  20. #include <stdio.h>

  21. 

  22. #ifndef JACKBRIDGE_DUMMY

  23. # include <semaphore.h>

  24. # include <sys/time.h>

  25. #endif

  26. 

  27. #ifdef __WINE__

  28. struct timespec {  // FIXME!

  29.     __time_t tv_sec;  /* Seconds.  */

  30.     long int tv_nsec; /* Nanoseconds.  */

  31. };

  32. #endif

  33. 

  34. #ifndef JACKBRIDGE_DIRECT

  35. 

  36. #include "CarlaLibUtils.hpp"

  37. 

  38. // -----------------------------------------------------------------------------

  39. 

  40. typedef const char*    (*jacksym_get_version_string)();

  41. typedef jack_client_t* (*jacksym_client_open)(const char*, jack_options_t, jack_status_t*, ...);

  42. typedef const char*    (*jacksym_client_rename)(jack_client_t* client, const char* new_name);

  43. 

  44. typedef int   (*jacksym_client_close)(jack_client_t*);

  45. typedef int   (*jacksym_client_name_size)();

  46. typedef char* (*jacksym_get_client_name)(jack_client_t*);

  47. 

  48. typedef int  (*jacksym_activate)(jack_client_t*);

  49. typedef int  (*jacksym_deactivate)(jack_client_t*);

  50. typedef void (*jacksym_on_shutdown)(jack_client_t*, JackShutdownCallback, void*);

  51. typedef int  (*jacksym_set_process_callback)(jack_client_t*, JackProcessCallback, void*);

  52. typedef int  (*jacksym_set_freewheel_callback)(jack_client_t*, JackFreewheelCallback, void*);

  53. typedef int  (*jacksym_set_buffer_size_callback)(jack_client_t*, JackBufferSizeCallback, void*);

  54. typedef int  (*jacksym_set_sample_rate_callback)(jack_client_t*, JackSampleRateCallback, void*);

  55. typedef int  (*jacksym_set_client_registration_callback)(jack_client_t*, JackClientRegistrationCallback, void*);

  56. typedef int  (*jacksym_set_port_registration_callback)(jack_client_t*, JackPortRegistrationCallback, void*);

  57. typedef int  (*jacksym_set_port_connect_callback)(jack_client_t*, JackPortConnectCallback, void*);

  58. typedef int  (*jacksym_set_port_rename_callback)(jack_client_t*, JackPortRenameCallback, void*);

  59. typedef int  (*jacksym_set_latency_callback)(jack_client_t*, JackLatencyCallback, void*);

  60. 

  61. typedef jack_nframes_t (*jacksym_get_sample_rate)(jack_client_t*);

  62. typedef jack_nframes_t (*jacksym_get_buffer_size)(jack_client_t*);

  63. typedef jack_port_t*   (*jacksym_port_register)(jack_client_t*, const char*, const char*, unsigned long, unsigned long);

  64. 

  65. typedef int   (*jacksym_port_unregister)(jack_client_t*, jack_port_t*);

  66. typedef void* (*jacksym_port_get_buffer)(jack_port_t*, jack_nframes_t);

  67. 

  68. typedef const char*  (*jacksym_port_name)(const jack_port_t*);

  69. typedef const char*  (*jacksym_port_short_name)(const jack_port_t*);

  70. typedef int          (*jacksym_port_flags)(const jack_port_t*);

  71. typedef const char*  (*jacksym_port_type)(const jack_port_t*);

  72. typedef const char** (*jacksym_port_get_connections)(const jack_port_t*);

  73. 

  74. typedef int  (*jacksym_port_set_name)(jack_port_t*, const char*);

  75. typedef int  (*jacksym_connect)(jack_client_t*, const char*, const char*);

  76. typedef int  (*jacksym_disconnect)(jack_client_t*, const char*, const char*);

  77. typedef int  (*jacksym_port_name_size)();

  78. typedef void (*jacksym_port_get_latency_range)(jack_port_t*, jack_latency_callback_mode_t, jack_latency_range_t*);

  79. typedef void (*jacksym_port_set_latency_range)(jack_port_t*, jack_latency_callback_mode_t, jack_latency_range_t*);

  80. typedef int  (*jacksym_recompute_total_latencies)(jack_client_t*);

  81. 

  82. typedef const char** (*jacksym_get_ports)(jack_client_t*, const char*, const char*, unsigned long);

  83. typedef jack_port_t* (*jacksym_port_by_name)(jack_client_t*, const char*);

  84. typedef jack_port_t* (*jacksym_port_by_id)(jack_client_t*, jack_port_id_t);

  85. 

  86. typedef void (*jacksym_free)(void*);

  87. 

  88. typedef uint32_t (*jacksym_midi_get_event_count)(void*);

  89. typedef int      (*jacksym_midi_event_get)(jack_midi_event_t*, void*, uint32_t);

  90. typedef void     (*jacksym_midi_clear_buffer)(void*);

  91. typedef int      (*jacksym_midi_event_write)(void*, jack_nframes_t, const jack_midi_data_t*, size_t);

  92. typedef jack_midi_data_t* (*jacksym_midi_event_reserve)(void*, jack_nframes_t, size_t);

  93. 

  94. typedef int  (*jacksym_transport_locate)(jack_client_t*, jack_nframes_t);

  95. typedef void (*jacksym_transport_start)(jack_client_t*);

  96. typedef void (*jacksym_transport_stop)(jack_client_t*);

  97. typedef jack_transport_state_t (*jacksym_transport_query)(const jack_client_t*, jack_position_t*);

  98. 

  99. // -----------------------------------------------------------------------------

  100. 

  101. struct JackBridge {

  102.     void* lib;

  103. 

  104.     jacksym_get_version_string get_version_string_ptr;

  105.     jacksym_client_open client_open_ptr;

  106.     jacksym_client_rename client_rename_ptr;

  107.     jacksym_client_close client_close_ptr;

  108.     jacksym_client_name_size client_name_size_ptr;

  109.     jacksym_get_client_name get_client_name_ptr;

  110.     jacksym_activate activate_ptr;

  111.     jacksym_deactivate deactivate_ptr;

  112.     jacksym_on_shutdown on_shutdown_ptr;

  113.     jacksym_set_process_callback set_process_callback_ptr;

  114.     jacksym_set_freewheel_callback set_freewheel_callback_ptr;

  115.     jacksym_set_buffer_size_callback set_buffer_size_callback_ptr;

  116.     jacksym_set_sample_rate_callback set_sample_rate_callback_ptr;

  117.     jacksym_set_client_registration_callback set_client_registration_callback_ptr;

  118.     jacksym_set_port_registration_callback set_port_registration_callback_ptr;

  119.     jacksym_set_port_connect_callback set_port_connect_callback_ptr;

  120.     jacksym_set_port_rename_callback set_port_rename_callback_ptr;

  121.     jacksym_set_latency_callback set_latency_callback_ptr;

  122.     jacksym_get_sample_rate get_sample_rate_ptr;

  123.     jacksym_get_buffer_size get_buffer_size_ptr;

  124.     jacksym_port_register port_register_ptr;

  125.     jacksym_port_unregister port_unregister_ptr;

  126.     jacksym_port_get_buffer port_get_buffer_ptr;

  127.     jacksym_port_name port_name_ptr;

  128.     jacksym_port_short_name port_short_name_ptr;

  129.     jacksym_port_flags port_flags_ptr;

  130.     jacksym_port_type port_type_ptr;

  131.     jacksym_port_get_connections port_get_connections_ptr;

  132.     jacksym_port_set_name port_set_name_ptr;

  133.     jacksym_connect connect_ptr;

  134.     jacksym_disconnect disconnect_ptr;

  135.     jacksym_port_name_size port_name_size_ptr;

  136.     jacksym_port_get_latency_range port_get_latency_range_ptr;

  137.     jacksym_port_set_latency_range port_set_latency_range_ptr;

  138.     jacksym_recompute_total_latencies recompute_total_latencies_ptr;

  139.     jacksym_get_ports get_ports_ptr;

  140.     jacksym_port_by_name port_by_name_ptr;

  141.     jacksym_port_by_id port_by_id_ptr;

  142.     jacksym_free free_ptr;

  143. 

  144.     jacksym_midi_get_event_count midi_get_event_count_ptr;

  145.     jacksym_midi_event_get midi_event_get_ptr;

  146.     jacksym_midi_clear_buffer midi_clear_buffer_ptr;

  147.     jacksym_midi_event_write midi_event_write_ptr;

  148.     jacksym_midi_event_reserve midi_event_reserve_ptr;

  149. 

  150.     jacksym_transport_locate transport_locate_ptr;

  151.     jacksym_transport_start transport_start_ptr;

  152.     jacksym_transport_stop transport_stop_ptr;

  153.     jacksym_transport_query transport_query_ptr;

  154. 

  155.     JackBridge()

  156.         : lib(nullptr),

  157.           get_version_string_ptr(nullptr),

  158.           client_open_ptr(nullptr),

  159.           client_rename_ptr(nullptr),

  160.           client_close_ptr(nullptr),

  161.           client_name_size_ptr(nullptr),

  162.           get_client_name_ptr(nullptr),

  163.           activate_ptr(nullptr),

  164.           deactivate_ptr(nullptr),

  165.           on_shutdown_ptr(nullptr),

  166.           set_process_callback_ptr(nullptr),

  167.           set_freewheel_callback_ptr(nullptr),

  168.           set_buffer_size_callback_ptr(nullptr),

  169.           set_sample_rate_callback_ptr(nullptr),

  170.           set_client_registration_callback_ptr(nullptr),

  171.           set_port_registration_callback_ptr(nullptr),

  172.           set_port_connect_callback_ptr(nullptr),

  173.           set_port_rename_callback_ptr(nullptr),

  174.           set_latency_callback_ptr(nullptr),

  175.           get_sample_rate_ptr(nullptr),

  176.           get_buffer_size_ptr(nullptr),

  177.           port_register_ptr(nullptr),

  178.           port_unregister_ptr(nullptr),

  179.           port_get_buffer_ptr(nullptr),

  180.           port_name_ptr(nullptr),

  181.           port_short_name_ptr(nullptr),

  182.           port_flags_ptr(nullptr),

  183.           port_type_ptr(nullptr),

  184.           port_get_connections_ptr(nullptr),

  185.           port_set_name_ptr(nullptr),

  186.           connect_ptr(nullptr),

  187.           disconnect_ptr(nullptr),

  188.           port_name_size_ptr(nullptr),

  189.           port_get_latency_range_ptr(nullptr),

  190.           port_set_latency_range_ptr(nullptr),

  191.           recompute_total_latencies_ptr(nullptr),

  192.           get_ports_ptr(nullptr),

  193.           port_by_name_ptr(nullptr),

  194.           port_by_id_ptr(nullptr),

  195.           free_ptr(nullptr),

  196.           midi_get_event_count_ptr(nullptr),

  197.           midi_event_get_ptr(nullptr),

  198.           midi_clear_buffer_ptr(nullptr),

  199.           midi_event_write_ptr(nullptr),

  200.           midi_event_reserve_ptr(nullptr),

  201.           transport_locate_ptr(nullptr),

  202.           transport_start_ptr(nullptr),

  203.           transport_stop_ptr(nullptr),

  204.           transport_query_ptr(nullptr)

  205.     {

  206. #if defined(CARLA_OS_MAC)

  207.         const char* const filename = "libjack.dylib";

  208. #elif defined(CARLA_OS_WIN)

  209.         const char* const filename = "libjack.dll";

  210. #else

  211.         const char* const filename = "libjack.so.0";

  212. #endif

  213. 

  214.         lib = lib_open(filename);

  215. 

  216.         if (lib == nullptr)

  217.         {

  218.             fprintf(stderr, "Failed to load JACK DLL, reason:\n%s\n", lib_error(filename));

  219.             return;

  220.         }

  221.         else

  222.         {

  223.             fprintf(stdout, "%s loaded sucessfully!\n", filename);

  224.         }

  225. 

  226.         #define JOIN(a, b) a ## b

  227.         #define LIB_SYMBOL(NAME) JOIN(NAME, _ptr) = (jacksym_##NAME)lib_symbol(lib, "jack_" #NAME);

  228. 

  229.         LIB_SYMBOL(get_version_string)

  230.         LIB_SYMBOL(client_open)

  231.         LIB_SYMBOL(client_rename)

  232.         LIB_SYMBOL(client_close)

  233.         LIB_SYMBOL(client_name_size)

  234.         LIB_SYMBOL(get_client_name)

  235.         LIB_SYMBOL(activate)

  236.         LIB_SYMBOL(deactivate)

  237.         LIB_SYMBOL(on_shutdown)

  238.         LIB_SYMBOL(set_process_callback)

  239.         LIB_SYMBOL(set_freewheel_callback)

  240.         LIB_SYMBOL(set_buffer_size_callback)

  241.         LIB_SYMBOL(set_sample_rate_callback)

  242.         LIB_SYMBOL(set_client_registration_callback)

  243.         LIB_SYMBOL(set_port_registration_callback)

  244.         LIB_SYMBOL(set_port_connect_callback)

  245.         LIB_SYMBOL(set_port_rename_callback)

  246.         LIB_SYMBOL(set_latency_callback)

  247.         LIB_SYMBOL(get_sample_rate)

  248.         LIB_SYMBOL(get_buffer_size)

  249.         LIB_SYMBOL(port_register)

  250.         LIB_SYMBOL(port_unregister)

  251.         LIB_SYMBOL(port_get_buffer)

  252.         LIB_SYMBOL(port_name)

  253.         LIB_SYMBOL(port_short_name)

  254.         LIB_SYMBOL(port_flags)

  255.         LIB_SYMBOL(port_type)

  256.         LIB_SYMBOL(port_get_connections)

  257.         LIB_SYMBOL(port_set_name)

  258.         LIB_SYMBOL(connect)

  259.         LIB_SYMBOL(disconnect)

  260.         LIB_SYMBOL(port_name_size)

  261.         LIB_SYMBOL(port_get_latency_range)

  262.         LIB_SYMBOL(port_set_latency_range)

  263.         LIB_SYMBOL(recompute_total_latencies)

  264.         LIB_SYMBOL(get_ports)

  265.         LIB_SYMBOL(port_by_name)

  266.         LIB_SYMBOL(port_by_id)

  267.         LIB_SYMBOL(free)

  268. 

  269.         LIB_SYMBOL(midi_get_event_count)

  270.         LIB_SYMBOL(midi_event_get)

  271.         LIB_SYMBOL(midi_clear_buffer)

  272.         LIB_SYMBOL(midi_event_write)

  273.         LIB_SYMBOL(midi_event_reserve)

  274. 

  275.         LIB_SYMBOL(transport_locate)

  276.         LIB_SYMBOL(transport_start)

  277.         LIB_SYMBOL(transport_stop)

  278.         LIB_SYMBOL(transport_query)

  279. 

  280.         #undef JOIN

  281.         #undef LIB_SYMBOL

  282.     }

  283. 

  284.     ~JackBridge()

  285.     {

  286.         if (lib != nullptr)

  287.             lib_close(lib);

  288.     }

  289. };

  290. 

  291. static JackBridge bridge;

  292. 

  293. #endif // ! JACKBRIDGE_DIRECT

  294. 

  295. // -----------------------------------------------------------------------------

  296. 

  297. const char* jackbridge_get_version_string()

  298. {

  299. #ifdef JACKBRIDGE_DIRECT

  300.     return jack_get_version_string();

  301. #else

  302.     if (bridge.get_version_string_ptr != nullptr)

  303.         return bridge.get_version_string_ptr();

  304.     return nullptr;

  305. #endif

  306. }

  307. 

  308. jack_client_t* jackbridge_client_open(const char* client_name, jack_options_t options, jack_status_t* status, ...)

  309. {

  310. #ifdef JACKBRIDGE_DIRECT

  311.     return jack_client_open(client_name, options, status);

  312. #else

  313.     if (bridge.client_open_ptr != nullptr)

  314.         return bridge.client_open_ptr(client_name, options, status);

  315.     return nullptr;

  316. #endif

  317. }

  318. 

  319. const char* jackbridge_client_rename(jack_client_t* client, const char* new_name)

  320. {

  321. #ifdef JACKBRIDGE_DIRECT

  322.     //return jack_client_rename(client, new_name);

  323.     return nullptr;

  324.     (void)client;

  325.     (void)new_name;

  326. #else

  327.     if (bridge.client_rename_ptr != nullptr)

  328.         return bridge.client_rename_ptr(client, new_name);

  329.     return nullptr;

  330. #endif

  331. }

  332. 

  333. // -----------------------------------------------------------------------------

  334. 

  335. bool jackbridge_client_close(jack_client_t* client)

  336. {

  337. #ifdef JACKBRIDGE_DIRECT

  338.     return (jack_client_close(client) == 0);

  339. #else

  340.     if (bridge.client_close_ptr != nullptr)

  341.         return (bridge.client_close_ptr(client) == 0);

  342.     return false;

  343. #endif

  344. }

  345. 

  346. int jackbridge_client_name_size()

  347. {

  348. #ifdef JACKBRIDGE_DIRECT

  349.     return jack_client_name_size();

  350. #else

  351.     if (bridge.client_name_size_ptr != nullptr)

  352.         return bridge.client_name_size_ptr();

  353.     return 0;

  354. #endif

  355. }

  356. 

  357. char* jackbridge_get_client_name(jack_client_t* client)

  358. {

  359. #ifdef JACKBRIDGE_DIRECT

  360.     return jack_get_client_name(client);

  361. #else

  362.     if (bridge.get_client_name_ptr != nullptr)

  363.         return bridge.get_client_name_ptr(client);

  364.     return nullptr;

  365. #endif

  366. }

  367. 

  368. // -----------------------------------------------------------------------------

  369. 

  370. bool jackbridge_activate(jack_client_t* client)

  371. {

  372. #ifdef JACKBRIDGE_DIRECT

  373.     return (jack_activate(client) == 0);

  374. #else

  375.     if (bridge.activate_ptr != nullptr)

  376.         return (bridge.activate_ptr(client) == 0);

  377.     return false;

  378. #endif

  379. }

  380. 

  381. bool jackbridge_deactivate(jack_client_t* client)

  382. {

  383. #ifdef JACKBRIDGE_DIRECT

  384.     return (jack_deactivate(client) == 0);

  385. #else

  386.     if (bridge.deactivate_ptr != nullptr)

  387.         return (bridge.deactivate_ptr(client) == 0);

  388.     return false;

  389. #endif

  390. }

  391. 

  392. void jackbridge_on_shutdown(jack_client_t* client, JackShutdownCallback shutdown_callback, void* arg)

  393. {

  394. #ifdef JACKBRIDGE_DIRECT

  395.     jack_on_shutdown(client, shutdown_callback, arg);

  396. #else

  397.     if (bridge.on_shutdown_ptr != nullptr)

  398.         bridge.on_shutdown_ptr(client, shutdown_callback, arg);

  399. #endif

  400. }

  401. 

  402. bool jackbridge_set_process_callback(jack_client_t* client, JackProcessCallback process_callback, void* arg)

  403. {

  404. #ifdef JACKBRIDGE_DIRECT

  405.     return (jack_set_process_callback(client, process_callback, arg) == 0);

  406. #else

  407.     if (bridge.set_process_callback_ptr != nullptr)

  408.         return (bridge.set_process_callback_ptr(client, process_callback, arg) == 0);

  409.     return false;

  410. #endif

  411. }

  412. 

  413. bool jackbridge_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback freewheel_callback, void* arg)

  414. {

  415. #ifdef JACKBRIDGE_DIRECT

  416.     return (jack_set_freewheel_callback(client, freewheel_callback, arg) == 0);

  417. #else

  418.     if (bridge.set_freewheel_callback_ptr != nullptr)

  419.         return (bridge.set_freewheel_callback_ptr(client, freewheel_callback, arg) == 0);

  420.     return false;

  421. #endif

  422. }

  423. 

  424. bool jackbridge_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback bufsize_callback, void* arg)

  425. {

  426. #ifdef JACKBRIDGE_DIRECT

  427.     return (jack_set_buffer_size_callback(client, bufsize_callback, arg) == 0);

  428. #else

  429.     if (bridge.set_buffer_size_callback_ptr != nullptr)

  430.         return (bridge.set_buffer_size_callback_ptr(client, bufsize_callback, arg) == 0);

  431.     return false;

  432. #endif

  433. }

  434. 

  435. bool jackbridge_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback srate_callback, void* arg)

  436. {

  437. #ifdef JACKBRIDGE_DIRECT

  438.     return (jack_set_sample_rate_callback(client, srate_callback, arg) == 0);

  439. #else

  440.     if (bridge.set_sample_rate_callback_ptr != nullptr)

  441.         return (bridge.set_sample_rate_callback_ptr(client, srate_callback, arg) == 0);

  442.     return false;

  443. #endif

  444. }

  445. 

  446. bool jackbridge_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback registration_callback, void* arg)

  447. {

  448. #ifdef JACKBRIDGE_DIRECT

  449.     return (jack_set_client_registration_callback(client, registration_callback, arg) == 0);

  450. #else

  451.     if (bridge.set_client_registration_callback_ptr != nullptr)

  452.         return (bridge.set_client_registration_callback_ptr(client, registration_callback, arg) == 0);

  453.     return false;

  454. #endif

  455. }

  456. 

  457. bool jackbridge_set_port_registration_callback (jack_client_t* client, JackPortRegistrationCallback registration_callback, void *arg)

  458. {

  459. #ifdef JACKBRIDGE_DIRECT

  460.     return (jack_set_port_registration_callback(client, registration_callback, arg) == 0);

  461. #else

  462.     if (bridge.set_port_registration_callback_ptr != nullptr)

  463.         return (bridge.set_port_registration_callback_ptr(client, registration_callback, arg) == 0);

  464.     return false;

  465. #endif

  466. }

  467. 

  468. bool jackbridge_set_port_connect_callback (jack_client_t* client, JackPortConnectCallback connect_callback, void* arg)

  469. {

  470. #ifdef JACKBRIDGE_DIRECT

  471.     return (jack_set_port_connect_callback(client, connect_callback, arg) == 0);

  472. #else

  473.     if (bridge.set_port_connect_callback_ptr != nullptr)

  474.         return (bridge.set_port_connect_callback_ptr(client, connect_callback, arg) == 0);

  475.     return false;

  476. #endif

  477. }

  478. 

  479. bool jackbridge_set_port_rename_callback (jack_client_t* client, JackPortRenameCallback rename_callback, void* arg)

  480. {

  481. #ifdef JACKBRIDGE_DIRECT

  482.     return (jack_set_port_rename_callback(client, rename_callback, arg) == 0);

  483. #else

  484.     if (bridge.set_port_rename_callback_ptr != nullptr)

  485.         return (bridge.set_port_rename_callback_ptr(client, rename_callback, arg) == 0);

  486.     return false;

  487. #endif

  488. }

  489. 

  490. bool jackbridge_set_latency_callback(jack_client_t* client, JackLatencyCallback latency_callback, void* arg)

  491. {

  492. #ifdef JACKBRIDGE_DIRECT

  493.     return (jack_set_latency_callback(client, latency_callback, arg) == 0);

  494. #else

  495.     if (bridge.set_latency_callback_ptr != nullptr)

  496.         return (bridge.set_latency_callback_ptr(client, latency_callback, arg) == 0);

  497.     return false;

  498. #endif

  499. }

  500. 

  501. // -----------------------------------------------------------------------------

  502. 

  503. jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)

  504. {

  505. #ifdef JACKBRIDGE_DIRECT

  506.     return jack_get_sample_rate(client);

  507. #else

  508.     if (bridge.get_sample_rate_ptr != nullptr)

  509.         return bridge.get_sample_rate_ptr(client);

  510.     return 0;

  511. #endif

  512. }

  513. 

  514. jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)

  515. {

  516. #ifdef JACKBRIDGE_DIRECT

  517.     return jack_get_buffer_size(client);

  518. #else

  519.     if (bridge.get_buffer_size_ptr != nullptr)

  520.         return bridge.get_buffer_size_ptr(client);

  521.     return 0;

  522. #endif

  523. }

  524. 

  525. jack_port_t* jackbridge_port_register(jack_client_t* client, const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size)

  526. {

  527. #ifdef JACKBRIDGE_DIRECT

  528.     return jack_port_register(client, port_name, port_type, flags, buffer_size);

  529. #else

  530.     if (bridge.port_register_ptr != nullptr)

  531.         return bridge.port_register_ptr(client, port_name, port_type, flags, buffer_size);

  532.     return nullptr;

  533. #endif

  534. }

  535. 

  536. bool jackbridge_port_unregister(jack_client_t* client, jack_port_t* port)

  537. {

  538. #ifdef JACKBRIDGE_DIRECT

  539.     return (jack_port_unregister(client, port) == 0);

  540. #else

  541.     if (bridge.port_unregister_ptr != nullptr)

  542.         return (bridge.port_unregister_ptr(client, port) == 0);

  543.     return false;

  544. #endif

  545. }

  546. 

  547. void* jackbridge_port_get_buffer(jack_port_t* port, jack_nframes_t nframes)

  548. {

  549. #ifdef JACKBRIDGE_DIRECT

  550.     return jack_port_get_buffer(port, nframes);

  551. #else

  552.     if (bridge.port_get_buffer_ptr != nullptr)

  553.         return bridge.port_get_buffer_ptr(port, nframes);

  554.     return nullptr;

  555. #endif

  556. }

  557. 

  558. // -----------------------------------------------------------------------------

  559. 

  560. const char* jackbridge_port_name(const jack_port_t* port)

  561. {

  562. #ifdef JACKBRIDGE_DIRECT

  563.     return jack_port_name(port);

  564. #else

  565.     if (bridge.port_name_ptr != nullptr)

  566.         return bridge.port_name_ptr(port);

  567.     return nullptr;

  568. #endif

  569. }

  570. 

  571. const char* jackbridge_port_short_name(const jack_port_t* port)

  572. {

  573. #ifdef JACKBRIDGE_DIRECT

  574.     return jack_port_short_name(port);

  575. #else

  576.     if (bridge.port_short_name_ptr != nullptr)

  577.         return bridge.port_short_name_ptr(port);

  578.     return nullptr;

  579. #endif

  580. }

  581. 

  582. int jackbridge_port_flags(const jack_port_t* port)

  583. {

  584. #ifdef JACKBRIDGE_DIRECT

  585.     return jack_port_flags(port);

  586. #else

  587.     if (bridge.port_flags_ptr != nullptr)

  588.         return bridge.port_flags_ptr(port);

  589.     return 0;

  590. #endif

  591. }

  592. 

  593. const char* jackbridge_port_type(const jack_port_t* port)

  594. {

  595. #ifdef JACKBRIDGE_DIRECT

  596.     return jack_port_type(port);

  597. #else

  598.     if (bridge.port_type_ptr != nullptr)

  599.         return bridge.port_type_ptr(port);

  600.     return nullptr;

  601. #endif

  602. }

  603. 

  604. const char** jackbridge_port_get_connections(const jack_port_t* port)

  605. {

  606. #ifdef JACKBRIDGE_DIRECT

  607.     return jack_port_get_connections(port);

  608. #else

  609.     if (bridge.port_get_connections_ptr != nullptr)

  610.         return bridge.port_get_connections_ptr(port);

  611.     return nullptr;

  612. #endif

  613. }

  614. 

  615. // -----------------------------------------------------------------------------

  616. 

  617. bool jackbridge_port_set_name(jack_port_t* port, const char* port_name)

  618. {

  619. #ifdef JACKBRIDGE_DIRECT

  620.     return (jack_port_set_name(port, port_name) == 0);

  621. #else

  622.     if (bridge.port_set_name_ptr != nullptr)

  623.         return (bridge.port_set_name_ptr(port, port_name) == 0);

  624.     return false;

  625. #endif

  626. }

  627. 

  628. bool jackbridge_connect(jack_client_t* client, const char* source_port, const char* destination_port)

  629. {

  630. #ifdef JACKBRIDGE_DIRECT

  631.     return (jack_connect(client, source_port, destination_port) == 0);

  632. #else

  633.     if (bridge.connect_ptr != nullptr)

  634.         return (bridge.connect_ptr(client, source_port, destination_port) == 0);

  635.     return false;

  636. #endif

  637. }

  638. 

  639. bool jackbridge_disconnect(jack_client_t* client, const char* source_port, const char* destination_port)

  640. {

  641. #ifdef JACKBRIDGE_DIRECT

  642.     return (jack_disconnect(client, source_port, destination_port) == 0);

  643. #else

  644.     if (bridge.disconnect_ptr != nullptr)

  645.         return (bridge.disconnect_ptr(client, source_port, destination_port) == 0);

  646.     return false;

  647. #endif

  648. }

  649. 

  650. int jackbridge_port_name_size()

  651. {

  652. #ifdef JACKBRIDGE_DIRECT

  653.     return jack_port_name_size();

  654. #else

  655.     if (bridge.port_name_size_ptr != nullptr)

  656.         return bridge.port_name_size_ptr();

  657.     return 0;

  658. #endif

  659. }

  660. 

  661. void jackbridge_port_get_latency_range(jack_port_t* port, jack_latency_callback_mode_t mode, jack_latency_range_t* range)

  662. {

  663. #ifdef JACKBRIDGE_DIRECT

  664.     return jack_port_get_latency_range(port, mode, range);

  665. #else

  666.     if (bridge.port_get_latency_range_ptr != nullptr)

  667.         bridge.port_get_latency_range_ptr(port, mode, range);

  668. #endif

  669. }

  670. 

  671. void jackbridge_port_set_latency_range(jack_port_t* port, jack_latency_callback_mode_t mode, jack_latency_range_t* range)

  672. {

  673. #ifdef JACKBRIDGE_DIRECT

  674.     return jack_port_set_latency_range(port, mode, range);

  675. #else

  676.     if (bridge.port_set_latency_range_ptr != nullptr)

  677.         bridge.port_set_latency_range_ptr(port, mode, range);

  678. #endif

  679. }

  680. 

  681. bool jackbridge_recompute_total_latencies(jack_client_t* client)

  682. {

  683. #ifdef JACKBRIDGE_DIRECT

  684.     return (jack_recompute_total_latencies(client) == 0);

  685. #else

  686.     if (bridge.recompute_total_latencies_ptr != nullptr)

  687.         return (bridge.recompute_total_latencies_ptr(client) == 0);

  688.     return false;

  689. #endif

  690. }

  691. 

  692. const char** jackbridge_get_ports(jack_client_t* client, const char* port_name_pattern, const char* type_name_pattern, unsigned long flags)

  693. {

  694. #ifdef JACKBRIDGE_DIRECT

  695.     return jack_get_ports(client, port_name_pattern, type_name_pattern, flags);

  696. #else

  697.     if (bridge.get_ports_ptr != nullptr)

  698.         return bridge.get_ports_ptr(client, port_name_pattern, type_name_pattern, flags);

  699.     return nullptr;

  700. #endif

  701. }

  702. 

  703. jack_port_t* jackbridge_port_by_name(jack_client_t* client, const char* port_name)

  704. {

  705. #ifdef JACKBRIDGE_DIRECT

  706.     return jack_port_by_name(client, port_name);

  707. #else

  708.     if (bridge.port_by_name_ptr != nullptr)

  709.         return bridge.port_by_name_ptr(client, port_name);

  710.     return nullptr;

  711. #endif

  712. }

  713. 

  714. jack_port_t* jackbridge_port_by_id(jack_client_t* client, jack_port_id_t port_id)

  715. {

  716. #ifdef JACKBRIDGE_DIRECT

  717.     return jack_port_by_id(client, port_id);

  718. #else

  719.     if (bridge.port_by_id_ptr != nullptr)

  720.         return bridge.port_by_id_ptr(client, port_id);

  721.     return nullptr;

  722. #endif

  723. }

  724. 

  725. // -----------------------------------------------------------------------------

  726. 

  727. void jackbridge_free(void* ptr)

  728. {

  729. #ifdef JACKBRIDGE_DIRECT

  730.     return jack_free(ptr);

  731. #else

  732.     if (bridge.free_ptr != nullptr)

  733.         return bridge.free_ptr(ptr);

  734. 

  735.     // just in case

  736.     free(ptr);

  737. #endif

  738. }

  739. 

  740. // -----------------------------------------------------------------------------

  741. 

  742. uint32_t jackbridge_midi_get_event_count(void* port_buffer)

  743. {

  744. #ifdef JACKBRIDGE_DIRECT

  745.     return jack_midi_get_event_count(port_buffer);

  746. #else

  747.     if (bridge.midi_get_event_count_ptr != nullptr)

  748.         return bridge.midi_get_event_count_ptr(port_buffer);

  749.     return 0;

  750. #endif

  751. }

  752. 

  753. bool jackbridge_midi_event_get(jack_midi_event_t* event, void* port_buffer, uint32_t event_index)

  754. {

  755. #ifdef JACKBRIDGE_DIRECT

  756.     return (jack_midi_event_get(event, port_buffer, event_index) == 0);

  757. #else

  758.     if (bridge.midi_event_get_ptr != nullptr)

  759.         return (bridge.midi_event_get_ptr(event, port_buffer, event_index) == 0);

  760.     return false;

  761. #endif

  762. }

  763. 

  764. void jackbridge_midi_clear_buffer(void* port_buffer)

  765. {

  766. #ifdef JACKBRIDGE_DIRECT

  767.     return jack_midi_clear_buffer(port_buffer);

  768. #else

  769.     if (bridge.midi_clear_buffer_ptr != nullptr)

  770.         bridge.midi_clear_buffer_ptr(port_buffer);

  771. #endif

  772. }

  773. 

  774. bool jackbridge_midi_event_write(void* port_buffer, jack_nframes_t time, const jack_midi_data_t* data, size_t data_size)

  775. {

  776. #ifdef JACKBRIDGE_DIRECT

  777.     return (jack_midi_event_write(port_buffer, time, data, data_size) == 0);

  778. #else

  779.     if (bridge.midi_event_write_ptr != nullptr)

  780.         return (bridge.midi_event_write_ptr(port_buffer, time, data, data_size) == 0);

  781.     return false;

  782. #endif

  783. }

  784. 

  785. jack_midi_data_t* jackbridge_midi_event_reserve(void* port_buffer, jack_nframes_t time, size_t data_size)

  786. {

  787. #ifdef JACKBRIDGE_DIRECT

  788.     return jack_midi_event_reserve(port_buffer, time, data_size);

  789. #else

  790.     if (bridge.midi_event_reserve_ptr != nullptr)

  791.         return bridge.midi_event_reserve_ptr(port_buffer, time, data_size);

  792.     return nullptr;

  793. #endif

  794. }

  795. 

  796. // -----------------------------------------------------------------------------

  797. 

  798. int jackbridge_transport_locate(jack_client_t* client, jack_nframes_t frame)

  799. {

  800. #ifdef JACKBRIDGE_DIRECT

  801.     return (jack_transport_locate(client, frame) == 0);

  802. #else

  803.     if (bridge.transport_locate_ptr != nullptr)

  804.         return (bridge.transport_locate_ptr(client, frame) == 0);

  805.     return false;

  806. #endif

  807. }

  808. 

  809. void jackbridge_transport_start(jack_client_t* client)

  810. {

  811. #ifdef JACKBRIDGE_DIRECT

  812.     jack_transport_start(client);

  813. #else

  814.     if (bridge.transport_start_ptr != nullptr)

  815.         bridge.transport_start_ptr(client);

  816. #endif

  817. }

  818. 

  819. void jackbridge_transport_stop(jack_client_t* client)

  820. {

  821. #ifdef JACKBRIDGE_DIRECT

  822.     jack_transport_stop(client);

  823. #else

  824.     if (bridge.transport_stop_ptr != nullptr)

  825.         bridge.transport_stop_ptr(client);

  826. #endif

  827. }

  828. 

  829. jack_transport_state_t jackbridge_transport_query(const jack_client_t* client, jack_position_t* pos)

  830. {

  831. #ifdef JACKBRIDGE_DIRECT

  832.     return jack_transport_query(client, pos);

  833. #else

  834.     if (bridge.transport_query_ptr != nullptr)

  835.         return bridge.transport_query_ptr(client, pos);

  836.     return JackTransportStopped;

  837. #endif

  838. }

  839. 

  840. // -----------------------------------------------------------------------------

  841. 

  842. #ifdef JACKBRIDGE_DUMMY

  843. bool jackbridge_sem_post(void* sem)

  844. {

  845.     return false;

  846. }

  847. 

  848. bool jackbridge_sem_timedwait(void* sem, int secs)

  849. {

  850.     return false;

  851. }

  852. #else

  853. bool jackbridge_sem_post(void* sem)

  854. {

  855.     return (sem_post((sem_t*)sem) == 0);

  856. }

  857. 

  858. bool jackbridge_sem_timedwait(void* sem, int secs)

  859. {

  860. # ifdef CARLA_OS_MAC

  861.         alarm(secs);

  862.         return (sem_wait((sem_t*)sem) == 0);

  863. # else

  864.         timespec timeout;

  865. 

  866. #  ifdef CARLA_OS_WIN

  867.         timeval now;

  868.         gettimeofday(&now, nullptr);

  869.         timeout.tv_sec  = now.tv_sec;

  870.         timeout.tv_nsec = now.tv_usec * 1000;

  871. #  else

  872.         clock_gettime(CLOCK_REALTIME, &timeout);

  873. #  endif

  874. 

  875.         timeout.tv_sec += secs;

  876. 

  877.         return (sem_timedwait((sem_t*)sem, &timeout) == 0);

  878. # endif

  879. }

  880. #endif