DISTRHO
/
PawPaw
mirror of https://github.com/DISTRHO/PawPaw
1
0
Fork 0
Code Issues 0 Releases 2 Wiki Activity
Cross-Platform build scripts for audio plugins
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.
759 Commits
3 Branches
4.3MB
Tree: 51ad86a6c8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '51ad86a6c8'
${ noResults }
PawPaw/patches/portaudio19/04_jackbridge-mod-app.patch

2727 lines
109KB
Raw Blame History 

  1. diff --git a/src/hostapi/jack/pa_jack.c b/src/hostapi/jack/pa_jack.c

  2. index a800f8e..c06eb89 100644

  3. --- a/src/hostapi/jack/pa_jack.c

  4. +++ b/src/hostapi/jack/pa_jack.c

  5. @@ -59,8 +59,8 @@

  6.  #include <math.h>

  7.  #include <semaphore.h>

  8.  

  9. -#include <jack/types.h>

  10. -#include <jack/jack.h>

  11. +#include "JackBridge.c"

  12. +#include <pthread.h>

  13.  

  14.  #include "pa_util.h"

  15.  #include "pa_hostapi.h"

  16. @@ -73,7 +73,7 @@

  17.  

  18.  static pthread_t mainThread_;

  19.  static char *jackErr_ = NULL;

  20. -static const char* clientName_ = "PortAudio";

  21. +static const char* clientName_ = "MOD Desktop";

  22.  

  23.  #define STRINGIZE_HELPER(expr) #expr

  24.  #define STRINGIZE(expr) STRINGIZE_HELPER(expr)

  25. @@ -488,15 +488,15 @@ static PaError BuildDeviceList( PaJackHostApiRepresentation *jackApi )

  26.       * associated with the previous list */

  27.      PaUtil_FreeAllAllocations( jackApi->deviceInfoMemory );

  28.  

  29. -    regex_pattern = PaUtil_GroupAllocateMemory( jackApi->deviceInfoMemory, jack_client_name_size() + 3 );

  30. -    tmp_client_name = PaUtil_GroupAllocateMemory( jackApi->deviceInfoMemory, jack_client_name_size() );

  31. +    regex_pattern = PaUtil_GroupAllocateMemory( jackApi->deviceInfoMemory, jackbridge_client_name_size() + 3 );

  32. +    tmp_client_name = PaUtil_GroupAllocateMemory( jackApi->deviceInfoMemory, jackbridge_client_name_size() );

  33.  

  34.      /* We can only retrieve the list of clients indirectly, by first

  35.       * asking for a list of all ports, then parsing the port names

  36.       * according to the client_name:port_name convention (which is

  37.       * enforced by jackd)

  38.       * A: If jack_get_ports returns NULL, there's nothing for us to do */

  39. -    UNLESS( (jack_ports = jack_get_ports( jackApi->jack_client, "", JACK_PORT_TYPE_FILTER, 0 )) && jack_ports[0], paNoError );

  40. +    UNLESS( (jack_ports = jackbridge_get_ports( jackApi->jack_client, "", JACK_PORT_TYPE_FILTER, 0 )) && jack_ports[0], paNoError );

  41.      /* Find number of ports */

  42.      while( jack_ports[numPorts] )

  43.          ++numPorts;

  44. @@ -514,7 +514,7 @@ static PaError BuildDeviceList( PaJackHostApiRepresentation *jackApi )

  45.          /* extract the client name from the port name, using a regex

  46.           * that parses the clientname:portname syntax */

  47.          UNLESS( !regexec( &port_regex, port, 1, &match_info, 0 ), paInternalError );

  48. -        assert(match_info.rm_eo - match_info.rm_so < jack_client_name_size());

  49. +        assert(match_info.rm_eo - match_info.rm_so < jackbridge_client_name_size());

  50.          memcpy( tmp_client_name, port + match_info.rm_so,

  51.                  match_info.rm_eo - match_info.rm_so );

  52.          tmp_client_name[match_info.rm_eo - match_info.rm_so] = '\0';

  53. @@ -555,7 +555,7 @@ static PaError BuildDeviceList( PaJackHostApiRepresentation *jackApi )

  54.  

  55.      /* there is one global sample rate all clients must conform to */

  56.  

  57. -    globalSampleRate = jack_get_sample_rate( jackApi->jack_client );

  58. +    globalSampleRate = jackbridge_get_sample_rate( jackApi->jack_client );

  59.      UNLESS( commonApi->deviceInfos = (PaDeviceInfo**)PaUtil_GroupAllocateMemory( jackApi->deviceInfoMemory,

  60.                  sizeof(PaDeviceInfo*) * numClients ), paInsufficientMemory );

  61.  

  62. @@ -586,16 +586,16 @@ static PaError BuildDeviceList( PaJackHostApiRepresentation *jackApi )

  63.          sprintf( regex_pattern, "%s:.*", client_names[client_index] );

  64.  

  65.          /* ... what are your output ports (that we could input from)? */

  66. -        clientPorts = jack_get_ports( jackApi->jack_client, regex_pattern,

  67. -                                     JACK_PORT_TYPE_FILTER, JackPortIsOutput);

  68. +        clientPorts = jackbridge_get_ports( jackApi->jack_client, regex_pattern,

  69. +                                           JACK_PORT_TYPE_FILTER, JackPortIsOutput);

  70.          curDevInfo->maxInputChannels = 0;

  71.          curDevInfo->defaultLowInputLatency = 0.;

  72.          curDevInfo->defaultHighInputLatency = 0.;

  73.          if( clientPorts )

  74.          {

  75. -            jack_port_t *p = jack_port_by_name( jackApi->jack_client, clientPorts[0] );

  76. +            jack_port_t *p = jackbridge_port_by_name( jackApi->jack_client, clientPorts[0] );

  77.              curDevInfo->defaultLowInputLatency = curDevInfo->defaultHighInputLatency =

  78. -                jack_port_get_latency( p ) / globalSampleRate;

  79. +                jackbridge_port_get_latency( p ) / globalSampleRate;

  80.  

  81.              for( i = 0; clientPorts[i] != NULL; i++)

  82.              {

  83. @@ -603,20 +603,20 @@ static PaError BuildDeviceList( PaJackHostApiRepresentation *jackApi )

  84.                   * We don't care what they are, we just care how many */

  85.                  curDevInfo->maxInputChannels++;

  86.              }

  87. -            free(clientPorts);

  88. +            jackbridge_free(clientPorts);

  89.          }

  90.  

  91.          /* ... what are your input ports (that we could output to)? */

  92. -        clientPorts = jack_get_ports( jackApi->jack_client, regex_pattern,

  93. -                                     JACK_PORT_TYPE_FILTER, JackPortIsInput);

  94. +        clientPorts = jackbridge_get_ports( jackApi->jack_client, regex_pattern,

  95. +                                           JACK_PORT_TYPE_FILTER, JackPortIsInput);

  96.          curDevInfo->maxOutputChannels = 0;

  97.          curDevInfo->defaultLowOutputLatency = 0.;

  98.          curDevInfo->defaultHighOutputLatency = 0.;

  99.          if( clientPorts )

  100.          {

  101. -            jack_port_t *p = jack_port_by_name( jackApi->jack_client, clientPorts[0] );

  102. +            jack_port_t *p = jackbridge_port_by_name( jackApi->jack_client, clientPorts[0] );

  103.              curDevInfo->defaultLowOutputLatency = curDevInfo->defaultHighOutputLatency =

  104. -                jack_port_get_latency( p ) / globalSampleRate;

  105. +                jackbridge_port_get_latency( p ) / globalSampleRate;

  106.  

  107.              for( i = 0; clientPorts[i] != NULL; i++)

  108.              {

  109. @@ -624,7 +624,7 @@ static PaError BuildDeviceList( PaJackHostApiRepresentation *jackApi )

  110.                   * We don't care what they are, we just care how many */

  111.                  curDevInfo->maxOutputChannels++;

  112.              }

  113. -            free(clientPorts);

  114. +            jackbridge_free(clientPorts);

  115.          }

  116.  

  117.          /* Add this client to the list of devices */

  118. @@ -638,7 +638,7 @@ static PaError BuildDeviceList( PaJackHostApiRepresentation *jackApi )

  119.  

  120.  error:

  121.      regfree( &port_regex );

  122. -    free( jack_ports );

  123. +    jackbridge_free( jack_ports );

  124.      return result;

  125.  }

  126.  

  127. @@ -730,7 +730,11 @@ PaError PaJack_Initialize( PaUtilHostApiRepresentation **hostApi,

  128.       * automatically which we do not want.

  129.       */

  130.  

  131. -    jackHostApi->jack_client = jack_client_open( clientName_, JackNoStartServer, &jackStatus );

  132. +    if (jackbridge_is_ok())

  133. +        jackHostApi->jack_client = jackbridge_client_open( clientName_, JackNoStartServer, &jackStatus );

  134. +    else

  135. +        jackHostApi->jack_client = NULL;

  136. +

  137.      if( !jackHostApi->jack_client )

  138.      {

  139.          /* the V19 development docs say that if an implementation

  140. @@ -746,7 +750,7 @@ PaError PaJack_Initialize( PaUtilHostApiRepresentation **hostApi,

  141.      *hostApi = &jackHostApi->commonHostApiRep;

  142.      (*hostApi)->info.structVersion = 1;

  143.      (*hostApi)->info.type = paJACK;

  144. -    (*hostApi)->info.name = "JACK Audio Connection Kit";

  145. +    (*hostApi)->info.name = "JACK";

  146.  

  147.      /* Build a device list by querying the JACK server */

  148.      ENSURE_PA( BuildDeviceList( jackHostApi ) );

  149. @@ -778,26 +782,26 @@ PaError PaJack_Initialize( PaUtilHostApiRepresentation **hostApi,

  150.      jackHostApi->processQueue = NULL;

  151.      jackHostApi->jackIsDown = 0;

  152.  

  153. -    jack_on_shutdown( jackHostApi->jack_client, JackOnShutdown, jackHostApi );

  154. -    jack_set_error_function( JackErrorCallback );

  155. -    jackHostApi->jack_buffer_size = jack_get_buffer_size ( jackHostApi->jack_client );

  156. +    jackbridge_on_shutdown( jackHostApi->jack_client, JackOnShutdown, jackHostApi );

  157. +    jackbridge_set_error_function( JackErrorCallback );

  158. +    jackHostApi->jack_buffer_size = jackbridge_get_buffer_size ( jackHostApi->jack_client );

  159.      /* Don't check for error, may not be supported (deprecated in at least jackdmp) */

  160. -    jack_set_sample_rate_callback( jackHostApi->jack_client, JackSrCb, jackHostApi );

  161. -    UNLESS( !jack_set_xrun_callback( jackHostApi->jack_client, JackXRunCb, jackHostApi ), paUnanticipatedHostError );

  162. -    UNLESS( !jack_set_process_callback( jackHostApi->jack_client, JackCallback, jackHostApi ), paUnanticipatedHostError );

  163. -    UNLESS( !jack_activate( jackHostApi->jack_client ), paUnanticipatedHostError );

  164. +    jackbridge_set_sample_rate_callback( jackHostApi->jack_client, JackSrCb, jackHostApi );

  165. +    UNLESS( jackbridge_set_xrun_callback( jackHostApi->jack_client, JackXRunCb, jackHostApi ), paUnanticipatedHostError );

  166. +    UNLESS( jackbridge_set_process_callback( jackHostApi->jack_client, JackCallback, jackHostApi ), paUnanticipatedHostError );

  167. +    UNLESS( jackbridge_activate( jackHostApi->jack_client ), paUnanticipatedHostError );

  168.      activated = 1;

  169.  

  170.      return result;

  171.  

  172.  error:

  173.      if( activated )

  174. -        ASSERT_CALL( jack_deactivate( jackHostApi->jack_client ), 0 );

  175. +        ASSERT_CALL( jackbridge_deactivate( jackHostApi->jack_client ), true );

  176.  

  177.      if( jackHostApi )

  178.      {

  179.          if( jackHostApi->jack_client )

  180. -            ASSERT_CALL( jack_client_close( jackHostApi->jack_client ), 0 );

  181. +            ASSERT_CALL( jackbridge_client_close( jackHostApi->jack_client ), true );

  182.  

  183.          if( jackHostApi->deviceInfoMemory )

  184.          {

  185. @@ -817,12 +821,12 @@ static void Terminate( struct PaUtilHostApiRepresentation *hostApi )

  186.  

  187.      /* note: this automatically disconnects all ports, since a deactivated

  188.       * client is not allowed to have any ports connected */

  189. -    ASSERT_CALL( jack_deactivate( jackHostApi->jack_client ), 0 );

  190. +    ASSERT_CALL( jackbridge_deactivate( jackHostApi->jack_client ), true );

  191.  

  192.      ASSERT_CALL( pthread_mutex_destroy( &jackHostApi->mtx ), 0 );

  193.      ASSERT_CALL( pthread_cond_destroy( &jackHostApi->cond ), 0 );

  194.  

  195. -    ASSERT_CALL( jack_client_close( jackHostApi->jack_client ), 0 );

  196. +    ASSERT_CALL( jackbridge_client_close( jackHostApi->jack_client ), true );

  197.  

  198.      if( jackHostApi->deviceInfoMemory )

  199.      {

  200. @@ -915,7 +919,7 @@ static PaError IsFormatSupported( struct PaUtilHostApiRepresentation *hostApi,

  201.      /* check that the device supports sampleRate */

  202.  

  203.  #define ABS(x) ( (x) > 0 ? (x) : -(x) )

  204. -    if( ABS(sampleRate - jack_get_sample_rate(((PaJackHostApiRepresentation *) hostApi)->jack_client )) > 1 )

  205. +    if( ABS(sampleRate - jackbridge_get_sample_rate(((PaJackHostApiRepresentation *) hostApi)->jack_client )) > 1 )

  206.         return paInvalidSampleRate;

  207.  #undef ABS

  208.  

  209. @@ -980,12 +984,12 @@ static void CleanUpStream( PaJackStream *stream, int terminateStreamRepresentati

  210.      for( i = 0; i < stream->num_incoming_connections; ++i )

  211.      {

  212.          if( stream->local_input_ports[i] )

  213. -            ASSERT_CALL( jack_port_unregister( stream->jack_client, stream->local_input_ports[i] ), 0 );

  214. +            ASSERT_CALL( jackbridge_port_unregister( stream->jack_client, stream->local_input_ports[i] ), 0 );

  215.      }

  216.      for( i = 0; i < stream->num_outgoing_connections; ++i )

  217.      {

  218.          if( stream->local_output_ports[i] )

  219. -            ASSERT_CALL( jack_port_unregister( stream->jack_client, stream->local_output_ports[i] ), 0 );

  220. +            ASSERT_CALL( jackbridge_port_unregister( stream->jack_client, stream->local_output_ports[i] ), 0 );

  221.      }

  222.  

  223.      if( terminateStreamRepresentation )

  224. @@ -1077,14 +1081,14 @@ static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi,

  225.      PaError result = paNoError;

  226.      PaJackHostApiRepresentation *jackHostApi = (PaJackHostApiRepresentation*)hostApi;

  227.      PaJackStream *stream = NULL;

  228. -    char *port_string = PaUtil_GroupAllocateMemory( jackHostApi->deviceInfoMemory, jack_port_name_size() );

  229. -    unsigned long regexSz = jack_client_name_size() + 3;

  230. +    char *port_string = PaUtil_GroupAllocateMemory( jackHostApi->deviceInfoMemory, jackbridge_port_name_size() );

  231. +    unsigned long regexSz = jackbridge_client_name_size() + 3;

  232.      char *regex_pattern = PaUtil_GroupAllocateMemory( jackHostApi->deviceInfoMemory, regexSz );

  233.      const char **jack_ports = NULL;

  234. -    /* int jack_max_buffer_size = jack_get_buffer_size( jackHostApi->jack_client ); */

  235. +    /* int jack_max_buffer_size = jackbridge_get_buffer_size( jackHostApi->jack_client ); */

  236.      int i;

  237.      int inputChannelCount, outputChannelCount;

  238. -    const double jackSr = jack_get_sample_rate( jackHostApi->jack_client );

  239. +    const double jackSr = jackbridge_get_sample_rate( jackHostApi->jack_client );

  240.      PaSampleFormat inputSampleFormat = 0, outputSampleFormat = 0;

  241.      int bpInitialized = 0, srInitialized = 0;   /* Initialized buffer processor and stream representation? */

  242.      unsigned long ofs;

  243. @@ -1178,7 +1182,7 @@ static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi,

  244.              latency = outputParameters->suggestedLatency;

  245.  

  246.          /* the latency the user asked for indicates the minimum buffer size in frames */

  247. -        minimum_buffer_frames = (int) (latency * jack_get_sample_rate( jackHostApi->jack_client ));

  248. +        minimum_buffer_frames = (int) (latency * jackbridge_get_sample_rate( jackHostApi->jack_client ));

  249.  

  250.          /* we also need to be able to store at least three full jack buffers to avoid dropouts */

  251.          if( jackHostApi->jack_buffer_size * 3 > minimum_buffer_frames )

  252. @@ -1211,8 +1215,8 @@ static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi,

  253.      ofs = jackHostApi->inputBase;

  254.      for( i = 0; i < inputChannelCount; i++ )

  255.      {

  256. -        snprintf( port_string, jack_port_name_size(), "in_%lu", ofs + i );

  257. -        UNLESS( stream->local_input_ports[i] = jack_port_register(

  258. +        snprintf( port_string, jackbridge_port_name_size(), "in_%lu", ofs + i );

  259. +        UNLESS( stream->local_input_ports[i] = jackbridge_port_register(

  260.                jackHostApi->jack_client, port_string,

  261.                JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0 ), paInsufficientMemory );

  262.      }

  263. @@ -1221,8 +1225,8 @@ static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi,

  264.      ofs = jackHostApi->outputBase;

  265.      for( i = 0; i < outputChannelCount; i++ )

  266.      {

  267. -        snprintf( port_string, jack_port_name_size(), "out_%lu", ofs + i );

  268. -        UNLESS( stream->local_output_ports[i] = jack_port_register(

  269. +        snprintf( port_string, jackbridge_port_name_size(), "out_%lu", ofs + i );

  270. +        UNLESS( stream->local_output_ports[i] = jackbridge_port_register(

  271.               jackHostApi->jack_client, port_string,

  272.               JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0 ), paInsufficientMemory );

  273.      }

  274. @@ -1238,18 +1242,18 @@ static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi,

  275.  

  276.          /* Get output ports of our capture device */

  277.          snprintf( regex_pattern, regexSz, "%s:.*", hostApi->deviceInfos[ inputParameters->device ]->name );

  278. -        UNLESS( jack_ports = jack_get_ports( jackHostApi->jack_client, regex_pattern,

  279. +        UNLESS( jack_ports = jackbridge_get_ports( jackHostApi->jack_client, regex_pattern,

  280.                                       JACK_PORT_TYPE_FILTER, JackPortIsOutput ), paUnanticipatedHostError );

  281.          for( i = 0; i < inputChannelCount && jack_ports[i]; i++ )

  282.          {

  283. -            if( (stream->remote_output_ports[i] = jack_port_by_name(

  284. +            if( (stream->remote_output_ports[i] = jackbridge_port_by_name(

  285.                   jackHostApi->jack_client, jack_ports[i] )) == NULL )

  286.              {

  287.                  err = 1;

  288.                  break;

  289.              }

  290.          }

  291. -        free( jack_ports );

  292. +        jackbridge_free( jack_ports );

  293.          UNLESS( !err, paInsufficientMemory );

  294.  

  295.          /* Fewer ports than expected? */

  296. @@ -1262,18 +1266,18 @@ static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi,

  297.  

  298.          /* Get input ports of our playback device */

  299.          snprintf( regex_pattern, regexSz, "%s:.*", hostApi->deviceInfos[ outputParameters->device ]->name );

  300. -        UNLESS( jack_ports = jack_get_ports( jackHostApi->jack_client, regex_pattern,

  301. +        UNLESS( jack_ports = jackbridge_get_ports( jackHostApi->jack_client, regex_pattern,

  302.                                       JACK_PORT_TYPE_FILTER, JackPortIsInput ), paUnanticipatedHostError );

  303.          for( i = 0; i < outputChannelCount && jack_ports[i]; i++ )

  304.          {

  305. -            if( (stream->remote_input_ports[i] = jack_port_by_name(

  306. +            if( (stream->remote_input_ports[i] = jackbridge_port_by_name(

  307.                   jackHostApi->jack_client, jack_ports[i] )) == 0 )

  308.              {

  309.                  err = 1;

  310.                  break;

  311.              }

  312.          }

  313. -        free( jack_ports );

  314. +        jackbridge_free( jack_ports );

  315.          UNLESS( !err , paInsufficientMemory );

  316.  

  317.          /* Fewer ports than expected? */

  318. @@ -1298,16 +1302,16 @@ static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi,

  319.      bpInitialized = 1;

  320.  

  321.      if( stream->num_incoming_connections > 0 )

  322. -        stream->streamRepresentation.streamInfo.inputLatency = (jack_port_get_latency( stream->remote_output_ports[0] )

  323. -                - jack_get_buffer_size( jackHostApi->jack_client )  /* One buffer is not counted as latency */

  324. +        stream->streamRepresentation.streamInfo.inputLatency = (jackbridge_port_get_latency( stream->remote_output_ports[0] )

  325. +                - jackbridge_get_buffer_size( jackHostApi->jack_client )  /* One buffer is not counted as latency */

  326.              + PaUtil_GetBufferProcessorInputLatencyFrames( &stream->bufferProcessor )) / sampleRate;

  327.      if( stream->num_outgoing_connections > 0 )

  328. -        stream->streamRepresentation.streamInfo.outputLatency = (jack_port_get_latency( stream->remote_input_ports[0] )

  329. -                - jack_get_buffer_size( jackHostApi->jack_client )  /* One buffer is not counted as latency */

  330. +        stream->streamRepresentation.streamInfo.outputLatency = (jackbridge_port_get_latency( stream->remote_input_ports[0] )

  331. +                - jackbridge_get_buffer_size( jackHostApi->jack_client )  /* One buffer is not counted as latency */

  332.              + PaUtil_GetBufferProcessorOutputLatencyFrames( &stream->bufferProcessor )) / sampleRate;

  333.  

  334.      stream->streamRepresentation.streamInfo.sampleRate = jackSr;

  335. -    stream->t0 = jack_frame_time( jackHostApi->jack_client );   /* A: Time should run from Pa_OpenStream */

  336. +    stream->t0 = jackbridge_frame_time( jackHostApi->jack_client );   /* A: Time should run from Pa_OpenStream */

  337.  

  338.      /* Add to queue of opened streams */

  339.      ENSURE_PA( AddStream( stream ) );

  340. @@ -1346,7 +1350,7 @@ static PaError RealProcess( PaJackStream *stream, jack_nframes_t frames )

  341.      PaStreamCallbackTimeInfo timeInfo = {0,0,0};

  342.      int chn;

  343.      int framesProcessed;

  344. -    const double sr = jack_get_sample_rate( stream->jack_client );    /* Shouldn't change during the process callback */

  345. +    const double sr = jackbridge_get_sample_rate( stream->jack_client );    /* Shouldn't change during the process callback */

  346.      PaStreamCallbackFlags cbFlags = 0;

  347.  

  348.      /* If the user has returned !paContinue from the callback we'll want to flush the internal buffers,

  349. @@ -1362,12 +1366,12 @@ static PaError RealProcess( PaJackStream *stream, jack_nframes_t frames )

  350.          goto end;

  351.      }

  352.  

  353. -    timeInfo.currentTime = (jack_frame_time( stream->jack_client ) - stream->t0) / sr;

  354. +    timeInfo.currentTime = (jackbridge_frame_time( stream->jack_client ) - stream->t0) / sr;

  355.      if( stream->num_incoming_connections > 0 )

  356. -        timeInfo.inputBufferAdcTime = timeInfo.currentTime - jack_port_get_latency( stream->remote_output_ports[0] )

  357. +        timeInfo.inputBufferAdcTime = timeInfo.currentTime - jackbridge_port_get_latency( stream->remote_output_ports[0] )

  358.              / sr;

  359.      if( stream->num_outgoing_connections > 0 )

  360. -        timeInfo.outputBufferDacTime = timeInfo.currentTime + jack_port_get_latency( stream->remote_input_ports[0] )

  361. +        timeInfo.outputBufferDacTime = timeInfo.currentTime + jackbridge_port_get_latency( stream->remote_input_ports[0] )

  362.              / sr;

  363.  

  364.      PaUtil_BeginCpuLoadMeasurement( &stream->cpuLoadMeasurer );

  365. @@ -1389,7 +1393,7 @@ static PaError RealProcess( PaJackStream *stream, jack_nframes_t frames )

  366.      for( chn = 0; chn < stream->num_incoming_connections; chn++ )

  367.      {

  368.          jack_default_audio_sample_t *channel_buf = (jack_default_audio_sample_t*)

  369. -            jack_port_get_buffer( stream->local_input_ports[chn],

  370. +            jackbridge_port_get_buffer( stream->local_input_ports[chn],

  371.                      frames );

  372.  

  373.          PaUtil_SetNonInterleavedInputChannel( &stream->bufferProcessor,

  374. @@ -1400,7 +1404,7 @@ static PaError RealProcess( PaJackStream *stream, jack_nframes_t frames )

  375.      for( chn = 0; chn < stream->num_outgoing_connections; chn++ )

  376.      {

  377.          jack_default_audio_sample_t *channel_buf = (jack_default_audio_sample_t*)

  378. -            jack_port_get_buffer( stream->local_output_ports[chn],

  379. +            jackbridge_port_get_buffer( stream->local_output_ports[chn],

  380.                      frames );

  381.  

  382.          PaUtil_SetNonInterleavedOutputChannel( &stream->bufferProcessor,

  383. @@ -1424,7 +1428,7 @@ static PaError UpdateQueue( PaJackHostApiRepresentation *hostApi )

  384.  {

  385.      PaError result = paNoError;

  386.      int queueModified = 0;

  387. -    const double jackSr = jack_get_sample_rate( hostApi->jack_client );

  388. +    const double jackSr = jackbridge_get_sample_rate( hostApi->jack_client );

  389.      int err;

  390.  

  391.      if( (err = pthread_mutex_trylock( &hostApi->mtx )) != 0 )

  392. @@ -1559,7 +1563,7 @@ static int JackCallback( jack_nframes_t frames, void *userData )

  393.              PA_DEBUG(( "Silencing the output\n" ));

  394.              for( i = 0; i < stream->num_outgoing_connections; ++i )

  395.              {

  396. -                jack_default_audio_sample_t *buffer = jack_port_get_buffer( stream->local_output_ports[i], frames );

  397. +                jack_default_audio_sample_t *buffer = jackbridge_port_get_buffer( stream->local_output_ports[i], frames );

  398.                  memset( buffer, 0, sizeof (jack_default_audio_sample_t) * frames );

  399.              }

  400.  

  401. @@ -1606,9 +1610,9 @@ static PaError StartStream( PaStream *s )

  402.      {

  403.          for( i = 0; i < stream->num_incoming_connections; i++ )

  404.          {

  405. -            int r = jack_connect( stream->jack_client, jack_port_name( stream->remote_output_ports[i] ),

  406. -                    jack_port_name( stream->local_input_ports[i] ) );

  407. -           UNLESS( 0 == r || EEXIST == r, paUnanticipatedHostError );

  408. +            bool r = jackbridge_connect( stream->jack_client, jackbridge_port_name( stream->remote_output_ports[i] ),

  409. +                    jackbridge_port_name( stream->local_input_ports[i] ) );

  410. +            UNLESS( r, paUnanticipatedHostError );

  411.          }

  412.      }

  413.  

  414. @@ -1616,9 +1620,9 @@ static PaError StartStream( PaStream *s )

  415.      {

  416.          for( i = 0; i < stream->num_outgoing_connections; i++ )

  417.          {

  418. -            int r = jack_connect( stream->jack_client, jack_port_name( stream->local_output_ports[i] ),

  419. -                    jack_port_name( stream->remote_input_ports[i] ) );

  420. -           UNLESS( 0 == r || EEXIST == r, paUnanticipatedHostError );

  421. +            bool r = jackbridge_connect( stream->jack_client, jackbridge_port_name( stream->local_output_ports[i] ),

  422. +                    jackbridge_port_name( stream->remote_input_ports[i] ) );

  423. +            UNLESS( r, paUnanticipatedHostError );

  424.          }

  425.      }

  426.  

  427. @@ -1685,17 +1689,17 @@ error:

  428.      {

  429.          for( i = 0; i < stream->num_incoming_connections; i++ )

  430.          {

  431. -            if( jack_port_connected( stream->local_input_ports[i] ) )

  432. +            if( jackbridge_port_connected( stream->local_input_ports[i] ) )

  433.              {

  434. -                UNLESS( !jack_port_disconnect( stream->jack_client, stream->local_input_ports[i] ),

  435. +                UNLESS( jackbridge_port_disconnect( stream->jack_client, stream->local_input_ports[i] ),

  436.                          paUnanticipatedHostError );

  437.              }

  438.          }

  439.          for( i = 0; i < stream->num_outgoing_connections; i++ )

  440.          {

  441. -            if( jack_port_connected( stream->local_output_ports[i] ) )

  442. +            if( jackbridge_port_connected( stream->local_output_ports[i] ) )

  443.              {

  444. -                UNLESS( !jack_port_disconnect( stream->jack_client, stream->local_output_ports[i] ),

  445. +                UNLESS( jackbridge_port_disconnect( stream->jack_client, stream->local_output_ports[i] ),

  446.                          paUnanticipatedHostError );

  447.              }

  448.          }

  449. @@ -1735,7 +1739,7 @@ static PaTime GetStreamTime( PaStream *s )

  450.      PaJackStream *stream = (PaJackStream*)s;

  451.  

  452.      /* A: Is this relevant?? --> TODO: what if we're recording-only? */

  453. -    return (jack_frame_time( stream->jack_client ) - stream->t0) / (PaTime)jack_get_sample_rate( stream->jack_client );

  454. +    return (jackbridge_frame_time( stream->jack_client ) - stream->t0) / (PaTime)jackbridge_get_sample_rate( stream->jack_client );

  455.  }

  456.  

  457.  

  458. @@ -1747,7 +1751,7 @@ static double GetStreamCpuLoad( PaStream* s )

  459.  

  460.  PaError PaJack_SetClientName( const char* name )

  461.  {

  462. -    if( strlen( name ) > jack_client_name_size() )

  463. +    if( strlen( name ) > jackbridge_client_name_size() )

  464.      {

  465.          /* OK, I don't know any better error code */

  466.          return paInvalidFlag;

  467. @@ -1762,7 +1766,7 @@ PaError PaJack_GetClientName(const char** clientName)

  468.      PaJackHostApiRepresentation* jackHostApi = NULL;

  469.      PaJackHostApiRepresentation** ref = &jackHostApi;

  470.      ENSURE_PA( PaUtil_GetHostApiRepresentation( (PaUtilHostApiRepresentation**)ref, paJACK ) );

  471. -    *clientName = jack_get_client_name( jackHostApi->jack_client );

  472. +    *clientName = jackbridge_get_client_name( jackHostApi->jack_client );

  473.  

  474.  error:

  475.      return result;

  476. diff --git a/src/hostapi/jack/JackBridge.c b/src/hostapi/jack/JackBridge.c

  477. new file mode 100644

  478. index 0000000..5d83b1d

  479. --- /dev/null

  480. +++ b/src/hostapi/jack/JackBridge.c

  481. @@ -0,0 +1,1820 @@

  482. +/*

  483. + * JackBridge for DPF

  484. + * Copyright (C) 2013-2022 Filipe Coelho <falktx@falktx.com>

  485. + *

  486. + * Permission to use, copy, modify, and/or distribute this software for any purpose with

  487. + * or without fee is hereby granted, provided that the above copyright notice and this

  488. + * permission notice appear in all copies.

  489. + *

  490. + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD

  491. + * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN

  492. + * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL

  493. + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER

  494. + * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN

  495. + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

  496. + */

  497. +

  498. +#include "JackBridge.h"

  499. +

  500. +#ifdef _WIN32

  501. +# define JACKSYM_API __cdecl

  502. +#else

  503. +# define JACKSYM_API

  504. +#endif

  505. +

  506. +#include <dlfcn.h>

  507. +#include <errno.h>

  508. +typedef void* lib_t;

  509. +

  510. +// -----------------------------------------------------------------------------

  511. +

  512. +typedef void (JACKSYM_API *JackSymLatencyCallback)(jack_latency_callback_mode_t, void*);

  513. +typedef int  (JACKSYM_API *JackSymProcessCallback)(jack_nframes_t, void*);

  514. +typedef void (JACKSYM_API *JackSymThreadInitCallback)(void*);

  515. +typedef int  (JACKSYM_API *JackSymGraphOrderCallback)(void*);

  516. +typedef int  (JACKSYM_API *JackSymXRunCallback)(void*);

  517. +typedef int  (JACKSYM_API *JackSymBufferSizeCallback)(jack_nframes_t, void*);

  518. +typedef int  (JACKSYM_API *JackSymSampleRateCallback)(jack_nframes_t, void*);

  519. +typedef void (JACKSYM_API *JackSymPortRegistrationCallback)(jack_port_id_t, int, void*);

  520. +typedef void (JACKSYM_API *JackSymClientRegistrationCallback)(const char*, int, void*);

  521. +typedef void (JACKSYM_API *JackSymPortConnectCallback)(jack_port_id_t, jack_port_id_t, int, void*);

  522. +typedef void (JACKSYM_API *JackSymPortRenameCallback)(jack_port_id_t, const char*, const char*, void*);

  523. +typedef void (JACKSYM_API *JackSymFreewheelCallback)(int, void*);

  524. +typedef void (JACKSYM_API *JackSymShutdownCallback)(void*);

  525. +typedef void (JACKSYM_API *JackSymInfoShutdownCallback)(jack_status_t, const char*, void*);

  526. +typedef int  (JACKSYM_API *JackSymSyncCallback)(jack_transport_state_t, jack_position_t*, void*);

  527. +typedef void (JACKSYM_API *JackSymTimebaseCallback)(jack_transport_state_t, jack_nframes_t, jack_position_t*, int, void*);

  528. +typedef void (JACKSYM_API *JackSymSessionCallback)(jack_session_event_t*, void*);

  529. +typedef void (JACKSYM_API *JackSymPropertyChangeCallback)(jack_uuid_t, const char*, jack_property_change_t, void*);

  530. +typedef void* (JACKSYM_API *JackSymThreadCallback)(void*);

  531. +

  532. +typedef void        (JACKSYM_API *jacksym_get_version)(int*, int*, int*, int*);

  533. +typedef const char* (JACKSYM_API *jacksym_get_version_string)(void);

  534. +

  535. +typedef jack_client_t* (JACKSYM_API *jacksym_client_open)(const char*, jack_options_t, jack_status_t*, ...);

  536. +typedef int            (JACKSYM_API *jacksym_client_close)(jack_client_t*);

  537. +

  538. +typedef int   (JACKSYM_API *jacksym_client_name_size)(void);

  539. +typedef char* (JACKSYM_API *jacksym_get_client_name)(jack_client_t*);

  540. +

  541. +typedef char* (JACKSYM_API *jacksym_client_get_uuid)(jack_client_t*);

  542. +typedef char* (JACKSYM_API *jacksym_get_uuid_for_client_name)(jack_client_t*, const char*);

  543. +typedef char* (JACKSYM_API *jacksym_get_client_name_by_uuid)(jack_client_t*, const char*);

  544. +

  545. +typedef int  (JACKBRIDGE_API *jacksym_uuid_parse)(const char*, jack_uuid_t*);

  546. +typedef void (JACKBRIDGE_API *jacksym_uuid_unparse)(jack_uuid_t, char buf[JACK_UUID_STRING_SIZE]);

  547. +

  548. +typedef int (JACKSYM_API *jacksym_activate)(jack_client_t*);

  549. +typedef int (JACKSYM_API *jacksym_deactivate)(jack_client_t*);

  550. +typedef int (JACKSYM_API *jacksym_is_realtime)(jack_client_t*);

  551. +

  552. +typedef int  (JACKSYM_API *jacksym_set_thread_init_callback)(jack_client_t*, JackSymThreadInitCallback, void*);

  553. +typedef void (JACKSYM_API *jacksym_on_shutdown)(jack_client_t*, JackSymShutdownCallback, void*);

  554. +typedef void (JACKSYM_API *jacksym_on_info_shutdown)(jack_client_t*, JackSymInfoShutdownCallback, void*);

  555. +typedef int  (JACKSYM_API *jacksym_set_process_callback)(jack_client_t*, JackSymProcessCallback, void*);

  556. +typedef int  (JACKSYM_API *jacksym_set_freewheel_callback)(jack_client_t*, JackSymFreewheelCallback, void*);

  557. +typedef int  (JACKSYM_API *jacksym_set_buffer_size_callback)(jack_client_t*, JackSymBufferSizeCallback, void*);

  558. +typedef int  (JACKSYM_API *jacksym_set_sample_rate_callback)(jack_client_t*, JackSymSampleRateCallback, void*);

  559. +typedef int  (JACKSYM_API *jacksym_set_client_registration_callback)(jack_client_t*, JackSymClientRegistrationCallback, void*);

  560. +typedef int  (JACKSYM_API *jacksym_set_port_registration_callback)(jack_client_t*, JackSymPortRegistrationCallback, void*);

  561. +typedef int  (JACKSYM_API *jacksym_set_port_rename_callback)(jack_client_t*, JackSymPortRenameCallback, void*);

  562. +typedef int  (JACKSYM_API *jacksym_set_port_connect_callback)(jack_client_t*, JackSymPortConnectCallback, void*);

  563. +typedef int  (JACKSYM_API *jacksym_set_graph_order_callback)(jack_client_t*, JackSymGraphOrderCallback, void*);

  564. +typedef int  (JACKSYM_API *jacksym_set_xrun_callback)(jack_client_t*, JackSymXRunCallback, void*);

  565. +typedef int  (JACKSYM_API *jacksym_set_latency_callback)(jack_client_t*, JackSymLatencyCallback, void*);

  566. +

  567. +typedef int (JACKSYM_API *jacksym_set_freewheel)(jack_client_t*, int);

  568. +typedef int (JACKSYM_API *jacksym_set_buffer_size)(jack_client_t*, jack_nframes_t);

  569. +

  570. +typedef jack_nframes_t (JACKSYM_API *jacksym_get_sample_rate)(jack_client_t*);

  571. +typedef jack_nframes_t (JACKSYM_API *jacksym_get_buffer_size)(jack_client_t*);

  572. +typedef float          (JACKSYM_API *jacksym_cpu_load)(jack_client_t*);

  573. +

  574. +typedef jack_port_t* (JACKSYM_API *jacksym_port_register)(jack_client_t*, const char*, const char*, ulong, ulong);

  575. +typedef int          (JACKSYM_API *jacksym_port_unregister)(jack_client_t*, jack_port_t*);

  576. +typedef void*        (JACKSYM_API *jacksym_port_get_buffer)(jack_port_t*, jack_nframes_t);

  577. +

  578. +typedef const char*  (JACKSYM_API *jacksym_port_name)(const jack_port_t*);

  579. +typedef jack_uuid_t  (JACKSYM_API *jacksym_port_uuid)(const jack_port_t*);

  580. +typedef const char*  (JACKSYM_API *jacksym_port_short_name)(const jack_port_t*);

  581. +typedef int          (JACKSYM_API *jacksym_port_flags)(const jack_port_t*);

  582. +typedef const char*  (JACKSYM_API *jacksym_port_type)(const jack_port_t*);

  583. +typedef int          (JACKSYM_API *jacksym_port_is_mine)(const jack_client_t*, const jack_port_t*);

  584. +typedef int          (JACKSYM_API *jacksym_port_connected)(const jack_port_t*);

  585. +typedef int          (JACKSYM_API *jacksym_port_connected_to)(const jack_port_t*, const char*);

  586. +typedef const char** (JACKSYM_API *jacksym_port_get_connections)(const jack_port_t*);

  587. +typedef const char** (JACKSYM_API *jacksym_port_get_all_connections)(const jack_client_t*, const jack_port_t*);

  588. +

  589. +typedef int (JACKSYM_API *jacksym_port_rename)(jack_client_t*, jack_port_t*, const char*);

  590. +typedef int (JACKSYM_API *jacksym_port_set_name)(jack_port_t*, const char*);

  591. +typedef int (JACKSYM_API *jacksym_port_set_alias)(jack_port_t*, const char*);

  592. +typedef int (JACKSYM_API *jacksym_port_unset_alias)(jack_port_t*, const char*);

  593. +typedef int (JACKSYM_API *jacksym_port_get_aliases)(const jack_port_t*, char* const aliases[2]);

  594. +

  595. +typedef int (JACKSYM_API *jacksym_port_request_monitor)(jack_port_t*, int);

  596. +typedef int (JACKSYM_API *jacksym_port_request_monitor_by_name)(jack_client_t*, const char*, int);

  597. +typedef int (JACKSYM_API *jacksym_port_ensure_monitor)(jack_port_t*, int);

  598. +typedef int (JACKSYM_API *jacksym_port_monitoring_input)(jack_port_t*);

  599. +

  600. +typedef int (JACKSYM_API *jacksym_connect)(jack_client_t*, const char*, const char*);

  601. +typedef int (JACKSYM_API *jacksym_disconnect)(jack_client_t*, const char*, const char*);

  602. +typedef int (JACKSYM_API *jacksym_port_disconnect)(jack_client_t*, jack_port_t*);

  603. +

  604. +typedef int    (JACKSYM_API *jacksym_port_name_size)(void);

  605. +typedef int    (JACKSYM_API *jacksym_port_type_size)(void);

  606. +typedef size_t (JACKSYM_API *jacksym_port_type_get_buffer_size)(jack_client_t*, const char*);

  607. +

  608. +typedef void (JACKSYM_API *jacksym_port_get_latency_range)(jack_port_t*, jack_latency_callback_mode_t, jack_latency_range_t*);

  609. +typedef void (JACKSYM_API *jacksym_port_set_latency_range)(jack_port_t*, jack_latency_callback_mode_t, jack_latency_range_t*);

  610. +typedef int  (JACKSYM_API *jacksym_recompute_total_latencies)(jack_client_t*);

  611. +

  612. +typedef const char** (JACKSYM_API *jacksym_get_ports)(jack_client_t*, const char*, const char*, ulong);

  613. +typedef jack_port_t* (JACKSYM_API *jacksym_port_by_name)(jack_client_t*, const char*);

  614. +typedef jack_port_t* (JACKSYM_API *jacksym_port_by_id)(jack_client_t*, jack_port_id_t);

  615. +

  616. +typedef void (JACKSYM_API *jacksym_free)(void*);

  617. +

  618. +typedef uint32_t (JACKSYM_API *jacksym_midi_get_event_count)(void*);

  619. +typedef int      (JACKSYM_API *jacksym_midi_event_get)(jack_midi_event_t*, void*, uint32_t);

  620. +typedef void     (JACKSYM_API *jacksym_midi_clear_buffer)(void*);

  621. +typedef int      (JACKSYM_API *jacksym_midi_event_write)(void*, jack_nframes_t, const jack_midi_data_t*, size_t);

  622. +typedef jack_midi_data_t* (JACKSYM_API *jacksym_midi_event_reserve)(void*, jack_nframes_t, size_t);

  623. +

  624. +typedef int (JACKSYM_API *jacksym_release_timebase)(jack_client_t*);

  625. +typedef int (JACKSYM_API *jacksym_set_sync_callback)(jack_client_t*, JackSymSyncCallback, void*);

  626. +typedef int (JACKSYM_API *jacksym_set_sync_timeout)(jack_client_t*, jack_time_t);

  627. +typedef int (JACKSYM_API *jacksym_set_timebase_callback)(jack_client_t*, int, JackSymTimebaseCallback, void*);

  628. +typedef int (JACKSYM_API *jacksym_transport_locate)(jack_client_t*, jack_nframes_t);

  629. +

  630. +typedef jack_transport_state_t (JACKSYM_API *jacksym_transport_query)(const jack_client_t*, jack_position_t*);

  631. +typedef jack_nframes_t         (JACKSYM_API *jacksym_get_current_transport_frame)(const jack_client_t*);

  632. +

  633. +typedef int  (JACKSYM_API *jacksym_transport_reposition)(jack_client_t*, const jack_position_t*);

  634. +typedef void (JACKSYM_API *jacksym_transport_start)(jack_client_t*);

  635. +typedef void (JACKSYM_API *jacksym_transport_stop)(jack_client_t*);

  636. +

  637. +typedef int  (JACKSYM_API *jacksym_set_property)(jack_client_t*, jack_uuid_t, const char*, const char*, const char*);

  638. +typedef int  (JACKSYM_API *jacksym_get_property)(jack_uuid_t, const char*, char**, char**);

  639. +typedef void (JACKSYM_API *jacksym_free_description)(jack_description_t*, int);

  640. +typedef int  (JACKSYM_API *jacksym_get_properties)(jack_uuid_t, jack_description_t*);

  641. +typedef int  (JACKSYM_API *jacksym_get_all_properties)(jack_description_t**);

  642. +typedef int  (JACKSYM_API *jacksym_remove_property)(jack_client_t*, jack_uuid_t, const char*);

  643. +typedef int  (JACKSYM_API *jacksym_remove_properties)(jack_client_t*, jack_uuid_t);

  644. +typedef int  (JACKSYM_API *jacksym_remove_all_properties)(jack_client_t*);

  645. +typedef int  (JACKSYM_API *jacksym_set_property_change_callback)(jack_client_t*, JackSymPropertyChangeCallback, void*);

  646. +

  647. +typedef bool           (JACKSYM_API *jacksym_set_process_thread)(jack_client_t*, JackSymThreadCallback callback, void*);

  648. +typedef jack_nframes_t (JACKSYM_API *jacksym_cycle_wait)(jack_client_t*);

  649. +typedef void           (JACKSYM_API *jacksym_cycle_signal)(jack_client_t*, int);

  650. +

  651. +typedef jack_nframes_t (JACKSYM_API *jacksym_port_get_latency)(jack_port_t*);

  652. +typedef jack_nframes_t (JACKSYM_API *jacksym_frame_time)(const jack_client_t*);

  653. +

  654. +// -----------------------------------------------------------------------------

  655. +

  656. +typedef struct JackBridge {

  657. +    lib_t lib;

  658. +

  659. +    jacksym_get_version get_version_ptr;

  660. +    jacksym_get_version_string get_version_string_ptr;

  661. +

  662. +    jacksym_client_open client_open_ptr;

  663. +    jacksym_client_close client_close_ptr;

  664. +

  665. +    jacksym_client_name_size client_name_size_ptr;

  666. +    jacksym_get_client_name get_client_name_ptr;

  667. +

  668. +    jacksym_client_get_uuid client_get_uuid_ptr;

  669. +    jacksym_get_uuid_for_client_name get_uuid_for_client_name_ptr;

  670. +    jacksym_get_client_name_by_uuid get_client_name_by_uuid_ptr;

  671. +

  672. +    jacksym_uuid_parse uuid_parse_ptr;

  673. +    jacksym_uuid_unparse uuid_unparse_ptr;

  674. +

  675. +    jacksym_activate activate_ptr;

  676. +    jacksym_deactivate deactivate_ptr;

  677. +    jacksym_is_realtime is_realtime_ptr;

  678. +

  679. +    jacksym_set_thread_init_callback set_thread_init_callback_ptr;

  680. +    jacksym_on_shutdown on_shutdown_ptr;

  681. +    jacksym_on_info_shutdown on_info_shutdown_ptr;

  682. +    jacksym_set_process_callback set_process_callback_ptr;

  683. +    jacksym_set_freewheel_callback set_freewheel_callback_ptr;

  684. +    jacksym_set_buffer_size_callback set_buffer_size_callback_ptr;

  685. +    jacksym_set_sample_rate_callback set_sample_rate_callback_ptr;

  686. +    jacksym_set_client_registration_callback set_client_registration_callback_ptr;

  687. +    jacksym_set_port_registration_callback set_port_registration_callback_ptr;

  688. +    jacksym_set_port_rename_callback set_port_rename_callback_ptr;

  689. +    jacksym_set_port_connect_callback set_port_connect_callback_ptr;

  690. +    jacksym_set_graph_order_callback set_graph_order_callback_ptr;

  691. +    jacksym_set_xrun_callback set_xrun_callback_ptr;

  692. +    jacksym_set_latency_callback set_latency_callback_ptr;

  693. +

  694. +    jacksym_set_freewheel set_freewheel_ptr;

  695. +    jacksym_set_buffer_size set_buffer_size_ptr;

  696. +

  697. +    jacksym_get_sample_rate get_sample_rate_ptr;

  698. +    jacksym_get_buffer_size get_buffer_size_ptr;

  699. +    jacksym_cpu_load cpu_load_ptr;

  700. +

  701. +    jacksym_port_register port_register_ptr;

  702. +    jacksym_port_unregister port_unregister_ptr;

  703. +    jacksym_port_get_buffer port_get_buffer_ptr;

  704. +

  705. +    jacksym_port_name port_name_ptr;

  706. +    jacksym_port_uuid port_uuid_ptr;

  707. +    jacksym_port_short_name port_short_name_ptr;

  708. +    jacksym_port_flags port_flags_ptr;

  709. +    jacksym_port_type port_type_ptr;

  710. +    jacksym_port_is_mine port_is_mine_ptr;

  711. +    jacksym_port_connected port_connected_ptr;

  712. +    jacksym_port_connected_to port_connected_to_ptr;

  713. +    jacksym_port_get_connections port_get_connections_ptr;

  714. +    jacksym_port_get_all_connections port_get_all_connections_ptr;

  715. +

  716. +    jacksym_port_rename port_rename_ptr;

  717. +    jacksym_port_set_name port_set_name_ptr;

  718. +    jacksym_port_set_alias port_set_alias_ptr;

  719. +    jacksym_port_unset_alias port_unset_alias_ptr;

  720. +    jacksym_port_get_aliases port_get_aliases_ptr;

  721. +

  722. +    jacksym_port_request_monitor port_request_monitor_ptr;

  723. +    jacksym_port_request_monitor_by_name port_request_monitor_by_name_ptr;

  724. +    jacksym_port_ensure_monitor port_ensure_monitor_ptr;

  725. +    jacksym_port_monitoring_input port_monitoring_input_ptr;

  726. +

  727. +    jacksym_connect connect_ptr;

  728. +    jacksym_disconnect disconnect_ptr;

  729. +    jacksym_port_disconnect port_disconnect_ptr;

  730. +

  731. +    jacksym_port_name_size port_name_size_ptr;

  732. +    jacksym_port_type_size port_type_size_ptr;

  733. +    jacksym_port_type_get_buffer_size port_type_get_buffer_size_ptr;

  734. +

  735. +    jacksym_port_get_latency_range port_get_latency_range_ptr;

  736. +    jacksym_port_set_latency_range port_set_latency_range_ptr;

  737. +    jacksym_recompute_total_latencies recompute_total_latencies_ptr;

  738. +

  739. +    jacksym_get_ports get_ports_ptr;

  740. +    jacksym_port_by_name port_by_name_ptr;

  741. +    jacksym_port_by_id port_by_id_ptr;

  742. +

  743. +    jacksym_free free_ptr;

  744. +

  745. +    jacksym_midi_get_event_count midi_get_event_count_ptr;

  746. +    jacksym_midi_event_get midi_event_get_ptr;

  747. +    jacksym_midi_clear_buffer midi_clear_buffer_ptr;

  748. +    jacksym_midi_event_write midi_event_write_ptr;

  749. +    jacksym_midi_event_reserve midi_event_reserve_ptr;

  750. +

  751. +    jacksym_release_timebase release_timebase_ptr;

  752. +    jacksym_set_sync_callback set_sync_callback_ptr;

  753. +    jacksym_set_sync_timeout set_sync_timeout_ptr;

  754. +    jacksym_set_timebase_callback set_timebase_callback_ptr;

  755. +    jacksym_transport_locate transport_locate_ptr;

  756. +

  757. +    jacksym_transport_query transport_query_ptr;

  758. +    jacksym_get_current_transport_frame get_current_transport_frame_ptr;

  759. +

  760. +    jacksym_transport_reposition transport_reposition_ptr;

  761. +    jacksym_transport_start transport_start_ptr;

  762. +    jacksym_transport_stop transport_stop_ptr;

  763. +

  764. +    jacksym_set_property set_property_ptr;

  765. +    jacksym_get_property get_property_ptr;

  766. +    jacksym_free_description free_description_ptr;

  767. +    jacksym_get_properties get_properties_ptr;

  768. +    jacksym_get_all_properties get_all_properties_ptr;

  769. +    jacksym_remove_property remove_property_ptr;

  770. +    jacksym_remove_properties remove_properties_ptr;

  771. +    jacksym_remove_all_properties remove_all_properties_ptr;

  772. +    jacksym_set_property_change_callback set_property_change_callback_ptr;

  773. +

  774. +    jacksym_set_process_thread set_process_thread_ptr;

  775. +    jacksym_cycle_wait cycle_wait_ptr;

  776. +    jacksym_cycle_signal cycle_signal_ptr;

  777. +

  778. +    jacksym_port_get_latency port_get_latency_ptr;

  779. +    jacksym_frame_time frame_time_ptr;

  780. +} JackBridge;

  781. +

  782. +static void jackbridge_init(JackBridge* const bridge)

  783. +{

  784. +    memset(bridge, 0, sizeof(*bridge));

  785. +

  786. +#if !(defined(JACKBRIDGE_DUMMY) || defined(JACKBRIDGE_DIRECT))

  787. +   #if defined(__APPLE__)

  788. +    const char* const filename = "libjack.dylib";

  789. +   #elif defined(_WIN64)

  790. +    const char* const filename = "libjack64.dll";

  791. +   #elif defined(_WIN32)

  792. +    const char* const filename = "libjack.dll";

  793. +   #else

  794. +    const char* const filename = "libjack.so.0";

  795. +   #endif

  796. +

  797. +    void* const lib = dlopen(filename, RTLD_NOW|RTLD_LOCAL);

  798. +

  799. +    if (lib == NULL)

  800. +    {

  801. +        fprintf(stderr, "Failed to load JACK DLL, reason:\n%s\n", dlerror());

  802. +        return;

  803. +    }

  804. +    else

  805. +    {

  806. +        fprintf(stdout, "%s loaded successfully!\n", filename);

  807. +    }

  808. +

  809. +    #define JOIN(a, b) a ## b

  810. +    #define LIB_SYMBOL(NAME) bridge->JOIN(NAME, _ptr) = (jacksym_##NAME)dlsym(lib, "jack_" #NAME);

  811. +

  812. +    LIB_SYMBOL(get_version)

  813. +    LIB_SYMBOL(get_version_string)

  814. +

  815. +    LIB_SYMBOL(client_open)

  816. +    LIB_SYMBOL(client_close)

  817. +

  818. +    LIB_SYMBOL(client_name_size)

  819. +    LIB_SYMBOL(get_client_name)

  820. +

  821. +    LIB_SYMBOL(client_get_uuid)

  822. +    LIB_SYMBOL(get_uuid_for_client_name)

  823. +    LIB_SYMBOL(get_client_name_by_uuid)

  824. +

  825. +    LIB_SYMBOL(uuid_parse)

  826. +    LIB_SYMBOL(uuid_unparse)

  827. +

  828. +    LIB_SYMBOL(activate)

  829. +    LIB_SYMBOL(deactivate)

  830. +    LIB_SYMBOL(is_realtime)

  831. +

  832. +    LIB_SYMBOL(set_thread_init_callback)

  833. +    LIB_SYMBOL(on_shutdown)

  834. +    LIB_SYMBOL(on_info_shutdown)

  835. +    LIB_SYMBOL(set_process_callback)

  836. +    LIB_SYMBOL(set_freewheel_callback)

  837. +    LIB_SYMBOL(set_buffer_size_callback)

  838. +    LIB_SYMBOL(set_sample_rate_callback)

  839. +    LIB_SYMBOL(set_client_registration_callback)

  840. +    LIB_SYMBOL(set_port_registration_callback)

  841. +    LIB_SYMBOL(set_port_rename_callback)

  842. +    LIB_SYMBOL(set_port_connect_callback)

  843. +    LIB_SYMBOL(set_graph_order_callback)

  844. +    LIB_SYMBOL(set_xrun_callback)

  845. +    LIB_SYMBOL(set_latency_callback)

  846. +

  847. +    LIB_SYMBOL(set_freewheel)

  848. +    LIB_SYMBOL(set_buffer_size)

  849. +

  850. +    LIB_SYMBOL(get_sample_rate)

  851. +    LIB_SYMBOL(get_buffer_size)

  852. +    LIB_SYMBOL(cpu_load)

  853. +

  854. +    LIB_SYMBOL(port_register)

  855. +    LIB_SYMBOL(port_unregister)

  856. +    LIB_SYMBOL(port_get_buffer)

  857. +

  858. +    LIB_SYMBOL(port_name)

  859. +    LIB_SYMBOL(port_uuid)

  860. +    LIB_SYMBOL(port_short_name)

  861. +    LIB_SYMBOL(port_flags)

  862. +    LIB_SYMBOL(port_type)

  863. +    LIB_SYMBOL(port_is_mine)

  864. +    LIB_SYMBOL(port_connected)

  865. +    LIB_SYMBOL(port_connected_to)

  866. +    LIB_SYMBOL(port_get_connections)

  867. +    LIB_SYMBOL(port_get_all_connections)

  868. +

  869. +    LIB_SYMBOL(port_rename)

  870. +    LIB_SYMBOL(port_set_name)

  871. +    LIB_SYMBOL(port_set_alias)

  872. +    LIB_SYMBOL(port_unset_alias)

  873. +    LIB_SYMBOL(port_get_aliases)

  874. +

  875. +    LIB_SYMBOL(port_request_monitor)

  876. +    LIB_SYMBOL(port_request_monitor_by_name)

  877. +    LIB_SYMBOL(port_ensure_monitor)

  878. +    LIB_SYMBOL(port_monitoring_input)

  879. +

  880. +    LIB_SYMBOL(connect)

  881. +    LIB_SYMBOL(disconnect)

  882. +    LIB_SYMBOL(port_disconnect)

  883. +

  884. +    LIB_SYMBOL(port_name_size)

  885. +    LIB_SYMBOL(port_type_size)

  886. +    LIB_SYMBOL(port_type_get_buffer_size)

  887. +

  888. +    LIB_SYMBOL(port_get_latency_range)

  889. +    LIB_SYMBOL(port_set_latency_range)

  890. +    LIB_SYMBOL(recompute_total_latencies)

  891. +

  892. +    LIB_SYMBOL(get_ports)

  893. +    LIB_SYMBOL(port_by_name)

  894. +    LIB_SYMBOL(port_by_id)

  895. +

  896. +    LIB_SYMBOL(free)

  897. +

  898. +    LIB_SYMBOL(midi_get_event_count)

  899. +    LIB_SYMBOL(midi_event_get)

  900. +    LIB_SYMBOL(midi_clear_buffer)

  901. +    LIB_SYMBOL(midi_event_write)

  902. +    LIB_SYMBOL(midi_event_reserve)

  903. +

  904. +    LIB_SYMBOL(release_timebase)

  905. +    LIB_SYMBOL(set_sync_callback)

  906. +    LIB_SYMBOL(set_sync_timeout)

  907. +    LIB_SYMBOL(set_timebase_callback)

  908. +    LIB_SYMBOL(transport_locate)

  909. +    LIB_SYMBOL(transport_query)

  910. +    LIB_SYMBOL(get_current_transport_frame)

  911. +    LIB_SYMBOL(transport_reposition)

  912. +    LIB_SYMBOL(transport_start)

  913. +    LIB_SYMBOL(transport_stop)

  914. +

  915. +    LIB_SYMBOL(set_property)

  916. +    LIB_SYMBOL(get_property)

  917. +    LIB_SYMBOL(free_description)

  918. +    LIB_SYMBOL(get_properties)

  919. +    LIB_SYMBOL(get_all_properties)

  920. +    LIB_SYMBOL(remove_property)

  921. +    LIB_SYMBOL(remove_properties)

  922. +    LIB_SYMBOL(remove_all_properties)

  923. +    LIB_SYMBOL(set_property_change_callback)

  924. +

  925. +    LIB_SYMBOL(set_process_thread)

  926. +    LIB_SYMBOL(cycle_wait)

  927. +    LIB_SYMBOL(cycle_signal)

  928. +

  929. +    LIB_SYMBOL(port_get_latency)

  930. +    LIB_SYMBOL(frame_time)

  931. +

  932. +    #undef JOIN

  933. +    #undef LIB_SYMBOL

  934. +

  935. +    bridge->lib = lib;

  936. +#endif

  937. +}

  938. +

  939. +static void jackbridge_destroy(JackBridge* const bridge)

  940. +{

  941. +    if (bridge->lib != NULL)

  942. +    {

  943. +        dlclose(bridge->lib);

  944. +        bridge->lib = NULL;

  945. +    }

  946. +}

  947. +

  948. +static JackBridge* jackbridge_instance()

  949. +{

  950. +    static JackBridge bridge;

  951. +    static bool init = false;

  952. +    if (! init)

  953. +    {

  954. +        init = true;

  955. +        jackbridge_init(&bridge);

  956. +    }

  957. +    return &bridge;

  958. +}

  959. +

  960. +// -----------------------------------------------------------------------------

  961. +

  962. +bool jackbridge_is_ok()

  963. +{

  964. +#if defined(JACKBRIDGE_DUMMY)

  965. +    return false;

  966. +#elif defined(JACKBRIDGE_DIRECT)

  967. +    return true;

  968. +#else

  969. +    return jackbridge_instance()->lib != NULL;

  970. +#endif

  971. +}

  972. +

  973. +// -----------------------------------------------------------------------------

  974. +

  975. +void jackbridge_get_version(int* major_ptr, int* minor_ptr, int* micro_ptr, int* proto_ptr)

  976. +{

  977. +#if defined(JACKBRIDGE_DUMMY)

  978. +#elif defined(JACKBRIDGE_DIRECT)

  979. +    return jack_get_version(major_ptr, minor_ptr, micro_ptr, proto_ptr);

  980. +#else

  981. +    if (jackbridge_instance()->get_version_ptr != NULL)

  982. +        return jackbridge_instance()->get_version_ptr(major_ptr, minor_ptr, micro_ptr, proto_ptr);

  983. +#endif

  984. +    if (major_ptr != NULL)

  985. +        *major_ptr = 0;

  986. +    if (minor_ptr != NULL)

  987. +        *minor_ptr = 0;

  988. +    if (micro_ptr != NULL)

  989. +        *micro_ptr = 0;

  990. +    if (proto_ptr != NULL)

  991. +        *proto_ptr = 0;

  992. +}

  993. +

  994. +const char* jackbridge_get_version_string()

  995. +{

  996. +#if defined(JACKBRIDGE_DUMMY)

  997. +#elif defined(JACKBRIDGE_DIRECT)

  998. +    return jack_get_version_string();

  999. +#else

  1000. +    if (jackbridge_instance()->get_version_string_ptr != NULL)

  1001. +        return jackbridge_instance()->get_version_string_ptr();

  1002. +#endif

  1003. +    return NULL;

  1004. +}

  1005. +

  1006. +// -----------------------------------------------------------------------------

  1007. +

  1008. +jack_client_t* jackbridge_client_open(const char* client_name, uint32_t options, jack_status_t* status)

  1009. +{

  1010. +#if defined(JACKBRIDGE_DUMMY)

  1011. +#elif defined(JACKBRIDGE_DIRECT)

  1012. +    return jack_client_open(client_name, (jack_options_t)options, status);

  1013. +#endif

  1014. +    if (jackbridge_instance()->client_open_ptr != NULL)

  1015. +        return jackbridge_instance()->client_open_ptr(client_name, (jack_options_t)options, status);

  1016. +    if (status != NULL)

  1017. +        *status = JackServerError;

  1018. +    return NULL;

  1019. +}

  1020. +

  1021. +bool jackbridge_client_close(jack_client_t* client)

  1022. +{

  1023. +#if defined(JACKBRIDGE_DUMMY)

  1024. +#elif defined(JACKBRIDGE_DIRECT)

  1025. +    return (jack_client_close(client) == 0);

  1026. +#else

  1027. +    if (jackbridge_instance()->client_close_ptr != NULL)

  1028. +        return (jackbridge_instance()->client_close_ptr(client) == 0);

  1029. +#endif

  1030. +    return false;

  1031. +}

  1032. +

  1033. +// -----------------------------------------------------------------------------

  1034. +

  1035. +int jackbridge_client_name_size()

  1036. +{

  1037. +#if defined(JACKBRIDGE_DUMMY)

  1038. +#elif defined(JACKBRIDGE_DIRECT)

  1039. +    return jack_client_name_size();

  1040. +#else

  1041. +    if (jackbridge_instance()->client_name_size_ptr != NULL)

  1042. +        return jackbridge_instance()->client_name_size_ptr();

  1043. +#endif

  1044. +    return 33;

  1045. +}

  1046. +

  1047. +const char* jackbridge_get_client_name(jack_client_t* client)

  1048. +{

  1049. +#if defined(JACKBRIDGE_DUMMY)

  1050. +#elif defined(JACKBRIDGE_DIRECT)

  1051. +    return jack_get_client_name(client);

  1052. +#else

  1053. +    if (jackbridge_instance()->get_client_name_ptr != NULL)

  1054. +        return jackbridge_instance()->get_client_name_ptr(client);

  1055. +#endif

  1056. +    return NULL;

  1057. +}

  1058. +

  1059. +// -----------------------------------------------------------------------------

  1060. +

  1061. +char* jackbridge_client_get_uuid(jack_client_t* client)

  1062. +{

  1063. +#if defined(JACKBRIDGE_DUMMY)

  1064. +#elif defined(JACKBRIDGE_DIRECT)

  1065. +    return jack_client_get_uuid(client);

  1066. +#else

  1067. +    if (jackbridge_instance()->client_get_uuid_ptr != NULL)

  1068. +        return jackbridge_instance()->client_get_uuid_ptr(client);

  1069. +#endif

  1070. +    return NULL;

  1071. +}

  1072. +

  1073. +char* jackbridge_get_uuid_for_client_name(jack_client_t* client, const char* name)

  1074. +{

  1075. +#if defined(JACKBRIDGE_DUMMY)

  1076. +#elif defined(JACKBRIDGE_DIRECT)

  1077. +    return jack_get_uuid_for_client_name(client, name);

  1078. +#else

  1079. +    if (jackbridge_instance()->get_uuid_for_client_name_ptr != NULL)

  1080. +        return jackbridge_instance()->get_uuid_for_client_name_ptr(client, name);

  1081. +#endif

  1082. +    return NULL;

  1083. +}

  1084. +

  1085. +char* jackbridge_get_client_name_by_uuid(jack_client_t* client, const char* uuid)

  1086. +{

  1087. +#if defined(JACKBRIDGE_DUMMY)

  1088. +#elif defined(JACKBRIDGE_DIRECT)

  1089. +    return jack_get_client_name_by_uuid(client, uuid);

  1090. +#else

  1091. +    if (jackbridge_instance()->get_client_name_by_uuid_ptr != NULL)

  1092. +        return jackbridge_instance()->get_client_name_by_uuid_ptr(client, uuid);

  1093. +#endif

  1094. +    return NULL;

  1095. +}

  1096. +

  1097. +// -----------------------------------------------------------------------------

  1098. +

  1099. +bool jackbridge_uuid_parse(const char* buf, jack_uuid_t* uuid)

  1100. +{

  1101. +#if defined(JACKBRIDGE_DUMMY)

  1102. +#elif defined(JACKBRIDGE_DIRECT)

  1103. +    return (jack_uuid_parse(buf, uuid) == 0);

  1104. +#else

  1105. +    if (jackbridge_instance()->uuid_parse_ptr != NULL)

  1106. +        return jackbridge_instance()->uuid_parse_ptr(buf, uuid) == 0;

  1107. +#endif

  1108. +    return false;

  1109. +}

  1110. +

  1111. +void jackbridge_uuid_unparse(jack_uuid_t uuid, char buf[JACK_UUID_STRING_SIZE])

  1112. +{

  1113. +#if defined(JACKBRIDGE_DUMMY)

  1114. +#elif defined(JACKBRIDGE_DIRECT)

  1115. +    jack_uuid_unparse(uuid, buf);

  1116. +#else

  1117. +    if (jackbridge_instance()->uuid_unparse_ptr != NULL)

  1118. +        return jackbridge_instance()->uuid_unparse_ptr(uuid, buf);

  1119. +#endif

  1120. +}

  1121. +

  1122. +// -----------------------------------------------------------------------------

  1123. +

  1124. +bool jackbridge_activate(jack_client_t* client)

  1125. +{

  1126. +#if defined(JACKBRIDGE_DUMMY)

  1127. +#elif defined(JACKBRIDGE_DIRECT)

  1128. +    return (jack_activate(client) == 0);

  1129. +#else

  1130. +    if (jackbridge_instance()->activate_ptr != NULL)

  1131. +        return (jackbridge_instance()->activate_ptr(client) == 0);

  1132. +#endif

  1133. +    return false;

  1134. +}

  1135. +

  1136. +bool jackbridge_deactivate(jack_client_t* client)

  1137. +{

  1138. +#if defined(JACKBRIDGE_DUMMY)

  1139. +#elif defined(JACKBRIDGE_DIRECT)

  1140. +    return (jack_deactivate(client) == 0);

  1141. +#else

  1142. +    if (jackbridge_instance()->deactivate_ptr != NULL)

  1143. +        return (jackbridge_instance()->deactivate_ptr(client) == 0);

  1144. +#endif

  1145. +    return false;

  1146. +}

  1147. +

  1148. +bool jackbridge_is_realtime(jack_client_t* client)

  1149. +{

  1150. +#if defined(JACKBRIDGE_DUMMY)

  1151. +#elif defined(JACKBRIDGE_DIRECT)

  1152. +    return jack_is_realtime(client);

  1153. +#else

  1154. +    if (jackbridge_instance()->is_realtime_ptr != NULL)

  1155. +        return jackbridge_instance()->is_realtime_ptr(client);

  1156. +#endif

  1157. +    return false;

  1158. +}

  1159. +

  1160. +// -----------------------------------------------------------------------------

  1161. +

  1162. +bool jackbridge_set_thread_init_callback(jack_client_t* client, JackThreadInitCallback thread_init_callback, void* arg)

  1163. +{

  1164. +#if defined(JACKBRIDGE_DUMMY)

  1165. +#elif defined(JACKBRIDGE_DIRECT)

  1166. +    return (jack_set_thread_init_callback(client, thread_init_callback, arg) == 0);

  1167. +#else

  1168. +    if (jackbridge_instance()->set_thread_init_callback_ptr != NULL)

  1169. +    {

  1170. +# ifdef __WINE__

  1171. +        WineBridge::getInstance().set_thread_init(thread_init_callback);

  1172. +        return (jackbridge_instance()->set_thread_init_callback_ptr(client, WineBridge::thread_init, arg) == 0);

  1173. +# else

  1174. +        return (jackbridge_instance()->set_thread_init_callback_ptr(client, thread_init_callback, arg) == 0);

  1175. +# endif

  1176. +    }

  1177. +#endif

  1178. +    return false;

  1179. +}

  1180. +

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

  1182. +{

  1183. +#if defined(JACKBRIDGE_DUMMY)

  1184. +#elif defined(JACKBRIDGE_DIRECT)

  1185. +    jack_on_shutdown(client, shutdown_callback, arg);

  1186. +#else

  1187. +    if (jackbridge_instance()->on_shutdown_ptr != NULL)

  1188. +    {

  1189. +# ifdef __WINE__

  1190. +        WineBridge::getInstance().set_shutdown(shutdown_callback);

  1191. +        jackbridge_instance()->on_shutdown_ptr(client, WineBridge::shutdown, arg);

  1192. +# else

  1193. +        jackbridge_instance()->on_shutdown_ptr(client, shutdown_callback, arg);

  1194. +# endif

  1195. +    }

  1196. +#endif

  1197. +}

  1198. +

  1199. +void jackbridge_on_info_shutdown(jack_client_t* client, JackInfoShutdownCallback shutdown_callback, void* arg)

  1200. +{

  1201. +#if defined(JACKBRIDGE_DUMMY)

  1202. +#elif defined(JACKBRIDGE_DIRECT)

  1203. +    jack_on_info_shutdown(client, shutdown_callback, arg);

  1204. +#else

  1205. +    if (jackbridge_instance()->on_info_shutdown_ptr != NULL)

  1206. +    {

  1207. +# ifdef __WINE__

  1208. +        WineBridge::getInstance().set_info_shutdown(shutdown_callback);

  1209. +        jackbridge_instance()->on_info_shutdown_ptr(client, WineBridge::info_shutdown, arg);

  1210. +# else

  1211. +        jackbridge_instance()->on_info_shutdown_ptr(client, shutdown_callback, arg);

  1212. +# endif

  1213. +    }

  1214. +#endif

  1215. +}

  1216. +

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

  1218. +{

  1219. +#if defined(JACKBRIDGE_DUMMY)

  1220. +#elif defined(JACKBRIDGE_DIRECT)

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

  1222. +#else

  1223. +    if (jackbridge_instance()->set_process_callback_ptr != NULL)

  1224. +    {

  1225. +# ifdef __WINE__

  1226. +        WineBridge::getInstance().set_process(process_callback);

  1227. +        return (jackbridge_instance()->set_process_callback_ptr(client, WineBridge::process, arg) == 0);

  1228. +# else

  1229. +        return (jackbridge_instance()->set_process_callback_ptr(client, process_callback, arg) == 0);

  1230. +# endif

  1231. +    }

  1232. +#endif

  1233. +    return false;

  1234. +}

  1235. +

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

  1237. +{

  1238. +#if defined(JACKBRIDGE_DUMMY)

  1239. +#elif defined(JACKBRIDGE_DIRECT)

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

  1241. +#else

  1242. +    if (jackbridge_instance()->set_freewheel_callback_ptr != NULL)

  1243. +    {

  1244. +# ifdef __WINE__

  1245. +        WineBridge::getInstance().set_freewheel(freewheel_callback);

  1246. +        return (jackbridge_instance()->set_freewheel_callback_ptr(client, WineBridge::freewheel, arg) == 0);

  1247. +# else

  1248. +        return (jackbridge_instance()->set_freewheel_callback_ptr(client, freewheel_callback, arg) == 0);

  1249. +# endif

  1250. +    }

  1251. +#endif

  1252. +    return false;

  1253. +}

  1254. +

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

  1256. +{

  1257. +#if defined(JACKBRIDGE_DUMMY)

  1258. +#elif defined(JACKBRIDGE_DIRECT)

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

  1260. +#else

  1261. +    if (jackbridge_instance()->set_buffer_size_callback_ptr != NULL)

  1262. +    {

  1263. +# ifdef __WINE__

  1264. +        WineBridge::getInstance().set_bufsize(bufsize_callback);

  1265. +        return (jackbridge_instance()->set_buffer_size_callback_ptr(client, WineBridge::bufsize, arg) == 0);

  1266. +# else

  1267. +        return (jackbridge_instance()->set_buffer_size_callback_ptr(client, bufsize_callback, arg) == 0);

  1268. +# endif

  1269. +    }

  1270. +#endif

  1271. +    return false;

  1272. +}

  1273. +

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

  1275. +{

  1276. +#if defined(JACKBRIDGE_DUMMY)

  1277. +#elif defined(JACKBRIDGE_DIRECT)

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

  1279. +#else

  1280. +    if (jackbridge_instance()->set_sample_rate_callback_ptr != NULL)

  1281. +    {

  1282. +# ifdef __WINE__

  1283. +        WineBridge::getInstance().set_srate(srate_callback);

  1284. +        return (jackbridge_instance()->set_sample_rate_callback_ptr(client, WineBridge::srate, arg) == 0);

  1285. +# else

  1286. +        return (jackbridge_instance()->set_sample_rate_callback_ptr(client, srate_callback, arg) == 0);

  1287. +# endif

  1288. +    }

  1289. +#endif

  1290. +    return false;

  1291. +}

  1292. +

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

  1294. +{

  1295. +#if defined(JACKBRIDGE_DUMMY)

  1296. +#elif defined(JACKBRIDGE_DIRECT)

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

  1298. +#else

  1299. +    if (jackbridge_instance()->set_client_registration_callback_ptr != NULL)

  1300. +    {

  1301. +# ifdef __WINE__

  1302. +        WineBridge::getInstance().set_client_reg(registration_callback);

  1303. +        return (jackbridge_instance()->set_client_registration_callback_ptr(client, WineBridge::client_reg, arg) == 0);

  1304. +# else

  1305. +        return (jackbridge_instance()->set_client_registration_callback_ptr(client, registration_callback, arg) == 0);

  1306. +# endif

  1307. +    }

  1308. +#endif

  1309. +    return false;

  1310. +}

  1311. +

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

  1313. +{

  1314. +#if defined(JACKBRIDGE_DUMMY)

  1315. +#elif defined(JACKBRIDGE_DIRECT)

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

  1317. +#else

  1318. +    if (jackbridge_instance()->set_port_registration_callback_ptr != NULL)

  1319. +    {

  1320. +# ifdef __WINE__

  1321. +        WineBridge::getInstance().set_port_reg(registration_callback);

  1322. +        return (jackbridge_instance()->set_port_registration_callback_ptr(client, WineBridge::port_reg, arg) == 0);

  1323. +# else

  1324. +        return (jackbridge_instance()->set_port_registration_callback_ptr(client, registration_callback, arg) == 0);

  1325. +# endif

  1326. +    }

  1327. +#endif

  1328. +    return false;

  1329. +}

  1330. +

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

  1332. +{

  1333. +#if defined(JACKBRIDGE_DUMMY)

  1334. +#elif defined(JACKBRIDGE_DIRECT)

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

  1336. +#else

  1337. +    if (jackbridge_instance()->set_port_rename_callback_ptr != NULL)

  1338. +    {

  1339. +# ifdef __WINE__

  1340. +        WineBridge::getInstance().set_port_rename(rename_callback);

  1341. +        return (jackbridge_instance()->set_port_rename_callback_ptr(client, WineBridge::port_rename, arg) == 0);

  1342. +# else

  1343. +        return (jackbridge_instance()->set_port_rename_callback_ptr(client, rename_callback, arg) == 0);

  1344. +# endif

  1345. +    }

  1346. +#endif

  1347. +    return false;

  1348. +}

  1349. +

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

  1351. +{

  1352. +#if defined(JACKBRIDGE_DUMMY)

  1353. +#elif defined(JACKBRIDGE_DIRECT)

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

  1355. +#else

  1356. +    if (jackbridge_instance()->set_port_connect_callback_ptr != NULL)

  1357. +    {

  1358. +# ifdef __WINE__

  1359. +        WineBridge::getInstance().set_port_conn(connect_callback);

  1360. +        return (jackbridge_instance()->set_port_connect_callback_ptr(client, WineBridge::port_conn, arg) == 0);

  1361. +# else

  1362. +        return (jackbridge_instance()->set_port_connect_callback_ptr(client, connect_callback, arg) == 0);

  1363. +# endif

  1364. +    }

  1365. +#endif

  1366. +    return false;

  1367. +}

  1368. +

  1369. +bool jackbridge_set_graph_order_callback(jack_client_t* client, JackGraphOrderCallback graph_callback, void* arg)

  1370. +{

  1371. +#if defined(JACKBRIDGE_DUMMY)

  1372. +#elif defined(JACKBRIDGE_DIRECT)

  1373. +    return (jack_set_graph_order_callback(client, graph_callback, arg) == 0);

  1374. +#else

  1375. +    if (jackbridge_instance()->set_graph_order_callback_ptr != NULL)

  1376. +    {

  1377. +# ifdef __WINE__

  1378. +        WineBridge::getInstance().set_graph_order(graph_callback);

  1379. +        return (jackbridge_instance()->set_graph_order_callback_ptr(client, WineBridge::graph_order, arg) == 0);

  1380. +# else

  1381. +        return (jackbridge_instance()->set_graph_order_callback_ptr(client, graph_callback, arg) == 0);

  1382. +# endif

  1383. +    }

  1384. +#endif

  1385. +    return false;

  1386. +}

  1387. +

  1388. +bool jackbridge_set_xrun_callback(jack_client_t* client, JackXRunCallback xrun_callback, void* arg)

  1389. +{

  1390. +#if defined(JACKBRIDGE_DUMMY)

  1391. +#elif defined(JACKBRIDGE_DIRECT)

  1392. +    return (jack_set_xrun_callback(client, xrun_callback, arg) == 0);

  1393. +#else

  1394. +    if (jackbridge_instance()->set_xrun_callback_ptr != NULL)

  1395. +    {

  1396. +# ifdef __WINE__

  1397. +        WineBridge::getInstance().set_xrun(xrun_callback);

  1398. +        return (jackbridge_instance()->set_xrun_callback_ptr(client, WineBridge::xrun, arg) == 0);

  1399. +# else

  1400. +        return (jackbridge_instance()->set_xrun_callback_ptr(client, xrun_callback, arg) == 0);

  1401. +# endif

  1402. +    }

  1403. +#endif

  1404. +    return false;

  1405. +}

  1406. +

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

  1408. +{

  1409. +#if defined(JACKBRIDGE_DUMMY)

  1410. +#elif defined(JACKBRIDGE_DIRECT)

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

  1412. +#else

  1413. +    if (jackbridge_instance()->set_latency_callback_ptr != NULL)

  1414. +    {

  1415. +# ifdef __WINE__

  1416. +        WineBridge::getInstance().set_latency(latency_callback);

  1417. +        return (jackbridge_instance()->set_latency_callback_ptr(client, WineBridge::latency, arg) == 0);

  1418. +# else

  1419. +        return (jackbridge_instance()->set_latency_callback_ptr(client, latency_callback, arg) == 0);

  1420. +# endif

  1421. +    }

  1422. +#endif

  1423. +    return false;

  1424. +}

  1425. +

  1426. +// -----------------------------------------------------------------------------

  1427. +

  1428. +bool jackbridge_set_freewheel(jack_client_t* client, bool onoff)

  1429. +{

  1430. +#if defined(JACKBRIDGE_DUMMY)

  1431. +#elif defined(JACKBRIDGE_DIRECT)

  1432. +    return jack_set_freewheel(client, onoff);

  1433. +#else

  1434. +    if (jackbridge_instance()->set_freewheel_ptr != NULL)

  1435. +        return jackbridge_instance()->set_freewheel_ptr(client, onoff);

  1436. +#endif

  1437. +    return false;

  1438. +}

  1439. +

  1440. +bool jackbridge_set_buffer_size(jack_client_t* client, jack_nframes_t nframes)

  1441. +{

  1442. +#if defined(JACKBRIDGE_DUMMY)

  1443. +#elif defined(JACKBRIDGE_DIRECT)

  1444. +    return jack_set_buffer_size(client, nframes);

  1445. +#else

  1446. +    if (jackbridge_instance()->set_buffer_size_ptr != NULL)

  1447. +        return jackbridge_instance()->set_buffer_size_ptr(client, nframes);

  1448. +#endif

  1449. +    return false;

  1450. +}

  1451. +

  1452. +// -----------------------------------------------------------------------------

  1453. +

  1454. +jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)

  1455. +{

  1456. +#if defined(JACKBRIDGE_DUMMY)

  1457. +#elif defined(JACKBRIDGE_DIRECT)

  1458. +    return jack_get_sample_rate(client);

  1459. +#else

  1460. +    if (jackbridge_instance()->get_sample_rate_ptr != NULL)

  1461. +        return jackbridge_instance()->get_sample_rate_ptr(client);

  1462. +#endif

  1463. +    return 0;

  1464. +}

  1465. +

  1466. +jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)

  1467. +{

  1468. +#if defined(JACKBRIDGE_DUMMY)

  1469. +#elif defined(JACKBRIDGE_DIRECT)

  1470. +    return jack_get_buffer_size(client);

  1471. +#else

  1472. +    if (jackbridge_instance()->get_buffer_size_ptr != NULL)

  1473. +        return jackbridge_instance()->get_buffer_size_ptr(client);

  1474. +#endif

  1475. +    return 0;

  1476. +}

  1477. +

  1478. +float jackbridge_cpu_load(jack_client_t* client)

  1479. +{

  1480. +#if defined(JACKBRIDGE_DUMMY)

  1481. +#elif defined(JACKBRIDGE_DIRECT)

  1482. +    return jack_cpu_load(client);

  1483. +#else

  1484. +    if (jackbridge_instance()->cpu_load_ptr != NULL)

  1485. +        return jackbridge_instance()->cpu_load_ptr(client);

  1486. +#endif

  1487. +    return 0.0f;

  1488. +}

  1489. +

  1490. +// -----------------------------------------------------------------------------

  1491. +

  1492. +jack_port_t* jackbridge_port_register(jack_client_t* client, const char* port_name, const char* type, uint64_t flags, uint64_t buffer_size)

  1493. +{

  1494. +#if defined(JACKBRIDGE_DUMMY)

  1495. +#elif defined(JACKBRIDGE_DIRECT)

  1496. +    return jack_port_register(client, port_name, type, flags, buffer_size);

  1497. +#else

  1498. +    if (jackbridge_instance()->port_register_ptr != NULL)

  1499. +        return jackbridge_instance()->port_register_ptr(client, port_name, type, (ulong)flags, (ulong)buffer_size);

  1500. +#endif

  1501. +    return NULL;

  1502. +}

  1503. +

  1504. +bool jackbridge_port_unregister(jack_client_t* client, jack_port_t* port)

  1505. +{

  1506. +#if defined(JACKBRIDGE_DUMMY)

  1507. +#elif defined(JACKBRIDGE_DIRECT)

  1508. +    return (jack_port_unregister(client, port) == 0);

  1509. +#else

  1510. +    if (jackbridge_instance()->port_unregister_ptr != NULL)

  1511. +        return (jackbridge_instance()->port_unregister_ptr(client, port) == 0);

  1512. +#endif

  1513. +    return false;

  1514. +}

  1515. +

  1516. +void* jackbridge_port_get_buffer(jack_port_t* port, jack_nframes_t nframes)

  1517. +{

  1518. +#if defined(JACKBRIDGE_DUMMY)

  1519. +#elif defined(JACKBRIDGE_DIRECT)

  1520. +    return jack_port_get_buffer(port, nframes);

  1521. +#else

  1522. +    if (jackbridge_instance()->port_get_buffer_ptr != NULL)

  1523. +        return jackbridge_instance()->port_get_buffer_ptr(port, nframes);

  1524. +#endif

  1525. +    return NULL;

  1526. +}

  1527. +

  1528. +// -----------------------------------------------------------------------------

  1529. +

  1530. +const char* jackbridge_port_name(const jack_port_t* port)

  1531. +{

  1532. +#if defined(JACKBRIDGE_DUMMY)

  1533. +#elif defined(JACKBRIDGE_DIRECT)

  1534. +    return jack_port_name(port);

  1535. +#else

  1536. +    if (jackbridge_instance()->port_name_ptr != NULL)

  1537. +        return jackbridge_instance()->port_name_ptr(port);

  1538. +#endif

  1539. +    return NULL;

  1540. +}

  1541. +

  1542. +jack_uuid_t jackbridge_port_uuid(const jack_port_t* port)

  1543. +{

  1544. +#if defined(JACKBRIDGE_DUMMY)

  1545. +#elif defined(JACKBRIDGE_DIRECT)

  1546. +    return jack_port_uuid(port);

  1547. +#else

  1548. +    if (jackbridge_instance()->port_uuid_ptr != NULL)

  1549. +        return jackbridge_instance()->port_uuid_ptr(port);

  1550. +#endif

  1551. +    return 0;

  1552. +}

  1553. +

  1554. +const char* jackbridge_port_short_name(const jack_port_t* port)

  1555. +{

  1556. +#if defined(JACKBRIDGE_DUMMY)

  1557. +#elif defined(JACKBRIDGE_DIRECT)

  1558. +    return jack_port_short_name(port);

  1559. +#else

  1560. +    if (jackbridge_instance()->port_short_name_ptr != NULL)

  1561. +        return jackbridge_instance()->port_short_name_ptr(port);

  1562. +#endif

  1563. +    return NULL;

  1564. +}

  1565. +

  1566. +int jackbridge_port_flags(const jack_port_t* port)

  1567. +{

  1568. +#if defined(JACKBRIDGE_DUMMY)

  1569. +#elif defined(JACKBRIDGE_DIRECT)

  1570. +    return jack_port_flags(port);

  1571. +#else

  1572. +    if (jackbridge_instance()->port_flags_ptr != NULL)

  1573. +        return jackbridge_instance()->port_flags_ptr(port);

  1574. +#endif

  1575. +    return 0x0;

  1576. +}

  1577. +

  1578. +const char* jackbridge_port_type(const jack_port_t* port)

  1579. +{

  1580. +#if defined(JACKBRIDGE_DUMMY)

  1581. +#elif defined(JACKBRIDGE_DIRECT)

  1582. +    return jack_port_type(port);

  1583. +#else

  1584. +    if (jackbridge_instance()->port_type_ptr != NULL)

  1585. +        return jackbridge_instance()->port_type_ptr(port);

  1586. +#endif

  1587. +    return NULL;

  1588. +}

  1589. +

  1590. +bool jackbridge_port_is_mine(const jack_client_t* client, const jack_port_t* port)

  1591. +{

  1592. +#if defined(JACKBRIDGE_DUMMY)

  1593. +#elif defined(JACKBRIDGE_DIRECT)

  1594. +    return jack_port_is_mine(client, port);

  1595. +#else

  1596. +    if (jackbridge_instance()->port_is_mine_ptr != NULL)

  1597. +        return jackbridge_instance()->port_is_mine_ptr(client, port);

  1598. +#endif

  1599. +    return false;

  1600. +}

  1601. +

  1602. +int jackbridge_port_connected(const jack_port_t* port)

  1603. +{

  1604. +#if defined(JACKBRIDGE_DUMMY)

  1605. +#elif defined(JACKBRIDGE_DIRECT)

  1606. +    return jack_port_connected(port);

  1607. +#else

  1608. +    if (jackbridge_instance()->port_connected_ptr != NULL)

  1609. +        return jackbridge_instance()->port_connected_ptr(port);

  1610. +#endif

  1611. +    return 0;

  1612. +}

  1613. +

  1614. +bool jackbridge_port_connected_to(const jack_port_t* port, const char* port_name)

  1615. +{

  1616. +#if defined(JACKBRIDGE_DUMMY)

  1617. +#elif defined(JACKBRIDGE_DIRECT)

  1618. +    return jack_port_connected_to(port, port_name);

  1619. +#else

  1620. +    if (jackbridge_instance()->port_connected_to_ptr != NULL)

  1621. +        return jackbridge_instance()->port_connected_to_ptr(port, port_name);

  1622. +#endif

  1623. +    return false;

  1624. +}

  1625. +

  1626. +const char** jackbridge_port_get_connections(const jack_port_t* port)

  1627. +{

  1628. +#if defined(JACKBRIDGE_DUMMY)

  1629. +#elif defined(JACKBRIDGE_DIRECT)

  1630. +    return jack_port_get_connections(port);

  1631. +#else

  1632. +    if (jackbridge_instance()->port_get_connections_ptr != NULL)

  1633. +        return jackbridge_instance()->port_get_connections_ptr(port);

  1634. +#endif

  1635. +    return NULL;

  1636. +}

  1637. +

  1638. +const char** jackbridge_port_get_all_connections(const jack_client_t* client, const jack_port_t* port)

  1639. +{

  1640. +#if defined(JACKBRIDGE_DUMMY)

  1641. +#elif defined(JACKBRIDGE_DIRECT)

  1642. +    return jack_port_get_all_connections(client, port);

  1643. +#else

  1644. +    if (jackbridge_instance()->port_get_all_connections_ptr != NULL)

  1645. +        return jackbridge_instance()->port_get_all_connections_ptr(client, port);

  1646. +#endif

  1647. +    return NULL;

  1648. +}

  1649. +

  1650. +// -----------------------------------------------------------------------------

  1651. +

  1652. +bool jackbridge_port_rename(jack_client_t* client, jack_port_t* port, const char* port_name)

  1653. +{

  1654. +#if defined(JACKBRIDGE_DUMMY)

  1655. +#elif defined(JACKBRIDGE_DIRECT)

  1656. +    return (jack_port_rename(client, port, port_name) == 0);

  1657. +#else

  1658. +    // Try new API first

  1659. +    if (jackbridge_instance()->port_rename_ptr != NULL)

  1660. +        return (jackbridge_instance()->port_rename_ptr(client, port, port_name) == 0);

  1661. +    // Try old API if using JACK2

  1662. +    if (jackbridge_instance()->get_version_string_ptr != NULL && jackbridge_instance()->port_set_name_ptr != NULL)

  1663. +        return (jackbridge_instance()->port_set_name_ptr(port, port_name) == 0);

  1664. +#endif

  1665. +    return false;

  1666. +}

  1667. +

  1668. +bool jackbridge_port_set_alias(jack_port_t* port, const char* alias)

  1669. +{

  1670. +#if defined(JACKBRIDGE_DUMMY)

  1671. +#elif defined(JACKBRIDGE_DIRECT)

  1672. +    return (jack_port_set_alias(port, alias) == 0);

  1673. +#else

  1674. +    if (jackbridge_instance()->port_set_alias_ptr != NULL)

  1675. +        return (jackbridge_instance()->port_set_alias_ptr(port, alias) == 0);

  1676. +#endif

  1677. +    return false;

  1678. +}

  1679. +

  1680. +bool jackbridge_port_unset_alias(jack_port_t* port, const char* alias)

  1681. +{

  1682. +#if defined(JACKBRIDGE_DUMMY)

  1683. +#elif defined(JACKBRIDGE_DIRECT)

  1684. +    return (jack_port_unset_alias(port, alias) == 0);

  1685. +#else

  1686. +    if (jackbridge_instance()->port_unset_alias_ptr != NULL)

  1687. +        return (jackbridge_instance()->port_unset_alias_ptr(port, alias) == 0);

  1688. +#endif

  1689. +    return false;

  1690. +}

  1691. +

  1692. +int jackbridge_port_get_aliases(const jack_port_t* port, char* const aliases[2])

  1693. +{

  1694. +#if defined(JACKBRIDGE_DUMMY)

  1695. +#elif defined(JACKBRIDGE_DIRECT)

  1696. +    return (jack_port_get_aliases(port, aliases) == 0);

  1697. +#else

  1698. +    if (jackbridge_instance()->port_get_aliases_ptr != NULL)

  1699. +        return jackbridge_instance()->port_get_aliases_ptr(port, aliases);

  1700. +#endif

  1701. +    return 0;

  1702. +}

  1703. +

  1704. +// -----------------------------------------------------------------------------

  1705. +

  1706. +bool jackbridge_port_request_monitor(jack_port_t* port, bool onoff)

  1707. +{

  1708. +#if defined(JACKBRIDGE_DUMMY)

  1709. +#elif defined(JACKBRIDGE_DIRECT)

  1710. +    return (jack_port_request_monitor(port, onoff) == 0);

  1711. +#else

  1712. +    if (jackbridge_instance()->port_request_monitor_ptr != NULL)

  1713. +        return (jackbridge_instance()->port_request_monitor_ptr(port, onoff) == 0);

  1714. +#endif

  1715. +    return false;

  1716. +}

  1717. +

  1718. +bool jackbridge_port_request_monitor_by_name(jack_client_t* client, const char* port_name, bool onoff)

  1719. +{

  1720. +#if defined(JACKBRIDGE_DUMMY)

  1721. +#elif defined(JACKBRIDGE_DIRECT)

  1722. +    return (jack_port_request_monitor_by_name(client, port_name, onoff) == 0);

  1723. +#else

  1724. +    if (jackbridge_instance()->port_request_monitor_by_name_ptr != NULL)

  1725. +        return (jackbridge_instance()->port_request_monitor_by_name_ptr(client, port_name, onoff) == 0);

  1726. +#endif

  1727. +    return false;

  1728. +}

  1729. +

  1730. +bool jackbridge_port_ensure_monitor(jack_port_t* port, bool onoff)

  1731. +{

  1732. +#if defined(JACKBRIDGE_DUMMY)

  1733. +#elif defined(JACKBRIDGE_DIRECT)

  1734. +    return (jack_port_ensure_monitor(port, onoff) == 0);

  1735. +#else

  1736. +    if (jackbridge_instance()->port_ensure_monitor_ptr != NULL)

  1737. +        return (jackbridge_instance()->port_ensure_monitor_ptr(port, onoff) == 0);

  1738. +#endif

  1739. +    return false;

  1740. +}

  1741. +

  1742. +bool jackbridge_port_monitoring_input(jack_port_t* port)

  1743. +{

  1744. +#if defined(JACKBRIDGE_DUMMY)

  1745. +#elif defined(JACKBRIDGE_DIRECT)

  1746. +    return jack_port_monitoring_input(port);

  1747. +#else

  1748. +    if (jackbridge_instance()->port_monitoring_input_ptr != NULL)

  1749. +        return jackbridge_instance()->port_monitoring_input_ptr(port);

  1750. +#endif

  1751. +    return false;

  1752. +}

  1753. +

  1754. +// -----------------------------------------------------------------------------

  1755. +

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

  1757. +{

  1758. +#if defined(JACKBRIDGE_DUMMY)

  1759. +#elif defined(JACKBRIDGE_DIRECT)

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

  1761. +#else

  1762. +    if (jackbridge_instance()->connect_ptr != NULL)

  1763. +    {

  1764. +        const int ret = jackbridge_instance()->connect_ptr(client, source_port, destination_port);

  1765. +        return ret == 0 || ret == EEXIST;

  1766. +    }

  1767. +#endif

  1768. +    return false;

  1769. +}

  1770. +

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

  1772. +{

  1773. +#if defined(JACKBRIDGE_DUMMY)

  1774. +#elif defined(JACKBRIDGE_DIRECT)

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

  1776. +#else

  1777. +    if (jackbridge_instance()->disconnect_ptr != NULL)

  1778. +        return (jackbridge_instance()->disconnect_ptr(client, source_port, destination_port) == 0);

  1779. +#endif

  1780. +    return false;

  1781. +}

  1782. +

  1783. +bool jackbridge_port_disconnect(jack_client_t* client, jack_port_t* port)

  1784. +{

  1785. +#if defined(JACKBRIDGE_DUMMY)

  1786. +#elif defined(JACKBRIDGE_DIRECT)

  1787. +    return (jack_port_disconnect(client, port) == 0);

  1788. +#else

  1789. +    if (jackbridge_instance()->port_disconnect_ptr != NULL)

  1790. +        return (jackbridge_instance()->port_disconnect_ptr(client, port) == 0);

  1791. +#endif

  1792. +    return false;

  1793. +}

  1794. +

  1795. +// -----------------------------------------------------------------------------

  1796. +

  1797. +int jackbridge_port_name_size()

  1798. +{

  1799. +#if defined(JACKBRIDGE_DUMMY)

  1800. +#elif defined(JACKBRIDGE_DIRECT)

  1801. +    return jack_port_name_size();

  1802. +#else

  1803. +    if (jackbridge_instance()->port_name_size_ptr != NULL)

  1804. +        return jackbridge_instance()->port_name_size_ptr();

  1805. +#endif

  1806. +    return 256;

  1807. +}

  1808. +

  1809. +int jackbridge_port_type_size()

  1810. +{

  1811. +#if defined(JACKBRIDGE_DUMMY)

  1812. +#elif defined(JACKBRIDGE_DIRECT)

  1813. +    return jack_port_type_size();

  1814. +#else

  1815. +    if (jackbridge_instance()->port_type_size_ptr != NULL)

  1816. +        return jackbridge_instance()->port_type_size_ptr();

  1817. +#endif

  1818. +    return 32;

  1819. +}

  1820. +

  1821. +uint32_t jackbridge_port_type_get_buffer_size(jack_client_t* client, const char* port_type)

  1822. +{

  1823. +#if defined(JACKBRIDGE_DUMMY)

  1824. +#elif defined(JACKBRIDGE_DIRECT)

  1825. +    return (uint32_t)jack_port_type_get_buffer_size(client, port_type);

  1826. +#else

  1827. +    if (jackbridge_instance()->port_type_get_buffer_size_ptr != NULL)

  1828. +        return (uint32_t)jackbridge_instance()->port_type_get_buffer_size_ptr(client, port_type);

  1829. +#endif

  1830. +    return 0;

  1831. +}

  1832. +

  1833. +// -----------------------------------------------------------------------------

  1834. +

  1835. +void jackbridge_port_get_latency_range(jack_port_t* port, uint32_t mode, jack_latency_range_t* range)

  1836. +{

  1837. +#if defined(JACKBRIDGE_DUMMY)

  1838. +#elif defined(JACKBRIDGE_DIRECT)

  1839. +    return jack_port_get_latency_range(port, (jack_latency_callback_mode_t)mode, range);

  1840. +#else

  1841. +    if (jackbridge_instance()->port_get_latency_range_ptr != NULL)

  1842. +        return jackbridge_instance()->port_get_latency_range_ptr(port, (jack_latency_callback_mode_t)mode, range);

  1843. +#endif

  1844. +    range->min = 0;

  1845. +    range->max = 0;

  1846. +}

  1847. +

  1848. +void jackbridge_port_set_latency_range(jack_port_t* port, uint32_t mode, jack_latency_range_t* range)

  1849. +{

  1850. +#if defined(JACKBRIDGE_DUMMY)

  1851. +#elif defined(JACKBRIDGE_DIRECT)

  1852. +    jack_port_set_latency_range(port, (jack_latency_callback_mode_t)mode, range);

  1853. +#else

  1854. +    if (jackbridge_instance()->port_set_latency_range_ptr != NULL)

  1855. +        jackbridge_instance()->port_set_latency_range_ptr(port, (jack_latency_callback_mode_t)mode, range);

  1856. +#endif

  1857. +}

  1858. +

  1859. +bool jackbridge_recompute_total_latencies(jack_client_t* client)

  1860. +{

  1861. +#if defined(JACKBRIDGE_DUMMY)

  1862. +#elif defined(JACKBRIDGE_DIRECT)

  1863. +    return (jack_recompute_total_latencies(client) == 0);

  1864. +#else

  1865. +    if (jackbridge_instance()->recompute_total_latencies_ptr != NULL)

  1866. +        return (jackbridge_instance()->recompute_total_latencies_ptr(client) == 0);

  1867. +#endif

  1868. +    return false;

  1869. +}

  1870. +

  1871. +// -----------------------------------------------------------------------------

  1872. +

  1873. +const char** jackbridge_get_ports(jack_client_t* client, const char* port_name_pattern, const char* type_name_pattern, uint64_t flags)

  1874. +{

  1875. +#if defined(JACKBRIDGE_DUMMY)

  1876. +#elif defined(JACKBRIDGE_DIRECT)

  1877. +    return jack_get_ports(client, port_name_pattern, type_name_pattern, flags);

  1878. +#else

  1879. +    if (jackbridge_instance()->get_ports_ptr != NULL)

  1880. +        return jackbridge_instance()->get_ports_ptr(client, port_name_pattern, type_name_pattern, (ulong)flags);

  1881. +#endif

  1882. +    return NULL;

  1883. +}

  1884. +

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

  1886. +{

  1887. +#if defined(JACKBRIDGE_DUMMY)

  1888. +#elif defined(JACKBRIDGE_DIRECT)

  1889. +    return jack_port_by_name(client, port_name);

  1890. +#else

  1891. +    if (jackbridge_instance()->port_by_name_ptr != NULL)

  1892. +        return jackbridge_instance()->port_by_name_ptr(client, port_name);

  1893. +#endif

  1894. +    return NULL;

  1895. +}

  1896. +

  1897. +jack_port_t* jackbridge_port_by_id(jack_client_t* client, jack_port_id_t port_id)

  1898. +{

  1899. +#if defined(JACKBRIDGE_DUMMY)

  1900. +#elif defined(JACKBRIDGE_DIRECT)

  1901. +    return jack_port_by_id(client, port_id);

  1902. +#else

  1903. +    if (jackbridge_instance()->port_by_id_ptr != NULL)

  1904. +        return jackbridge_instance()->port_by_id_ptr(client, port_id);

  1905. +#endif

  1906. +    return NULL;

  1907. +}

  1908. +

  1909. +// -----------------------------------------------------------------------------

  1910. +

  1911. +void jackbridge_free(void* ptr)

  1912. +{

  1913. +#if defined(JACKBRIDGE_DUMMY)

  1914. +#elif defined(JACKBRIDGE_DIRECT)

  1915. +    return jack_free(ptr);

  1916. +#else

  1917. +    if (jackbridge_instance()->free_ptr != NULL)

  1918. +        return jackbridge_instance()->free_ptr(ptr);

  1919. +

  1920. +   #ifndef _WIN32

  1921. +    free(ptr);

  1922. +   #endif

  1923. +#endif

  1924. +}

  1925. +

  1926. +// -----------------------------------------------------------------------------

  1927. +

  1928. +uint32_t jackbridge_midi_get_event_count(void* port_buffer)

  1929. +{

  1930. +#if defined(JACKBRIDGE_DUMMY)

  1931. +#elif defined(JACKBRIDGE_DIRECT)

  1932. +    return jack_midi_get_event_count(port_buffer);

  1933. +#else

  1934. +    if (jackbridge_instance()->midi_get_event_count_ptr != NULL)

  1935. +        return jackbridge_instance()->midi_get_event_count_ptr(port_buffer);

  1936. +#endif

  1937. +    return 0;

  1938. +}

  1939. +

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

  1941. +{

  1942. +#if defined(JACKBRIDGE_DUMMY)

  1943. +#elif defined(JACKBRIDGE_DIRECT)

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

  1945. +#else

  1946. +    if (jackbridge_instance()->midi_event_get_ptr != NULL)

  1947. +        return (jackbridge_instance()->midi_event_get_ptr(event, port_buffer, event_index) == 0);

  1948. +#endif

  1949. +    return false;

  1950. +}

  1951. +

  1952. +void jackbridge_midi_clear_buffer(void* port_buffer)

  1953. +{

  1954. +#if defined(JACKBRIDGE_DUMMY)

  1955. +#elif defined(JACKBRIDGE_DIRECT)

  1956. +    jack_midi_clear_buffer(port_buffer);

  1957. +#else

  1958. +    if (jackbridge_instance()->midi_clear_buffer_ptr != NULL)

  1959. +        jackbridge_instance()->midi_clear_buffer_ptr(port_buffer);

  1960. +#endif

  1961. +}

  1962. +

  1963. +bool jackbridge_midi_event_write(void* port_buffer, jack_nframes_t time, const jack_midi_data_t* data, uint32_t data_size)

  1964. +{

  1965. +#if defined(JACKBRIDGE_DUMMY)

  1966. +#elif defined(JACKBRIDGE_DIRECT)

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

  1968. +#else

  1969. +    if (jackbridge_instance()->midi_event_write_ptr != NULL)

  1970. +        return (jackbridge_instance()->midi_event_write_ptr(port_buffer, time, data, data_size) == 0);

  1971. +#endif

  1972. +    return false;

  1973. +}

  1974. +

  1975. +jack_midi_data_t* jackbridge_midi_event_reserve(void* port_buffer, jack_nframes_t time, uint32_t data_size)

  1976. +{

  1977. +#if defined(JACKBRIDGE_DUMMY)

  1978. +#elif defined(JACKBRIDGE_DIRECT)

  1979. +    return jack_midi_event_reserve(port_buffer, time, data_size);

  1980. +#else

  1981. +    if (jackbridge_instance()->midi_event_reserve_ptr != NULL)

  1982. +        return jackbridge_instance()->midi_event_reserve_ptr(port_buffer, time, data_size);

  1983. +#endif

  1984. +    return NULL;

  1985. +}

  1986. +

  1987. +// -----------------------------------------------------------------------------

  1988. +

  1989. +bool jackbridge_release_timebase(jack_client_t* client)

  1990. +{

  1991. +#if defined(JACKBRIDGE_DUMMY)

  1992. +#elif defined(JACKBRIDGE_DIRECT)

  1993. +    return (jack_release_timebase(client) == 0);

  1994. +#else

  1995. +    if (jackbridge_instance()->release_timebase_ptr != NULL)

  1996. +        return (jackbridge_instance()->release_timebase_ptr(client) == 0);

  1997. +#endif

  1998. +    return false;

  1999. +}

  2000. +

  2001. +bool jackbridge_set_sync_callback(jack_client_t* client, JackSyncCallback sync_callback, void* arg)

  2002. +{

  2003. +#if defined(JACKBRIDGE_DUMMY)

  2004. +#elif defined(JACKBRIDGE_DIRECT)

  2005. +    return (jack_set_sync_callback(client, sync_callback, arg) == 0);

  2006. +#else

  2007. +    if (jackbridge_instance()->set_sync_callback_ptr != NULL)

  2008. +    {

  2009. +# ifdef __WINE__

  2010. +        WineBridge::getInstance().set_sync(sync_callback);

  2011. +        return (jackbridge_instance()->set_sync_callback_ptr(client, WineBridge::sync, arg) == 0);

  2012. +# else

  2013. +        return (jackbridge_instance()->set_sync_callback_ptr(client, sync_callback, arg) == 0);

  2014. +# endif

  2015. +    }

  2016. +#endif

  2017. +    return false;

  2018. +}

  2019. +

  2020. +bool jackbridge_set_sync_timeout(jack_client_t* client, jack_time_t timeout)

  2021. +{

  2022. +#if defined(JACKBRIDGE_DUMMY)

  2023. +#elif defined(JACKBRIDGE_DIRECT)

  2024. +    return (jack_set_sync_timeout(client, timeout) == 0);

  2025. +#else

  2026. +    if (jackbridge_instance()->set_sync_timeout_ptr != NULL)

  2027. +        return (jackbridge_instance()->set_sync_timeout_ptr(client, timeout) == 0);

  2028. +#endif

  2029. +    return false;

  2030. +}

  2031. +

  2032. +bool jackbridge_set_timebase_callback(jack_client_t* client, bool conditional, JackTimebaseCallback timebase_callback, void* arg)

  2033. +{

  2034. +#if defined(JACKBRIDGE_DUMMY)

  2035. +#elif defined(JACKBRIDGE_DIRECT)

  2036. +    return (jack_set_timebase_callback(client, conditional, timebase_callback, arg) == 0);

  2037. +#else

  2038. +    if (jackbridge_instance()->set_timebase_callback_ptr != NULL)

  2039. +        return (jackbridge_instance()->set_timebase_callback_ptr(client, conditional, timebase_callback, arg) == 0);

  2040. +#endif

  2041. +    return false;

  2042. +}

  2043. +

  2044. +bool jackbridge_transport_locate(jack_client_t* client, jack_nframes_t frame)

  2045. +{

  2046. +#if defined(JACKBRIDGE_DUMMY)

  2047. +#elif defined(JACKBRIDGE_DIRECT)

  2048. +    return (jack_transport_locate(client, frame) == 0);

  2049. +#else

  2050. +    if (jackbridge_instance()->transport_locate_ptr != NULL)

  2051. +        return (jackbridge_instance()->transport_locate_ptr(client, frame) == 0);

  2052. +#endif

  2053. +    return false;

  2054. +}

  2055. +

  2056. +uint32_t jackbridge_transport_query(const jack_client_t* client, jack_position_t* pos)

  2057. +{

  2058. +#if defined(JACKBRIDGE_DUMMY)

  2059. +#elif defined(JACKBRIDGE_DIRECT)

  2060. +    return jack_transport_query(client, pos);

  2061. +#else

  2062. +    if (jackbridge_instance()->transport_query_ptr != NULL)

  2063. +        return jackbridge_instance()->transport_query_ptr(client, pos);

  2064. +#endif

  2065. +    if (pos != NULL)

  2066. +    {

  2067. +        // invalidate

  2068. +        memset(pos, 0, sizeof(*pos));

  2069. +        pos->unique_1 = 0;

  2070. +        pos->unique_2 = 1;

  2071. +    }

  2072. +    return JackTransportStopped;

  2073. +}

  2074. +

  2075. +jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client)

  2076. +{

  2077. +#if defined(JACKBRIDGE_DUMMY)

  2078. +#elif defined(JACKBRIDGE_DIRECT)

  2079. +    return jack_get_current_transport_frame(client);

  2080. +#else

  2081. +    if (jackbridge_instance()->get_current_transport_frame_ptr != NULL)

  2082. +        return jackbridge_instance()->get_current_transport_frame_ptr(client);

  2083. +#endif

  2084. +    return 0;

  2085. +}

  2086. +

  2087. +bool jackbridge_transport_reposition(jack_client_t* client, const jack_position_t* pos)

  2088. +{

  2089. +#if defined(JACKBRIDGE_DUMMY)

  2090. +#elif defined(JACKBRIDGE_DIRECT)

  2091. +    return (jack_transport_reposition(client, pos) == 0);

  2092. +#else

  2093. +    if (jackbridge_instance()->transport_reposition_ptr != NULL)

  2094. +        return (jackbridge_instance()->transport_reposition_ptr(client, pos) == 0);

  2095. +#endif

  2096. +    return false;

  2097. +}

  2098. +

  2099. +void jackbridge_transport_start(jack_client_t* client)

  2100. +{

  2101. +#if defined(JACKBRIDGE_DUMMY)

  2102. +#elif defined(JACKBRIDGE_DIRECT)

  2103. +    jack_transport_start(client);

  2104. +#else

  2105. +    if (jackbridge_instance()->transport_start_ptr != NULL)

  2106. +        jackbridge_instance()->transport_start_ptr(client);

  2107. +#endif

  2108. +}

  2109. +

  2110. +void jackbridge_transport_stop(jack_client_t* client)

  2111. +{

  2112. +#if defined(JACKBRIDGE_DUMMY)

  2113. +#elif defined(JACKBRIDGE_DIRECT)

  2114. +    jack_transport_stop(client);

  2115. +#else

  2116. +    if (jackbridge_instance()->transport_stop_ptr != NULL)

  2117. +        jackbridge_instance()->transport_stop_ptr(client);

  2118. +#endif

  2119. +}

  2120. +

  2121. +// -----------------------------------------------------------------------------

  2122. +

  2123. +bool jackbridge_set_property(jack_client_t* client, jack_uuid_t subject, const char* key, const char* value, const char* type)

  2124. +{

  2125. +#if defined(JACKBRIDGE_DUMMY)

  2126. +#elif defined(JACKBRIDGE_DIRECT)

  2127. +    return (jack_set_property(client, subject, key, value, type) == 0);

  2128. +#else

  2129. +    if (jackbridge_instance()->set_property_ptr != NULL)

  2130. +        return (jackbridge_instance()->set_property_ptr(client, subject, key, value, type) == 0);

  2131. +#endif

  2132. +    return false;

  2133. +}

  2134. +

  2135. +bool jackbridge_get_property(jack_uuid_t subject, const char* key, char** value, char** type)

  2136. +{

  2137. +#if defined(JACKBRIDGE_DUMMY)

  2138. +#elif defined(JACKBRIDGE_DIRECT)

  2139. +    return (jack_get_property(subject, key, value, type) == 0);

  2140. +#else

  2141. +    if (jackbridge_instance()->get_property_ptr != NULL)

  2142. +        return (jackbridge_instance()->get_property_ptr(subject, key, value, type) == 0);

  2143. +#endif

  2144. +    return false;

  2145. +}

  2146. +

  2147. +void jackbridge_free_description(jack_description_t* desc, bool free_description_itself)

  2148. +{

  2149. +#if defined(JACKBRIDGE_DUMMY)

  2150. +#elif defined(JACKBRIDGE_DIRECT)

  2151. +    jack_free_description(desc, free_description_itself);

  2152. +#else

  2153. +    if (jackbridge_instance()->free_description_ptr != NULL)

  2154. +        jackbridge_instance()->free_description_ptr(desc, free_description_itself);

  2155. +#endif

  2156. +}

  2157. +

  2158. +bool jackbridge_get_properties(jack_uuid_t subject, jack_description_t* desc)

  2159. +{

  2160. +#if defined(JACKBRIDGE_DUMMY)

  2161. +#elif defined(JACKBRIDGE_DIRECT)

  2162. +    return (jack_get_properties(subject, desc) == 0);

  2163. +#else

  2164. +    if (jackbridge_instance()->get_properties_ptr != NULL)

  2165. +        return (jackbridge_instance()->get_properties_ptr(subject, desc) == 0);

  2166. +#endif

  2167. +    return false;

  2168. +}

  2169. +

  2170. +bool jackbridge_get_all_properties(jack_description_t** descs)

  2171. +{

  2172. +#if defined(JACKBRIDGE_DUMMY)

  2173. +#elif defined(JACKBRIDGE_DIRECT)

  2174. +    return (jack_get_all_properties(descs) == 0);

  2175. +#else

  2176. +    if (jackbridge_instance()->get_all_properties_ptr != NULL)

  2177. +        return (jackbridge_instance()->get_all_properties_ptr(descs) == 0);

  2178. +#endif

  2179. +    return false;

  2180. +}

  2181. +

  2182. +bool jackbridge_remove_property(jack_client_t* client, jack_uuid_t subject, const char* key)

  2183. +{

  2184. +#if defined(JACKBRIDGE_DUMMY)

  2185. +#elif defined(JACKBRIDGE_DIRECT)

  2186. +    return (jack_remove_property(client, subject, key) == 0);

  2187. +#else

  2188. +    if (jackbridge_instance()->remove_property_ptr != NULL)

  2189. +        return (jackbridge_instance()->remove_property_ptr(client, subject, key) == 0);

  2190. +#endif

  2191. +    return false;

  2192. +}

  2193. +

  2194. +int jackbridge_remove_properties(jack_client_t* client, jack_uuid_t subject)

  2195. +{

  2196. +#if defined(JACKBRIDGE_DUMMY)

  2197. +#elif defined(JACKBRIDGE_DIRECT)

  2198. +    return jack_remove_properties(client, subject);

  2199. +#else

  2200. +    if (jackbridge_instance()->remove_properties_ptr != NULL)

  2201. +        return jackbridge_instance()->remove_properties_ptr(client, subject);

  2202. +#endif

  2203. +    return 0;

  2204. +}

  2205. +

  2206. +bool jackbridge_remove_all_properties(jack_client_t* client)

  2207. +{

  2208. +#if defined(JACKBRIDGE_DUMMY)

  2209. +#elif defined(JACKBRIDGE_DIRECT)

  2210. +    return (jack_remove_all_properties(client) == 0);

  2211. +#else

  2212. +    if (jackbridge_instance()->remove_all_properties_ptr != NULL)

  2213. +        return (jackbridge_instance()->remove_all_properties_ptr(client) == 0);

  2214. +#endif

  2215. +    return false;

  2216. +}

  2217. +

  2218. +bool jackbridge_set_property_change_callback(jack_client_t* client, JackPropertyChangeCallback callback, void* arg)

  2219. +{

  2220. +#if defined(JACKBRIDGE_DUMMY)

  2221. +#elif defined(JACKBRIDGE_DIRECT)

  2222. +    return (jack_set_property_change_callback(client, callback, arg) == 0);

  2223. +#else

  2224. +    if (jackbridge_instance()->set_property_change_callback_ptr != NULL)

  2225. +    {

  2226. +# ifdef __WINE__

  2227. +        WineBridge::getInstance().set_prop_change(callback);

  2228. +        return (jackbridge_instance()->set_property_change_callback_ptr(client, WineBridge::prop_change, arg) == 0);

  2229. +# else

  2230. +        return (jackbridge_instance()->set_property_change_callback_ptr(client, callback, arg) == 0);

  2231. +# endif

  2232. +    }

  2233. +#endif

  2234. +    return false;

  2235. +}

  2236. +

  2237. +bool jackbridge_set_process_thread(jack_client_t* client, JackThreadCallback callback, void* arg)

  2238. +{

  2239. +#if defined(JACKBRIDGE_DUMMY)

  2240. +#elif defined(JACKBRIDGE_DIRECT)

  2241. +    return (jack_set_process_thread(client, callback, arg) == 0);

  2242. +#else

  2243. +    if (jackbridge_instance()->set_process_thread_ptr != NULL)

  2244. +    {

  2245. +# ifdef __WINE__

  2246. +        WineBridge::getInstance().set_process_thread(callback);

  2247. +        return (jackbridge_instance()->set_process_thread_ptr(client, WineBridge::process_thread, arg) == 0);

  2248. +# else

  2249. +        return (jackbridge_instance()->set_process_thread_ptr(client, callback, arg) == 0);

  2250. +# endif

  2251. +    }

  2252. +#endif

  2253. +    return false;

  2254. +}

  2255. +

  2256. +jack_nframes_t jackbridge_cycle_wait(jack_client_t* client)

  2257. +{

  2258. +#if defined(JACKBRIDGE_DUMMY)

  2259. +#elif defined(JACKBRIDGE_DIRECT)

  2260. +    return jack_cycle_wait(client);

  2261. +#else

  2262. +    if (jackbridge_instance()->cycle_wait_ptr != NULL)

  2263. +        return jackbridge_instance()->cycle_wait_ptr(client);

  2264. +#endif

  2265. +    return 0;

  2266. +}

  2267. +

  2268. +void jackbridge_cycle_signal(jack_client_t* client, int status)

  2269. +{

  2270. +#if defined(JACKBRIDGE_DUMMY)

  2271. +#elif defined(JACKBRIDGE_DIRECT)

  2272. +    jack_cycle_signal(client, status);

  2273. +#else

  2274. +    if (jackbridge_instance()->cycle_signal_ptr != NULL)

  2275. +        jackbridge_instance()->cycle_signal_ptr(client, status);

  2276. +#endif

  2277. +}

  2278. +

  2279. +jack_nframes_t jackbridge_port_get_latency(jack_port_t* port)

  2280. +{

  2281. +#if defined(JACKBRIDGE_DUMMY)

  2282. +#elif defined(JACKBRIDGE_DIRECT)

  2283. +    return jack_port_get_latency(port);

  2284. +#else

  2285. +    if (jackbridge_instance()->port_get_latency_ptr != NULL)

  2286. +        jackbridge_instance()->port_get_latency_ptr(port);

  2287. +    return 0;

  2288. +#endif

  2289. +}

  2290. +

  2291. +jack_nframes_t jackbridge_frame_time(const jack_client_t* client)

  2292. +{

  2293. +#if defined(JACKBRIDGE_DUMMY)

  2294. +#elif defined(JACKBRIDGE_DIRECT)

  2295. +    return jackbridge_frame_time(client);

  2296. +#else

  2297. +    if (jackbridge_instance()->frame_time_ptr != NULL)

  2298. +        jackbridge_instance()->frame_time_ptr(client);

  2299. +    return 0;

  2300. +#endif

  2301. +}

  2302. diff --git a/src/hostapi/jack/JackBridge.h b/src/hostapi/jack/JackBridge.h

  2303. new file mode 100644

  2304. index 0000000..eff8cb0

  2305. --- /dev/null

  2306. +++ b/src/hostapi/jack/JackBridge.h

  2307. @@ -0,0 +1,406 @@

  2308. +/*

  2309. + * JackBridge for DPF

  2310. + * Copyright (C) 2013-2021 Filipe Coelho <falktx@falktx.com>

  2311. + *

  2312. + * Permission to use, copy, modify, and/or distribute this software for any purpose with

  2313. + * or without fee is hereby granted, provided that the above copyright notice and this

  2314. + * permission notice appear in all copies.

  2315. + *

  2316. + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD

  2317. + * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN

  2318. + * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL

  2319. + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER

  2320. + * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN

  2321. + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

  2322. + */

  2323. +

  2324. +#ifndef JACKBRIDGE_HPP_INCLUDED

  2325. +#define JACKBRIDGE_HPP_INCLUDED

  2326. +

  2327. +#if defined(_WIN32) && defined(__cdecl)

  2328. +# define JACKBRIDGE_API __cdecl

  2329. +#else

  2330. +# define JACKBRIDGE_API

  2331. +#endif

  2332. +

  2333. +#ifdef JACKBRIDGE_DIRECT

  2334. +# include <jack/jack.h>

  2335. +# include <jack/midiport.h>

  2336. +# include <jack/transport.h>

  2337. +# include <jack/session.h>

  2338. +# include <jack/metadata.h>

  2339. +# include <jack/uuid.h>

  2340. +#else

  2341. +

  2342. +#include <stdbool.h>

  2343. +#include <stddef.h>

  2344. +#include <stdint.h>

  2345. +

  2346. +#ifndef POST_PACKED_STRUCTURE

  2347. +# if defined(__GNUC__)

  2348. +  /* POST_PACKED_STRUCTURE needs to be a macro which

  2349. +      expands into a compiler directive. The directive must

  2350. +      tell the compiler to arrange the preceding structure

  2351. +      declaration so that it is packed on byte-boundaries rather

  2352. +      than use the natural alignment of the processor and/or

  2353. +      compiler.

  2354. +  */

  2355. +  #define PRE_PACKED_STRUCTURE

  2356. +  #define POST_PACKED_STRUCTURE __attribute__((__packed__))

  2357. +# elif defined(_MSC_VER)

  2358. +  #define PRE_PACKED_STRUCTURE1 __pragma(pack(push,1))

  2359. +  #define PRE_PACKED_STRUCTURE    PRE_PACKED_STRUCTURE1

  2360. +  /* PRE_PACKED_STRUCTURE needs to be a macro which

  2361. +      expands into a compiler directive. The directive must

  2362. +      tell the compiler to arrange the following structure

  2363. +      declaration so that it is packed on byte-boundaries rather

  2364. +      than use the natural alignment of the processor and/or

  2365. +      compiler.

  2366. +  */

  2367. +  #define POST_PACKED_STRUCTURE ;__pragma(pack(pop))

  2368. +  /* and POST_PACKED_STRUCTURE needs to be a macro which

  2369. +      restores the packing to its previous setting */

  2370. +# else

  2371. +  #define PRE_PACKED_STRUCTURE

  2372. +  #define POST_PACKED_STRUCTURE

  2373. +# endif

  2374. +#endif

  2375. +

  2376. +#if (defined(__arm__) || defined(__aarch64__) || defined(__mips__) || defined(__ppc__) || defined(__powerpc__)) && !defined(__APPLE__)

  2377. +# undef POST_PACKED_STRUCTURE

  2378. +# define POST_PACKED_STRUCTURE

  2379. +#endif

  2380. +

  2381. +#define JACK_DEFAULT_AUDIO_TYPE "32 bit float mono audio"

  2382. +#define JACK_DEFAULT_MIDI_TYPE  "8 bit raw midi"

  2383. +

  2384. +#define JACK_MAX_FRAMES (4294967295U)

  2385. +

  2386. +#define JackOpenOptions (JackSessionID|JackServerName|JackNoStartServer|JackUseExactName)

  2387. +#define JackLoadOptions (JackLoadInit|JackLoadName|JackUseExactName)

  2388. +

  2389. +#define JACK_POSITION_MASK (JackPositionBBT|JackPositionTimecode|JackBBTFrameOffset|JackAudioVideoRatio|JackVideoFrameOffset)

  2390. +#define EXTENDED_TIME_INFO

  2391. +

  2392. +#define JACK_UUID_SIZE 36

  2393. +#define JACK_UUID_STRING_SIZE (JACK_UUID_SIZE+1) /* includes trailing null */

  2394. +#define JACK_UUID_EMPTY_INITIALIZER 0

  2395. +

  2396. +#define JACK_TICK_DOUBLE

  2397. +

  2398. +enum JackOptions {

  2399. +    JackNullOption    = 0x00,

  2400. +    JackNoStartServer = 0x01,

  2401. +    JackUseExactName  = 0x02,

  2402. +    JackServerName    = 0x04,

  2403. +    JackLoadName      = 0x08,

  2404. +    JackLoadInit      = 0x10,

  2405. +    JackSessionID     = 0x20

  2406. +};

  2407. +

  2408. +enum JackStatus {

  2409. +    JackFailure       = 0x0001,

  2410. +    JackInvalidOption = 0x0002,

  2411. +    JackNameNotUnique = 0x0004,

  2412. +    JackServerStarted = 0x0008,

  2413. +    JackServerFailed  = 0x0010,

  2414. +    JackServerError   = 0x0020,

  2415. +    JackNoSuchClient  = 0x0040,

  2416. +    JackLoadFailure   = 0x0080,

  2417. +    JackInitFailure   = 0x0100,

  2418. +    JackShmFailure    = 0x0200,

  2419. +    JackVersionError  = 0x0400,

  2420. +    JackBackendError  = 0x0800,

  2421. +    JackClientZombie  = 0x1000,

  2422. +    JackBridgeNativeFailed = 0x10000

  2423. +};

  2424. +

  2425. +enum JackLatencyCallbackMode {

  2426. +    JackCaptureLatency,

  2427. +    JackPlaybackLatency

  2428. +};

  2429. +

  2430. +enum JackPortFlags {

  2431. +    JackPortIsInput    = 0x01,

  2432. +    JackPortIsOutput   = 0x02,

  2433. +    JackPortIsPhysical = 0x04,

  2434. +    JackPortCanMonitor = 0x08,

  2435. +    JackPortIsTerminal = 0x10,

  2436. +    JackPortIsControlVoltage = 0x100

  2437. +};

  2438. +

  2439. +enum JackTransportState {

  2440. +    JackTransportStopped  = 0,

  2441. +    JackTransportRolling  = 1,

  2442. +    JackTransportLooping  = 2,

  2443. +    JackTransportStarting = 3

  2444. +};

  2445. +

  2446. +enum JackPositionBits {

  2447. +    JackPositionBBT      = 0x010,

  2448. +    JackPositionTimecode = 0x020,

  2449. +    JackBBTFrameOffset   = 0x040,

  2450. +    JackAudioVideoRatio  = 0x080,

  2451. +    JackVideoFrameOffset = 0x100,

  2452. +    JackTickDouble       = 0x200

  2453. +};

  2454. +

  2455. +enum JackSessionEventType {

  2456. +    JackSessionSave         = 1,

  2457. +    JackSessionSaveAndQuit  = 2,

  2458. +    JackSessionSaveTemplate = 3

  2459. +};

  2460. +

  2461. +enum JackSessionFlags {

  2462. +    JackSessionSaveError    = 0x1,

  2463. +    JackSessionNeedTerminal = 0x2

  2464. +};

  2465. +

  2466. +enum JackPropertyChange {

  2467. +    PropertyCreated,

  2468. +    PropertyChanged,

  2469. +    PropertyDeleted

  2470. +};

  2471. +

  2472. +typedef uint32_t jack_nframes_t;

  2473. +typedef uint32_t jack_port_id_t;

  2474. +typedef uint64_t jack_time_t;

  2475. +typedef uint64_t jack_uuid_t;

  2476. +typedef uint64_t jack_unique_t;

  2477. +typedef unsigned char jack_midi_data_t;

  2478. +typedef float jack_default_audio_sample_t;

  2479. +

  2480. +typedef enum JackOptions jack_options_t;

  2481. +typedef enum JackStatus jack_status_t;

  2482. +typedef enum JackLatencyCallbackMode jack_latency_callback_mode_t;

  2483. +typedef enum JackTransportState jack_transport_state_t;

  2484. +typedef enum JackPositionBits jack_position_bits_t;

  2485. +typedef enum JackSessionEventType jack_session_event_type_t;

  2486. +typedef enum JackSessionFlags jack_session_flags_t;

  2487. +typedef enum JackPropertyChange jack_property_change_t;

  2488. +

  2489. +struct _jack_midi_event {

  2490. +    jack_nframes_t    time;

  2491. +    size_t            size;

  2492. +    jack_midi_data_t* buffer;

  2493. +};

  2494. +

  2495. +// NOTE: packed in JACK2 but not in JACK1

  2496. +PRE_PACKED_STRUCTURE

  2497. +struct _jack_latency_range {

  2498. +    jack_nframes_t min;

  2499. +    jack_nframes_t max;

  2500. +} POST_PACKED_STRUCTURE;

  2501. +

  2502. +PRE_PACKED_STRUCTURE

  2503. +struct _jack_position {

  2504. +    jack_unique_t  unique_1;

  2505. +    jack_time_t    usecs;

  2506. +    jack_nframes_t frame_rate;

  2507. +    jack_nframes_t frame;

  2508. +    jack_position_bits_t valid;

  2509. +    int32_t bar;

  2510. +    int32_t beat;

  2511. +    int32_t tick;

  2512. +    double  bar_start_tick;

  2513. +    float   beats_per_bar;

  2514. +    float   beat_type;

  2515. +    double  ticks_per_beat;

  2516. +    double  beats_per_minute;

  2517. +    double  frame_time;

  2518. +    double  next_time;

  2519. +    jack_nframes_t bbt_offset;

  2520. +    float          audio_frames_per_video_frame;

  2521. +    jack_nframes_t video_offset;

  2522. +    double         tick_double;

  2523. +    int32_t        padding[5];

  2524. +    jack_unique_t  unique_2;

  2525. +} POST_PACKED_STRUCTURE;

  2526. +

  2527. +struct _jack_session_event {

  2528. +    jack_session_event_type_t type;

  2529. +    const char* session_dir;

  2530. +    const char* client_uuid;

  2531. +    char*       command_line;

  2532. +    jack_session_flags_t flags;

  2533. +    uint32_t future;

  2534. +};

  2535. +

  2536. +struct _jack_session_command_t {

  2537. +    const char* uuid;

  2538. +    const char* client_name;

  2539. +    const char* command;

  2540. +    jack_session_flags_t flags;

  2541. +};

  2542. +

  2543. +typedef struct {

  2544. +    const char* key;

  2545. +    const char* data;

  2546. +    const char* type;

  2547. +} jack_property_t;

  2548. +

  2549. +typedef struct {

  2550. +    jack_uuid_t      subject;

  2551. +    uint32_t         property_cnt;

  2552. +    jack_property_t* properties;

  2553. +    uint32_t         property_size;

  2554. +} jack_description_t;

  2555. +

  2556. +typedef struct _jack_port jack_port_t;

  2557. +typedef struct _jack_client jack_client_t;

  2558. +typedef struct _jack_midi_event jack_midi_event_t;

  2559. +typedef struct _jack_latency_range jack_latency_range_t;

  2560. +typedef struct _jack_position jack_position_t;

  2561. +typedef struct _jack_session_event jack_session_event_t;

  2562. +typedef struct _jack_session_command_t jack_session_command_t;

  2563. +

  2564. +typedef void (JACKBRIDGE_API *JackLatencyCallback)(jack_latency_callback_mode_t mode, void* arg);

  2565. +typedef int  (JACKBRIDGE_API *JackProcessCallback)(jack_nframes_t nframes, void* arg);

  2566. +typedef void (JACKBRIDGE_API *JackThreadInitCallback)(void* arg);

  2567. +typedef int  (JACKBRIDGE_API *JackGraphOrderCallback)(void* arg);

  2568. +typedef int  (JACKBRIDGE_API *JackXRunCallback)(void* arg);

  2569. +typedef int  (JACKBRIDGE_API *JackBufferSizeCallback)(jack_nframes_t nframes, void* arg);

  2570. +typedef int  (JACKBRIDGE_API *JackSampleRateCallback)(jack_nframes_t nframes, void* arg);

  2571. +typedef void (JACKBRIDGE_API *JackPortRegistrationCallback)(jack_port_id_t port, int register_, void* arg);

  2572. +typedef void (JACKBRIDGE_API *JackClientRegistrationCallback)(const char* name, int register_, void* arg);

  2573. +typedef void (JACKBRIDGE_API *JackPortConnectCallback)(jack_port_id_t a, jack_port_id_t b, int connect, void* arg);

  2574. +typedef void (JACKBRIDGE_API *JackPortRenameCallback)(jack_port_id_t port, const char* old_name, const char* new_name, void* arg);

  2575. +typedef void (JACKBRIDGE_API *JackFreewheelCallback)(int starting, void* arg);

  2576. +typedef void (JACKBRIDGE_API *JackShutdownCallback)(void* arg);

  2577. +typedef void (JACKBRIDGE_API *JackInfoShutdownCallback)(jack_status_t code, const char* reason, void* arg);

  2578. +typedef int  (JACKBRIDGE_API *JackSyncCallback)(jack_transport_state_t state, jack_position_t* pos, void* arg);

  2579. +typedef void (JACKBRIDGE_API *JackTimebaseCallback)(jack_transport_state_t state, jack_nframes_t nframes, jack_position_t* pos, int new_pos, void* arg);

  2580. +typedef void (JACKBRIDGE_API *JackSessionCallback)(jack_session_event_t* event, void* arg);

  2581. +typedef void (JACKBRIDGE_API *JackPropertyChangeCallback)(jack_uuid_t subject, const char* key, jack_property_change_t change, void* arg);

  2582. +typedef void *(JACKBRIDGE_API *JackThreadCallback)(void* arg);

  2583. +

  2584. +#endif // ! JACKBRIDGE_DIRECT

  2585. +

  2586. +JACKBRIDGE_API bool jackbridge_is_ok();

  2587. +

  2588. +JACKBRIDGE_API void        jackbridge_get_version(int* major_ptr, int* minor_ptr, int* micro_ptr, int* proto_ptr);

  2589. +JACKBRIDGE_API const char* jackbridge_get_version_string();

  2590. +

  2591. +JACKBRIDGE_API jack_client_t* jackbridge_client_open(const char* client_name, uint32_t options, jack_status_t* status);

  2592. +JACKBRIDGE_API bool           jackbridge_client_close(jack_client_t* client);

  2593. +

  2594. +JACKBRIDGE_API int         jackbridge_client_name_size();

  2595. +JACKBRIDGE_API const char* jackbridge_get_client_name(jack_client_t* client);

  2596. +

  2597. +JACKBRIDGE_API char* jackbridge_client_get_uuid(jack_client_t* client);

  2598. +JACKBRIDGE_API char* jackbridge_get_uuid_for_client_name(jack_client_t* client, const char* name);

  2599. +JACKBRIDGE_API char* jackbridge_get_client_name_by_uuid(jack_client_t* client, const char* uuid);

  2600. +

  2601. +JACKBRIDGE_API bool jackbridge_uuid_parse(const char* buf, jack_uuid_t* uuid);

  2602. +JACKBRIDGE_API void jackbridge_uuid_unparse(jack_uuid_t uuid, char buf[JACK_UUID_STRING_SIZE]);

  2603. +

  2604. +JACKBRIDGE_API bool jackbridge_activate(jack_client_t* client);

  2605. +JACKBRIDGE_API bool jackbridge_deactivate(jack_client_t* client);

  2606. +JACKBRIDGE_API bool jackbridge_is_realtime(jack_client_t* client);

  2607. +

  2608. +JACKBRIDGE_API bool jackbridge_set_thread_init_callback(jack_client_t* client, JackThreadInitCallback thread_init_callback, void* arg);

  2609. +JACKBRIDGE_API void jackbridge_on_shutdown(jack_client_t* client, JackShutdownCallback shutdown_callback, void* arg);

  2610. +JACKBRIDGE_API void jackbridge_on_info_shutdown(jack_client_t* client, JackInfoShutdownCallback shutdown_callback, void* arg);

  2611. +JACKBRIDGE_API bool jackbridge_set_process_callback(jack_client_t* client, JackProcessCallback process_callback, void* arg);

  2612. +JACKBRIDGE_API bool jackbridge_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback freewheel_callback, void* arg);

  2613. +JACKBRIDGE_API bool jackbridge_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback bufsize_callback, void* arg);

  2614. +JACKBRIDGE_API bool jackbridge_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback srate_callback, void* arg);

  2615. +JACKBRIDGE_API bool jackbridge_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback registration_callback, void* arg);

  2616. +JACKBRIDGE_API bool jackbridge_set_port_registration_callback(jack_client_t* client, JackPortRegistrationCallback registration_callback, void* arg);

  2617. +JACKBRIDGE_API bool jackbridge_set_port_rename_callback(jack_client_t* client, JackPortRenameCallback rename_callback, void* arg);

  2618. +JACKBRIDGE_API bool jackbridge_set_port_connect_callback(jack_client_t* client, JackPortConnectCallback connect_callback, void* arg);

  2619. +JACKBRIDGE_API bool jackbridge_set_graph_order_callback(jack_client_t* client, JackGraphOrderCallback graph_callback, void* arg);

  2620. +JACKBRIDGE_API bool jackbridge_set_xrun_callback(jack_client_t* client, JackXRunCallback xrun_callback, void* arg);

  2621. +JACKBRIDGE_API bool jackbridge_set_latency_callback(jack_client_t* client, JackLatencyCallback latency_callback, void* arg);

  2622. +

  2623. +JACKBRIDGE_API bool jackbridge_set_freewheel(jack_client_t* client, bool onoff);

  2624. +JACKBRIDGE_API bool jackbridge_set_buffer_size(jack_client_t* client, jack_nframes_t nframes);

  2625. +

  2626. +JACKBRIDGE_API jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client);

  2627. +JACKBRIDGE_API jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client);

  2628. +JACKBRIDGE_API float          jackbridge_cpu_load(jack_client_t* client);

  2629. +

  2630. +JACKBRIDGE_API jack_port_t* jackbridge_port_register(jack_client_t* client, const char* port_name, const char* port_type, uint64_t flags, uint64_t buffer_size);

  2631. +JACKBRIDGE_API bool         jackbridge_port_unregister(jack_client_t* client, jack_port_t* port);

  2632. +JACKBRIDGE_API void*        jackbridge_port_get_buffer(jack_port_t* port, jack_nframes_t nframes);

  2633. +

  2634. +JACKBRIDGE_API const char*  jackbridge_port_name(const jack_port_t* port);

  2635. +JACKBRIDGE_API jack_uuid_t  jackbridge_port_uuid(const jack_port_t* port);

  2636. +JACKBRIDGE_API const char*  jackbridge_port_short_name(const jack_port_t* port);

  2637. +JACKBRIDGE_API int          jackbridge_port_flags(const jack_port_t* port);

  2638. +JACKBRIDGE_API const char*  jackbridge_port_type(const jack_port_t* port);

  2639. +JACKBRIDGE_API bool         jackbridge_port_is_mine(const jack_client_t* client, const jack_port_t* port);

  2640. +JACKBRIDGE_API int          jackbridge_port_connected(const jack_port_t* port);

  2641. +JACKBRIDGE_API bool         jackbridge_port_connected_to(const jack_port_t* port, const char* port_name);

  2642. +JACKBRIDGE_API const char** jackbridge_port_get_connections(const jack_port_t* port);

  2643. +JACKBRIDGE_API const char** jackbridge_port_get_all_connections(const jack_client_t* client, const jack_port_t* port);

  2644. +

  2645. +JACKBRIDGE_API bool jackbridge_port_rename(jack_client_t* client, jack_port_t* port, const char* port_name);

  2646. +JACKBRIDGE_API bool jackbridge_port_set_alias(jack_port_t* port, const char* alias);

  2647. +JACKBRIDGE_API bool jackbridge_port_unset_alias(jack_port_t* port, const char* alias);

  2648. +JACKBRIDGE_API int  jackbridge_port_get_aliases(const jack_port_t* port, char* const al[2]);

  2649. +

  2650. +JACKBRIDGE_API bool jackbridge_port_request_monitor(jack_port_t* port, bool onoff);

  2651. +JACKBRIDGE_API bool jackbridge_port_request_monitor_by_name(jack_client_t* client, const char* port_name, bool onoff);

  2652. +JACKBRIDGE_API bool jackbridge_port_ensure_monitor(jack_port_t* port, bool onoff);

  2653. +JACKBRIDGE_API bool jackbridge_port_monitoring_input(jack_port_t* port);

  2654. +

  2655. +JACKBRIDGE_API bool jackbridge_connect(jack_client_t* client, const char* source_port, const char* destination_port);

  2656. +JACKBRIDGE_API bool jackbridge_disconnect(jack_client_t* client, const char* source_port, const char* destination_port);

  2657. +JACKBRIDGE_API bool jackbridge_port_disconnect(jack_client_t* client, jack_port_t* port);

  2658. +

  2659. +JACKBRIDGE_API int      jackbridge_port_name_size();

  2660. +JACKBRIDGE_API int      jackbridge_port_type_size();

  2661. +JACKBRIDGE_API uint32_t jackbridge_port_type_get_buffer_size(jack_client_t* client, const char* port_type);

  2662. +

  2663. +JACKBRIDGE_API void jackbridge_port_get_latency_range(jack_port_t* port, uint32_t mode, jack_latency_range_t* range);

  2664. +JACKBRIDGE_API void jackbridge_port_set_latency_range(jack_port_t* port, uint32_t mode, jack_latency_range_t* range);

  2665. +JACKBRIDGE_API bool jackbridge_recompute_total_latencies(jack_client_t* client);

  2666. +

  2667. +JACKBRIDGE_API const char** jackbridge_get_ports(jack_client_t* client, const char* port_name_pattern, const char* type_name_pattern, uint64_t flags);

  2668. +JACKBRIDGE_API jack_port_t* jackbridge_port_by_name(jack_client_t* client, const char* port_name);

  2669. +JACKBRIDGE_API jack_port_t* jackbridge_port_by_id(jack_client_t* client, jack_port_id_t port_id);

  2670. +

  2671. +JACKBRIDGE_API void jackbridge_free(void* ptr);

  2672. +

  2673. +JACKBRIDGE_API uint32_t jackbridge_midi_get_event_count(void* port_buffer);

  2674. +JACKBRIDGE_API bool     jackbridge_midi_event_get(jack_midi_event_t* event, void* port_buffer, uint32_t event_index);

  2675. +JACKBRIDGE_API void     jackbridge_midi_clear_buffer(void* port_buffer);

  2676. +JACKBRIDGE_API bool     jackbridge_midi_event_write(void* port_buffer, jack_nframes_t time, const jack_midi_data_t* data, uint32_t data_size);

  2677. +JACKBRIDGE_API jack_midi_data_t* jackbridge_midi_event_reserve(void* port_buffer, jack_nframes_t time, uint32_t data_size);

  2678. +

  2679. +JACKBRIDGE_API bool jackbridge_release_timebase(jack_client_t* client);

  2680. +JACKBRIDGE_API bool jackbridge_set_sync_callback(jack_client_t* client, JackSyncCallback sync_callback, void* arg);

  2681. +JACKBRIDGE_API bool jackbridge_set_sync_timeout(jack_client_t* client, jack_time_t timeout);

  2682. +JACKBRIDGE_API bool jackbridge_set_timebase_callback(jack_client_t* client, bool conditional, JackTimebaseCallback timebase_callback, void* arg);

  2683. +JACKBRIDGE_API bool jackbridge_transport_locate(jack_client_t* client, jack_nframes_t frame);

  2684. +

  2685. +JACKBRIDGE_API uint32_t       jackbridge_transport_query(const jack_client_t* client, jack_position_t* pos);

  2686. +JACKBRIDGE_API jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client);

  2687. +

  2688. +JACKBRIDGE_API bool jackbridge_transport_reposition(jack_client_t* client, const jack_position_t* pos);

  2689. +JACKBRIDGE_API void jackbridge_transport_start(jack_client_t* client);

  2690. +JACKBRIDGE_API void jackbridge_transport_stop(jack_client_t* client);

  2691. +

  2692. +JACKBRIDGE_API bool jackbridge_set_property(jack_client_t* client, jack_uuid_t subject, const char* key, const char* value, const char* type);

  2693. +JACKBRIDGE_API bool jackbridge_get_property(jack_uuid_t subject, const char* key, char** value, char** type);

  2694. +JACKBRIDGE_API void jackbridge_free_description(jack_description_t* desc, bool free_description_itself);

  2695. +JACKBRIDGE_API bool jackbridge_get_properties(jack_uuid_t subject, jack_description_t* desc);

  2696. +JACKBRIDGE_API bool jackbridge_get_all_properties(jack_description_t** descs);

  2697. +JACKBRIDGE_API bool jackbridge_remove_property(jack_client_t* client, jack_uuid_t subject, const char* key);

  2698. +JACKBRIDGE_API int  jackbridge_remove_properties(jack_client_t* client, jack_uuid_t subject);

  2699. +JACKBRIDGE_API bool jackbridge_remove_all_properties(jack_client_t* client);

  2700. +JACKBRIDGE_API bool jackbridge_set_property_change_callback(jack_client_t* client, JackPropertyChangeCallback callback, void* arg);

  2701. +

  2702. +JACKBRIDGE_API bool jackbridge_set_process_thread(jack_client_t* client, JackThreadCallback callback, void* arg);

  2703. +JACKBRIDGE_API jack_nframes_t jackbridge_cycle_wait(jack_client_t* client);

  2704. +JACKBRIDGE_API void jackbridge_cycle_signal(jack_client_t* client, int status);

  2705. +

  2706. +JACKBRIDGE_API jack_nframes_t jackbridge_port_get_latency(jack_port_t* port);

  2707. +JACKBRIDGE_API jack_nframes_t jackbridge_frame_time(const jack_client_t* client);

  2708. +

  2709. +// todo

  2710. +static inline

  2711. +void jackbridge_set_error_function(void* cb) {}

  2712. +

  2713. +#endif // JACKBRIDGE_HPP_INCLUDED

  2714. diff --git a/configure.in b/configure.in

  2715. index f325bb1..178588f 100644

  2716. --- a/configure.in

  2717. +++ b/configure.in

  2718. @@ -134,7 +134,7 @@ if test "x$with_oss" != "xno"; then

  2719.  fi

  2720.  have_jack=no

  2721.  if test "x$with_jack" != "xno"; then

  2722. -    PKG_CHECK_MODULES(JACK, jack, have_jack=yes, have_jack=no)

  2723. +    have_jack=yes

  2724.  fi

  2725.  

  2726.