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.
401 Commits
16 Branches
451MB
Tree: 6fe677b4f2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6fe677b4f2'
${ noResults }
Carla/source/libs/jackbridge/JackBridge.cpp

605 lines
20KB
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. #include "CarlaLibUtils.hpp"

  19. 

  20. #ifndef JACKBRIDGE_DUMMY

  21. # include <time.h>

  22. # include <semaphore.h>

  23. #endif

  24. 

  25. // -----------------------------------------------------------------------------

  26. 

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

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

  29. 

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

  31. typedef int   (*jacksym_client_name_size)();

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

  33. 

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

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

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

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

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

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

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

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

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

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

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

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

  46. 

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

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

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

  50. 

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

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

  53. 

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

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

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

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

  58. 

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

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

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

  62. typedef int  (*jacksym_port_name_size)();

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

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

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

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

  67. 

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

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

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

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

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

  73. 

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

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

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

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

  78. 

  79. // -----------------------------------------------------------------------------

  80. 

  81. struct JackBridge

  82. {

  83.     void* lib;

  84. 

  85.     jacksym_get_version_string get_version_string_ptr;

  86.     jacksym_client_open client_open_ptr;

  87.     jacksym_client_close client_close_ptr;

  88.     jacksym_client_name_size client_name_size_ptr;

  89.     jacksym_get_client_name get_client_name_ptr;

  90.     jacksym_activate activate_ptr;

  91.     jacksym_deactivate deactivate_ptr;

  92.     jacksym_on_shutdown on_shutdown_ptr;

  93.     jacksym_set_process_callback set_process_callback_ptr;

  94.     jacksym_set_freewheel_callback set_freewheel_callback_ptr;

  95.     jacksym_set_buffer_size_callback set_buffer_size_callback_ptr;

  96.     jacksym_set_sample_rate_callback set_sample_rate_callback_ptr;

  97.     jacksym_set_client_registration_callback set_client_registration_callback_ptr;

  98.     jacksym_set_port_registration_callback set_port_registration_callback_ptr;

  99.     jacksym_set_port_connect_callback set_port_connect_callback_ptr;

  100.     jacksym_set_port_rename_callback set_port_rename_callback_ptr;

  101.     jacksym_set_latency_callback set_latency_callback_ptr;

  102.     jacksym_get_sample_rate get_sample_rate_ptr;

  103.     jacksym_get_buffer_size get_buffer_size_ptr;

  104.     jacksym_port_register port_register_ptr;

  105.     jacksym_port_unregister port_unregister_ptr;

  106.     jacksym_port_get_buffer port_get_buffer_ptr;

  107.     jacksym_port_name port_name_ptr;

  108.     jacksym_port_short_name port_short_name_ptr;

  109.     jacksym_port_flags port_flags_ptr;

  110.     jacksym_port_type port_type_ptr;

  111.     jacksym_port_set_name port_set_name_ptr;

  112.     jacksym_connect connect_ptr;

  113.     jacksym_disconnect disconnect_ptr;

  114.     jacksym_port_name_size port_name_size_ptr;

  115.     jacksym_port_get_latency_range port_get_latency_range_ptr;

  116.     jacksym_port_set_latency_range port_set_latency_range_ptr;

  117.     jacksym_recompute_total_latencies recompute_total_latencies_ptr;

  118.     jacksym_free free_ptr;

  119. 

  120.     jacksym_midi_get_event_count midi_get_event_count_ptr;

  121.     jacksym_midi_event_get midi_event_get_ptr;

  122.     jacksym_midi_clear_buffer midi_clear_buffer_ptr;

  123.     jacksym_midi_event_write midi_event_write_ptr;

  124.     jacksym_midi_event_reserve midi_event_reserve_ptr;

  125. 

  126.     jacksym_transport_locate transport_locate_ptr;

  127.     jacksym_transport_start transport_start_ptr;

  128.     jacksym_transport_stop transport_stop_ptr;

  129.     jacksym_transport_query transport_query_ptr;

  130. 

  131.     JackBridge()

  132.         : lib(nullptr),

  133.           get_version_string_ptr(nullptr),

  134.           client_open_ptr(nullptr),

  135.           client_close_ptr(nullptr),

  136.           client_name_size_ptr(nullptr),

  137.           get_client_name_ptr(nullptr),

  138.           activate_ptr(nullptr),

  139.           deactivate_ptr(nullptr),

  140.           on_shutdown_ptr(nullptr),

  141.           set_process_callback_ptr(nullptr),

  142.           set_freewheel_callback_ptr(nullptr),

  143.           set_buffer_size_callback_ptr(nullptr),

  144.           set_sample_rate_callback_ptr(nullptr),

  145.           set_client_registration_callback_ptr(nullptr),

  146.           set_port_registration_callback_ptr(nullptr),

  147.           set_port_connect_callback_ptr(nullptr),

  148.           set_port_rename_callback_ptr(nullptr),

  149.           set_latency_callback_ptr(nullptr),

  150.           get_sample_rate_ptr(nullptr),

  151.           get_buffer_size_ptr(nullptr),

  152.           port_register_ptr(nullptr),

  153.           port_unregister_ptr(nullptr),

  154.           port_get_buffer_ptr(nullptr),

  155.           port_name_ptr(nullptr),

  156.           port_short_name_ptr(nullptr),

  157.           port_flags_ptr(nullptr),

  158.           port_type_ptr(nullptr),

  159.           port_set_name_ptr(nullptr),

  160.           connect_ptr(nullptr),

  161.           disconnect_ptr(nullptr),

  162.           port_name_size_ptr(nullptr),

  163.           port_get_latency_range_ptr(nullptr),

  164.           port_set_latency_range_ptr(nullptr),

  165.           recompute_total_latencies_ptr(nullptr),

  166.           free_ptr(nullptr),

  167.           midi_get_event_count_ptr(nullptr),

  168.           midi_event_get_ptr(nullptr),

  169.           midi_clear_buffer_ptr(nullptr),

  170.           midi_event_write_ptr(nullptr),

  171.           midi_event_reserve_ptr(nullptr),

  172.           transport_locate_ptr(nullptr),

  173.           transport_start_ptr(nullptr),

  174.           transport_stop_ptr(nullptr),

  175.           transport_query_ptr(nullptr)

  176.     {

  177. #if defined(CARLA_OS_MAC)

  178.         lib = lib_open("libjack.dylib");

  179. #elif defined(CARLA_OS_WIN)

  180.         lib = lib_open("libjack.dll");

  181. #else

  182.         lib = lib_open("libjack.so");

  183. #endif

  184. 

  185.         if (lib == nullptr)

  186.             return;

  187. 

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

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

  190. 

  191.         LIB_SYMBOL(get_version_string)

  192.         LIB_SYMBOL(client_open)

  193.         LIB_SYMBOL(client_close)

  194.         LIB_SYMBOL(client_name_size)

  195.         LIB_SYMBOL(get_client_name)

  196.         LIB_SYMBOL(activate)

  197.         LIB_SYMBOL(deactivate)

  198.         LIB_SYMBOL(on_shutdown)

  199.         LIB_SYMBOL(set_process_callback)

  200.         LIB_SYMBOL(set_freewheel_callback)

  201.         LIB_SYMBOL(set_buffer_size_callback)

  202.         LIB_SYMBOL(set_sample_rate_callback)

  203.         LIB_SYMBOL(set_client_registration_callback)

  204.         LIB_SYMBOL(set_port_registration_callback)

  205.         LIB_SYMBOL(set_port_connect_callback)

  206.         LIB_SYMBOL(set_port_rename_callback)

  207.         LIB_SYMBOL(set_latency_callback)

  208.         LIB_SYMBOL(get_sample_rate)

  209.         LIB_SYMBOL(get_buffer_size)

  210.         LIB_SYMBOL(port_register)

  211.         LIB_SYMBOL(port_unregister)

  212.         LIB_SYMBOL(port_get_buffer)

  213.         LIB_SYMBOL(port_name)

  214.         LIB_SYMBOL(port_short_name)

  215.         LIB_SYMBOL(port_flags)

  216.         LIB_SYMBOL(port_type)

  217.         LIB_SYMBOL(port_set_name)

  218.         LIB_SYMBOL(connect)

  219.         LIB_SYMBOL(disconnect)

  220.         LIB_SYMBOL(port_name_size)

  221.         LIB_SYMBOL(port_get_latency_range)

  222.         LIB_SYMBOL(port_set_latency_range)

  223.         LIB_SYMBOL(recompute_total_latencies)

  224.         LIB_SYMBOL(free)

  225. 

  226.         LIB_SYMBOL(midi_get_event_count)

  227.         LIB_SYMBOL(midi_event_get)

  228.         LIB_SYMBOL(midi_clear_buffer)

  229.         LIB_SYMBOL(midi_event_write)

  230.         LIB_SYMBOL(midi_event_reserve)

  231. 

  232.         LIB_SYMBOL(transport_locate)

  233.         LIB_SYMBOL(transport_start)

  234.         LIB_SYMBOL(transport_stop)

  235.         LIB_SYMBOL(transport_query)

  236. 

  237.         #undef JOIN

  238.         #undef LIB_SYMBOL

  239.     }

  240. 

  241.     ~JackBridge()

  242.     {

  243.         if (lib != nullptr)

  244.             lib_close(lib);

  245.     }

  246. };

  247. 

  248. static JackBridge bridge;

  249. 

  250. int main(){return 0;}

  251. 

  252. // -----------------------------------------------------------------------------

  253. 

  254. const char* jackbridge_get_version_string()

  255. {

  256. #ifndef JACKBRIDGE_DUMMY

  257.     if (bridge.get_version_string_ptr != nullptr)

  258.         return bridge.get_version_string_ptr();

  259. #endif

  260.     return nullptr;

  261. }

  262. 

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

  264. {

  265. #ifndef JACKBRIDGE_DUMMY

  266.     if (bridge.client_open_ptr != nullptr)

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

  268. #endif

  269.     return nullptr;

  270. }

  271. 

  272. // -----------------------------------------------------------------------------

  273. 

  274. int jackbridge_client_close(jack_client_t* client)

  275. {

  276. #ifndef JACKBRIDGE_DUMMY

  277.     if (bridge.client_close_ptr != nullptr)

  278.         return bridge.client_close_ptr(client);

  279. #endif

  280.     return 0;

  281. }

  282. 

  283. int jackbridge_client_name_size()

  284. {

  285. #ifndef JACKBRIDGE_DUMMY

  286.     if (bridge.client_name_size_ptr != nullptr)

  287.         return bridge.client_name_size_ptr();

  288. #endif

  289.     return 0;

  290. }

  291. 

  292. char* jackbridge_get_client_name(jack_client_t* client)

  293. {

  294. #ifndef JACKBRIDGE_DUMMY

  295.     if (bridge.get_client_name_ptr != nullptr)

  296.         return bridge.get_client_name_ptr(client);

  297. #endif

  298.     return nullptr;

  299. }

  300. 

  301. // -----------------------------------------------------------------------------

  302. 

  303. int jackbridge_activate(jack_client_t* client)

  304. {

  305. #ifndef JACKBRIDGE_DUMMY

  306.     if (bridge.activate_ptr != nullptr)

  307.         return bridge.activate_ptr(client);

  308. #endif

  309.     return 0;

  310. }

  311. 

  312. int jackbridge_deactivate(jack_client_t* client)

  313. {

  314. #ifndef JACKBRIDGE_DUMMY

  315.     if (bridge.deactivate_ptr != nullptr)

  316.         return bridge.deactivate_ptr(client);

  317. #endif

  318.     return 0;

  319. }

  320. 

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

  322. {

  323. #ifndef JACKBRIDGE_DUMMY

  324.     if (bridge.on_shutdown_ptr != nullptr)

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

  326. #endif

  327. }

  328. 

  329. int jackbridge_set_process_callback(jack_client_t* client, JackProcessCallback process_callback, void* arg)

  330. {

  331. #ifndef JACKBRIDGE_DUMMY

  332.     if (bridge.set_process_callback_ptr != nullptr)

  333.         return bridge.set_process_callback_ptr(client, process_callback, arg);

  334. #endif

  335.     return 0;

  336. }

  337. 

  338. int jackbridge_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback freewheel_callback, void* arg)

  339. {

  340. #ifndef JACKBRIDGE_DUMMY

  341.     if (bridge.set_freewheel_callback_ptr != nullptr)

  342.         return bridge.set_freewheel_callback_ptr(client, freewheel_callback, arg);

  343. #endif

  344.     return 0;

  345. }

  346. 

  347. int jackbridge_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback bufsize_callback, void* arg)

  348. {

  349. #ifndef JACKBRIDGE_DUMMY

  350.     if (bridge.set_buffer_size_callback_ptr != nullptr)

  351.         return bridge.set_buffer_size_callback_ptr(client, bufsize_callback, arg);

  352. #endif

  353.     return 0;

  354. }

  355. 

  356. int jackbridge_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback srate_callback, void* arg)

  357. {

  358. #ifndef JACKBRIDGE_DUMMY

  359.     if (bridge.set_sample_rate_callback_ptr != nullptr)

  360.         return bridge.set_sample_rate_callback_ptr(client, srate_callback, arg);

  361. #endif

  362.     return 0;

  363. }

  364. 

  365. int jackbridge_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback registration_callback, void* arg)

  366. {

  367. #ifndef JACKBRIDGE_DUMMY

  368.     if (bridge.set_client_registration_callback_ptr != nullptr)

  369.         return bridge.set_client_registration_callback_ptr(client, registration_callback, arg);

  370. #endif

  371.     return 0;

  372. }

  373. 

  374. int jackbridge_set_port_registration_callback (jack_client_t* client, JackPortRegistrationCallback registration_callback, void *arg)

  375. {

  376. #ifndef JACKBRIDGE_DUMMY

  377.     if (bridge.set_port_registration_callback_ptr != nullptr)

  378.         return bridge.set_port_registration_callback_ptr(client, registration_callback, arg);

  379. #endif

  380.     return 0;

  381. }

  382. 

  383. int jackbridge_set_port_connect_callback (jack_client_t* client, JackPortConnectCallback connect_callback, void* arg)

  384. {

  385. #ifndef JACKBRIDGE_DUMMY

  386.     if (bridge.set_port_connect_callback_ptr != nullptr)

  387.         return bridge.set_port_connect_callback_ptr(client, connect_callback, arg);

  388. #endif

  389.     return 0;

  390. }

  391. 

  392. int jackbridge_set_port_rename_callback (jack_client_t* client, JackPortRenameCallback rename_callback, void* arg)

  393. {

  394. #ifndef JACKBRIDGE_DUMMY

  395.     if (bridge.set_port_rename_callback_ptr != nullptr)

  396.         return bridge.set_port_rename_callback_ptr(client, rename_callback, arg);

  397. #endif

  398.     return 0;

  399. }

  400. 

  401. int jackbridge_set_latency_callback(jack_client_t* client, JackLatencyCallback latency_callback, void* arg)

  402. {

  403. #ifndef JACKBRIDGE_DUMMY

  404.     if (bridge.set_latency_callback_ptr != nullptr)

  405.         return bridge.set_latency_callback_ptr(client, latency_callback, arg);

  406. #endif

  407.     return 0;

  408. }

  409. 

  410. // -----------------------------------------------------------------------------

  411. 

  412. jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)

  413. {

  414. #ifndef JACKBRIDGE_DUMMY

  415.     if (bridge.get_sample_rate_ptr != nullptr)

  416.         return bridge.get_sample_rate_ptr(client);

  417. #endif

  418.     return 0;

  419. }

  420. 

  421. jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)

  422. {

  423. #ifndef JACKBRIDGE_DUMMY

  424.     if (bridge.get_buffer_size_ptr != nullptr)

  425.         return bridge.get_buffer_size_ptr(client);

  426. #endif

  427.     return 0;

  428. }

  429. 

  430. 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)

  431. {

  432. #ifndef JACKBRIDGE_DUMMY

  433.     if (bridge.port_register_ptr != nullptr)

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

  435. #endif

  436.     return nullptr;

  437. }

  438. 

  439. int jackbridge_port_unregister(jack_client_t* client, jack_port_t* port)

  440. {

  441. #ifndef JACKBRIDGE_DUMMY

  442.     if (bridge.port_unregister_ptr != nullptr)

  443.         return bridge.port_unregister_ptr(client, port);

  444. #endif

  445.     return 0;

  446. }

  447. 

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

  449. {

  450. #ifndef JACKBRIDGE_DUMMY

  451.     if (bridge.port_get_buffer_ptr != nullptr)

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

  453. #endif

  454.     return nullptr;

  455. }

  456. 

  457. // -----------------------------------------------------------------------------

  458. 

  459. // -----------------------------------------------------------------------------

  460. 

  461. int jackbridge_port_name_size()

  462. {

  463. #ifndef JACKBRIDGE_DUMMY

  464.     if (bridge.port_name_size_ptr != nullptr)

  465.         return bridge.port_name_size_ptr();

  466. #endif

  467.     return 0;

  468. }

  469. 

  470. int jackbridge_recompute_total_latencies(jack_client_t* client)

  471. {

  472. #ifndef JACKBRIDGE_DUMMY

  473.     if (bridge.recompute_total_latencies_ptr != nullptr)

  474.         return bridge.recompute_total_latencies_ptr(client);

  475. #endif

  476.     return 0;

  477. }

  478. 

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

  480. {

  481. #ifndef JACKBRIDGE_DUMMY

  482.     if (bridge.port_get_latency_range_ptr != nullptr)

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

  484. #endif

  485. }

  486. 

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

  488. {

  489. #ifndef JACKBRIDGE_DUMMY

  490.     if (bridge.port_set_latency_range_ptr != nullptr)

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

  492. #endif

  493. }

  494. 

  495. // -----------------------------------------------------------------------------

  496. 

  497. uint32_t jackbridge_midi_get_event_count(void* port_buffer)

  498. {

  499. #ifndef JACKBRIDGE_DUMMY

  500.     if (bridge.midi_get_event_count_ptr != nullptr)

  501.         return bridge.midi_get_event_count_ptr(port_buffer);

  502. #endif

  503.     return 0;

  504. }

  505. 

  506. int jackbridge_midi_event_get(jack_midi_event_t* event, void* port_buffer, uint32_t event_index)

  507. {

  508. #ifndef JACKBRIDGE_DUMMY

  509.     if (bridge.midi_event_get_ptr != nullptr)

  510.         return bridge.midi_event_get_ptr(event, port_buffer, event_index);

  511. #endif

  512.     return 0;

  513. }

  514. 

  515. void jackbridge_midi_clear_buffer(void* port_buffer)

  516. {

  517. #ifndef JACKBRIDGE_DUMMY

  518.     if (bridge.midi_clear_buffer_ptr != nullptr)

  519.         bridge.midi_clear_buffer_ptr(port_buffer);

  520. #endif

  521. }

  522. 

  523. int jackbridge_midi_event_write(void* port_buffer, jack_nframes_t time, const jack_midi_data_t* data, size_t data_size)

  524. {

  525. #ifndef JACKBRIDGE_DUMMY

  526.     if (bridge.midi_event_write_ptr != nullptr)

  527.         return bridge.midi_event_write_ptr(port_buffer, time, data, data_size);

  528. #endif

  529.     return 0;

  530. }

  531. 

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

  533. {

  534. #ifndef JACKBRIDGE_DUMMY

  535.     if (bridge.midi_event_reserve_ptr != nullptr)

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

  537. #endif

  538.     return nullptr;

  539. }

  540. 

  541. // -----------------------------------------------------------------------------

  542. 

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

  544. {

  545. #ifndef JACKBRIDGE_DUMMY

  546.     if (bridge.transport_locate_ptr != nullptr)

  547.         return bridge.transport_locate_ptr(client, frame);

  548. #endif

  549.     return 0;

  550. }

  551. 

  552. void jackbridge_transport_start(jack_client_t* client)

  553. {

  554. #ifndef JACKBRIDGE_DUMMY

  555.     if (bridge.transport_start_ptr != nullptr)

  556.         bridge.transport_start_ptr(client);

  557. #endif

  558. }

  559. 

  560. void jackbridge_transport_stop(jack_client_t* client)

  561. {

  562. #ifndef JACKBRIDGE_DUMMY

  563.     if (bridge.transport_stop_ptr != nullptr)

  564.         bridge.transport_stop_ptr(client);

  565. #endif

  566. }

  567. 

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

  569. {

  570. #ifndef JACKBRIDGE_DUMMY

  571.     if (bridge.transport_query_ptr != nullptr)

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

  573. #endif

  574.     return JackTransportStopped;

  575. }

  576. 

  577. // -----------------------------------------------------------------------------

  578. 

  579. #if 0

  580. void linux_clock_gettime_rt(struct timespec* ts)

  581. {

  582. #ifndef JACKBRIDGE_DUMMY

  583.     clock_gettime(CLOCK_REALTIME, ts);

  584. #endif

  585. }

  586. 

  587. int linux_sem_post(void* sem)

  588. {

  589. #ifndef JACKBRIDGE_DUMMY

  590.     return sem_post(sem);

  591. #else

  592.     return 1;

  593. #endif

  594. }

  595. 

  596. int linux_sem_timedwait(void* sem, struct timespec* ts)

  597. {

  598. #ifndef JACKBRIDGE_DUMMY

  599.     return sem_timedwait(sem, ts);

  600. #else

  601.     return 1;

  602. #endif

  603. }

  604. #endif