Browse Source

rebase from trunk 4083:4180

git-svn-id: http://subversion.jackaudio.org/jack/jack2/branches/libjacknet@4181 0c269be4-1314-0410-8aa9-9f06e86f4224
tags/1.9.8
sletz 12 years ago
parent
commit
a7e8377441
100 changed files with 5448 additions and 2949 deletions
  1. +61
    -2
      ChangeLog
  2. +255
    -153
      common/JackAPI.cpp
  3. +78
    -22
      common/JackAudioDriver.cpp
  4. +9
    -5
      common/JackAudioDriver.h
  5. +16
    -7
      common/JackAudioPort.cpp
  6. +13
    -18
      common/JackChannel.h
  7. +232
    -92
      common/JackClient.cpp
  8. +20
    -12
      common/JackClient.h
  9. +3
    -3
      common/JackClientControl.h
  10. +42
    -3
      common/JackConnectionManager.cpp
  11. +27
    -8
      common/JackConnectionManager.h
  12. +6
    -6
      common/JackDebugClient.cpp
  13. +2
    -2
      common/JackDebugClient.h
  14. +5
    -5
      common/JackDriver.cpp
  15. +44
    -44
      common/JackDriver.h
  16. +6
    -0
      common/JackDummyDriver.cpp
  17. +83
    -42
      common/JackEngine.cpp
  18. +6
    -2
      common/JackEngine.h
  19. +14
    -14
      common/JackEngineControl.cpp
  20. +5
    -6
      common/JackError.h
  21. +11
    -11
      common/JackFrameTimer.h
  22. +78
    -37
      common/JackGraphManager.cpp
  23. +9
    -7
      common/JackGraphManager.h
  24. +10
    -7
      common/JackInternalClientChannel.h
  25. +22
    -6
      common/JackLockedEngine.h
  26. +13
    -14
      common/JackMessageBuffer.cpp
  27. +12
    -6
      common/JackMidiPort.cpp
  28. +25
    -20
      common/JackNetDriver.cpp
  29. +46
    -34
      common/JackNetManager.cpp
  30. +3
    -3
      common/JackNetManager.h
  31. +688
    -692
      common/JackNetOneDriver.cpp
  32. +28
    -26
      common/JackNetOneDriver.h
  33. +2
    -1
      common/JackNotification.h
  34. +50
    -6
      common/JackPort.cpp
  35. +10
    -4
      common/JackPort.h
  36. +6
    -6
      common/JackPortType.cpp
  37. +3
    -2
      common/JackPortType.h
  38. +86
    -32
      common/JackRequest.h
  39. +17
    -17
      common/JackServer.cpp
  40. +6
    -4
      common/JackServerGlobals.cpp
  41. +4
    -3
      common/JackServerGlobals.h
  42. +28
    -28
      common/JackThread.h
  43. +0
    -1
      common/JackTime.h
  44. +6
    -0
      common/JackTypes.h
  45. +19
    -19
      common/Jackdmp.cpp
  46. +340
    -124
      common/jack/jack.h
  47. +26
    -26
      common/jack/midiport.h
  48. +143
    -87
      common/jack/session.h
  49. +17
    -6
      common/jack/systemdeps.h
  50. +9
    -5
      common/jack/thread.h
  51. +222
    -171
      common/jack/types.h
  52. +61
    -6
      common/jack/weakjack.h
  53. +20
    -12
      common/jack/weakmacros.h
  54. +87
    -42
      common/netjack.c
  55. +10
    -0
      common/netjack.h
  56. +14
    -60
      common/netjack_packet.c
  57. +0
    -6
      common/netjack_packet.h
  58. +6
    -5
      common/timestamps.c
  59. +53
    -13
      example-clients/alsa_in.c
  60. +53
    -9
      example-clients/alsa_out.c
  61. +13
    -2
      example-clients/bufsize.c
  62. +155
    -55
      example-clients/connect.c
  63. +215
    -0
      example-clients/latent_client.c
  64. +29
    -15
      example-clients/lsp.c
  65. +114
    -0
      example-clients/midi_dump.c
  66. +31
    -27
      example-clients/netsource.c
  67. +117
    -120
      example-clients/session_notify.c
  68. +2
    -6
      example-clients/wscript
  69. +5
    -2
      linux/JackAtomic_os.h
  70. +1
    -0
      linux/JackLinuxTime.c
  71. +82
    -64
      linux/alsa/JackAlsaDriver.cpp
  72. +13
    -13
      linux/alsa/alsa_rawmidi.c
  73. +8
    -8
      linux/alsa/alsa_seqmidi.c
  74. +5
    -5
      linux/alsa/usx2y.c
  75. +0
    -18
      linux/cycles.h
  76. +14
    -9
      linux/firewire/JackFFADODriver.cpp
  77. +10
    -7
      linux/freebob/JackFreebobDriver.cpp
  78. +1
    -1
      macosx/Jack-Info.plist
  79. +13
    -13
      macosx/JackMachThread.cpp
  80. +14
    -14
      macosx/JackMachThread.h
  81. +835
    -107
      macosx/Jackdmp.xcodeproj/project.pbxproj
  82. +152
    -142
      macosx/coreaudio/JackCoreAudioAdapter.cpp
  83. +158
    -146
      macosx/coreaudio/JackCoreAudioDriver.cpp
  84. +0
    -6
      macosx/wscript
  85. +53
    -0
      man/jack_iodelay.0
  86. +17
    -17
      posix/JackPosixMutex.h
  87. +32
    -32
      posix/JackPosixThread.cpp
  88. +13
    -13
      posix/JackPosixThread.h
  89. +20
    -20
      posix/JackSocket.cpp
  90. +37
    -26
      posix/JackSocketClientChannel.cpp
  91. +13
    -11
      posix/JackSocketClientChannel.h
  92. +46
    -18
      posix/JackSocketServerChannel.cpp
  93. +3
    -3
      posix/JackSocketServerChannel.h
  94. +4
    -2
      posix/JackSocketServerNotifyChannel.cpp
  95. +1
    -1
      posix/JackSocketServerNotifyChannel.h
  96. +2
    -0
      posix/JackSystemDeps_os.h
  97. +2
    -0
      posix/JackTypes_os.h
  98. +46
    -20
      tests/iodelay.cpp
  99. +1
    -1
      tests/wscript
  100. +1
    -1
      windows/JackRouter/JackRouter.dsp

+ 61
- 2
ChangeLog View File

@@ -27,16 +27,75 @@ Mario Lang
Arnold Krille
Jan Engelhardt
Adrian Knoth
David Garcia Garzon
David Garcia Garzon
Valerio Pilo
---------------------------
Jackdmp changes log
---------------------------

2011-03-11 Stephane Letz <letz@grame.fr>

* Correct JackNetMaster::SetBufferSize.

2011-03-10 Stephane Letz <letz@grame.fr>

* Latency callback must always be activated.
* Correct TopologicalSort.
* Add jack_midi_dump client.
* Synchronize netjack1 with JACK1 version.
* Synchronize jack_connect/jack_disconnect with JACK1 version.

2011-03-09 Stephane Letz <letz@grame.fr>

* jack_client_has_session_callback implementation.
* Fix jdelay for new latency API.
* Check requested buffer size and limit to 1..8192 - avoids wierd behaviour caused by jack_bufsize foobar.
* jack_port_type_get_buffer_size implementation.
* Stop using alloca and allocate buffer on the heap for alsa_io.
* Rename jdelay to jack_iodelay as per Fons' request.
* Call buffer size callback in activate (actually this is done on client side in the RT thread Init method).
* JackEngine::ComputeTotalLatencies in progress.

2011-03-08 Stephane Letz <letz@grame.fr>

* Use of latency range in all backends.
* ComputeTotalLatencies now a client/server call.
* Add latent test client for latency API.
* Also print playback and capture latency in jack_lsp.

2011-03-04 Stephane Letz <letz@grame.fr>

* Revert r4119 (RT notification in the server). JackAudioDriver::ProcessSync now skip backend write in case of graph process failure.
* Fix incorrect error codes in alsa/usx2y.c and alsa/JackAlsaDriver.cpp.
* Synchronize public headers with JACK1. Update OSX project.
* New latency API implementation (in progress).

2011-02-09 Stephane Letz <letz@grame.fr>

* Remove JackPortIsActive flag.

2011-02-07 Stephane Letz <letz@grame.fr>

* Valerio Pilo second CAS for ARMv7 patch.

2011-02-03 Stephane Letz <letz@grame.fr>

* Valerio Pilo CAS for ARMv7 patch.

2011-01-11 Stephane Letz <letz@grame.fr>

* Adrian Knoth jack_lsp patch.

2010-11-17 Stephane Letz <letz@grame.fr>

* ALSA backend : suspend/resume handling (jack1 r4075).
* Correct dummy driver.

2010-11-05 Stephane Letz <letz@grame.fr>

* In jackdmp.cpp, jackctl_setup_signals moved before jackctl_server_start.
* Correct symbols export in backends.
* Correct symbols export in backends on OSX.

2010-11-03 Stephane Letz <letz@grame.fr>



+ 255
- 153
common/JackAPI.cpp View File

@@ -41,7 +41,7 @@ extern "C"
{
#endif

typedef void (*print_function)(const char *);
typedef void (*print_function)(const char*);
typedef void *(*thread_routine)(void*);

EXPORT
@@ -53,198 +53,219 @@ extern "C"
int *proto_ptr);

EXPORT
const char *
const char*
jack_get_version_string();

jack_client_t * jack_client_new_aux (const char *client_name,
jack_client_t * jack_client_new_aux(const char* client_name,
jack_options_t options,
jack_status_t *status);
EXPORT jack_client_t * jack_client_open (const char *client_name,
EXPORT jack_client_t * jack_client_open(const char* client_name,
jack_options_t options,
jack_status_t *status, ...);
EXPORT jack_client_t * jack_client_new (const char *client_name);
EXPORT int jack_client_name_size (void);
EXPORT char* jack_get_client_name (jack_client_t *client);
EXPORT int jack_internal_client_new (const char *client_name,
const char *load_name,
const char *load_init);
EXPORT void jack_internal_client_close (const char *client_name);
EXPORT int jack_is_realtime (jack_client_t *client);
EXPORT void jack_on_shutdown (jack_client_t *client,
EXPORT jack_client_t * jack_client_new(const char* client_name);
EXPORT int jack_client_name_size(void);
EXPORT char* jack_get_client_name(jack_client_t *client);
EXPORT int jack_internal_client_new(const char* client_name,
const char* load_name,
const char* load_init);
EXPORT void jack_internal_client_close(const char* client_name);
EXPORT int jack_is_realtime(jack_client_t *client);
EXPORT void jack_on_shutdown(jack_client_t *client,
JackShutdownCallback shutdown_callback, void *arg);
EXPORT void jack_on_info_shutdown (jack_client_t *client,
EXPORT void jack_on_info_shutdown(jack_client_t *client,
JackInfoShutdownCallback shutdown_callback, void *arg);
EXPORT int jack_set_process_callback (jack_client_t *client,
EXPORT int jack_set_process_callback(jack_client_t *client,
JackProcessCallback process_callback,
void *arg);
EXPORT jack_nframes_t jack_thread_wait(jack_client_t *client, int status);

// new
EXPORT jack_nframes_t jack_cycle_wait (jack_client_t*);
EXPORT void jack_cycle_signal (jack_client_t*, int status);
EXPORT jack_nframes_t jack_cycle_wait(jack_client_t*);
EXPORT void jack_cycle_signal(jack_client_t*, int status);
EXPORT int jack_set_process_thread(jack_client_t* client, JackThreadCallback fun, void *arg);

EXPORT int jack_set_thread_init_callback (jack_client_t *client,
EXPORT int jack_set_thread_init_callback(jack_client_t *client,
JackThreadInitCallback thread_init_callback,
void *arg);
EXPORT int jack_set_freewheel_callback (jack_client_t *client,
EXPORT int jack_set_freewheel_callback(jack_client_t *client,
JackFreewheelCallback freewheel_callback,
void *arg);
EXPORT int jack_set_freewheel(jack_client_t* client, int onoff);
EXPORT int jack_set_buffer_size (jack_client_t *client, jack_nframes_t nframes);
EXPORT int jack_set_buffer_size_callback (jack_client_t *client,
EXPORT int jack_set_buffer_size(jack_client_t *client, jack_nframes_t nframes);
EXPORT int jack_set_buffer_size_callback(jack_client_t *client,
JackBufferSizeCallback bufsize_callback,
void *arg);
EXPORT int jack_set_sample_rate_callback (jack_client_t *client,
EXPORT int jack_set_sample_rate_callback(jack_client_t *client,
JackSampleRateCallback srate_callback,
void *arg);
EXPORT int jack_set_client_registration_callback (jack_client_t *,
EXPORT int jack_set_client_registration_callback(jack_client_t *,
JackClientRegistrationCallback
registration_callback, void *arg);
EXPORT int jack_set_port_registration_callback (jack_client_t *,
EXPORT int jack_set_port_registration_callback(jack_client_t *,
JackPortRegistrationCallback
registration_callback, void *arg);
EXPORT int jack_set_port_connect_callback (jack_client_t *,
EXPORT int jack_set_port_connect_callback(jack_client_t *,
JackPortConnectCallback
connect_callback, void *arg);
EXPORT int jack_set_port_rename_callback (jack_client_t *,
EXPORT int jack_set_port_rename_callback(jack_client_t *,
JackPortRenameCallback
rename_callback, void *arg);
EXPORT int jack_set_graph_order_callback (jack_client_t *,
EXPORT int jack_set_graph_order_callback(jack_client_t *,
JackGraphOrderCallback graph_callback,
void *);
EXPORT int jack_set_xrun_callback (jack_client_t *,
EXPORT int jack_set_xrun_callback(jack_client_t *,
JackXRunCallback xrun_callback, void *arg);
EXPORT int jack_activate (jack_client_t *client);
EXPORT int jack_deactivate (jack_client_t *client);
EXPORT jack_port_t * jack_port_register (jack_client_t *client,
const char *port_name,
const char *port_type,
EXPORT int jack_set_latency_callback(jack_client_t *client,
JackLatencyCallback callback, void *arg);

EXPORT int jack_activate(jack_client_t *client);
EXPORT int jack_deactivate(jack_client_t *client);
EXPORT jack_port_t * jack_port_register(jack_client_t *client,
const char* port_name,
const char* port_type,
unsigned long flags,
unsigned long buffer_size);
EXPORT int jack_port_unregister (jack_client_t *, jack_port_t *);
EXPORT void * jack_port_get_buffer (jack_port_t *, jack_nframes_t);
EXPORT const char * jack_port_name (const jack_port_t *port);
EXPORT const char * jack_port_short_name (const jack_port_t *port);
EXPORT int jack_port_flags (const jack_port_t *port);
EXPORT const char * jack_port_type (const jack_port_t *port);
EXPORT jack_port_type_id_t jack_port_type_id (const jack_port_t *port);
EXPORT int jack_port_is_mine (const jack_client_t *, const jack_port_t *port);
EXPORT int jack_port_connected (const jack_port_t *port);
EXPORT int jack_port_connected_to (const jack_port_t *port,
const char *port_name);
EXPORT const char ** jack_port_get_connections (const jack_port_t *port);
EXPORT const char ** jack_port_get_all_connections (const jack_client_t *client,
EXPORT int jack_port_unregister(jack_client_t *, jack_port_t *);
EXPORT void * jack_port_get_buffer(jack_port_t *, jack_nframes_t);
EXPORT const char* jack_port_name(const jack_port_t *port);
EXPORT const char* jack_port_short_name(const jack_port_t *port);
EXPORT int jack_port_flags(const jack_port_t *port);
EXPORT const char* jack_port_type(const jack_port_t *port);
EXPORT jack_port_type_id_t jack_port_type_id(const jack_port_t *port);
EXPORT int jack_port_is_mine(const jack_client_t *, const jack_port_t *port);
EXPORT int jack_port_connected(const jack_port_t *port);
EXPORT int jack_port_connected_to(const jack_port_t *port,
const char* port_name);
EXPORT const char* * jack_port_get_connections(const jack_port_t *port);
EXPORT const char* * jack_port_get_all_connections(const jack_client_t *client,
const jack_port_t *port);
EXPORT int jack_port_tie (jack_port_t *src, jack_port_t *dst);
EXPORT int jack_port_untie (jack_port_t *port);
EXPORT jack_nframes_t jack_port_get_latency (jack_port_t *port);
EXPORT jack_nframes_t jack_port_get_total_latency (jack_client_t *,
EXPORT int jack_port_tie(jack_port_t *src, jack_port_t *dst);
EXPORT int jack_port_untie(jack_port_t *port);

// Old latency API
EXPORT jack_nframes_t jack_port_get_latency(jack_port_t *port);
EXPORT jack_nframes_t jack_port_get_total_latency(jack_client_t *,
jack_port_t *port);
EXPORT void jack_port_set_latency (jack_port_t *, jack_nframes_t);
EXPORT int jack_recompute_total_latency (jack_client_t*, jack_port_t* port);
EXPORT int jack_recompute_total_latencies (jack_client_t*);
EXPORT int jack_port_set_name (jack_port_t *port, const char *port_name);
EXPORT int jack_port_set_alias (jack_port_t *port, const char *alias);
EXPORT int jack_port_unset_alias (jack_port_t *port, const char *alias);
EXPORT int jack_port_get_aliases (const jack_port_t *port, char* const aliases[2]);
EXPORT int jack_port_request_monitor (jack_port_t *port, int onoff);
EXPORT int jack_port_request_monitor_by_name (jack_client_t *client,
const char *port_name, int onoff);
EXPORT int jack_port_ensure_monitor (jack_port_t *port, int onoff);
EXPORT int jack_port_monitoring_input (jack_port_t *port);
EXPORT int jack_connect (jack_client_t *,
const char *source_port,
const char *destination_port);
EXPORT int jack_disconnect (jack_client_t *,
const char *source_port,
const char *destination_port);
EXPORT int jack_port_disconnect (jack_client_t *, jack_port_t *);
EXPORT void jack_port_set_latency(jack_port_t *, jack_nframes_t);
EXPORT int jack_recompute_total_latency(jack_client_t*, jack_port_t* port);

// New latency API
EXPORT void jack_port_get_latency_range(jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range);
EXPORT void jack_port_set_latency_range(jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range);
EXPORT int jack_recompute_total_latencies(jack_client_t*);

EXPORT int jack_port_set_name(jack_port_t *port, const char* port_name);
EXPORT int jack_port_set_alias(jack_port_t *port, const char* alias);
EXPORT int jack_port_unset_alias(jack_port_t *port, const char* alias);
EXPORT int jack_port_get_aliases(const jack_port_t *port, char* const aliases[2]);
EXPORT int jack_port_request_monitor(jack_port_t *port, int onoff);
EXPORT int jack_port_request_monitor_by_name(jack_client_t *client,
const char* port_name, int onoff);
EXPORT int jack_port_ensure_monitor(jack_port_t *port, int onoff);
EXPORT int jack_port_monitoring_input(jack_port_t *port);
EXPORT int jack_connect(jack_client_t *,
const char* source_port,
const char* destination_port);
EXPORT int jack_disconnect(jack_client_t *,
const char* source_port,
const char* destination_port);
EXPORT int jack_port_disconnect(jack_client_t *, jack_port_t *);
EXPORT int jack_port_name_size(void);
EXPORT int jack_port_type_size(void);
EXPORT jack_nframes_t jack_get_sample_rate (jack_client_t *);
EXPORT jack_nframes_t jack_get_buffer_size (jack_client_t *);
EXPORT const char ** jack_get_ports (jack_client_t *,
const char *port_name_pattern,
const char *type_name_pattern,
EXPORT size_t jack_port_type_get_buffer_size(jack_client_t *client, const char* port_type);
EXPORT jack_nframes_t jack_get_sample_rate(jack_client_t *);
EXPORT jack_nframes_t jack_get_buffer_size(jack_client_t *);
EXPORT const char* * jack_get_ports(jack_client_t *,
const char* port_name_pattern,
const char* type_name_pattern,
unsigned long flags);
EXPORT jack_port_t * jack_port_by_name (jack_client_t *, const char *port_name);
EXPORT jack_port_t * jack_port_by_id (jack_client_t *client,
EXPORT jack_port_t * jack_port_by_name(jack_client_t *, const char* port_name);
EXPORT jack_port_t * jack_port_by_id(jack_client_t *client,
jack_port_id_t port_id);
EXPORT int jack_engine_takeover_timebase (jack_client_t *);
EXPORT jack_nframes_t jack_frames_since_cycle_start (const jack_client_t *);
EXPORT int jack_engine_takeover_timebase(jack_client_t *);
EXPORT jack_nframes_t jack_frames_since_cycle_start(const jack_client_t *);
EXPORT jack_time_t jack_get_time();
EXPORT jack_nframes_t jack_time_to_frames(const jack_client_t *client, jack_time_t time);
EXPORT jack_time_t jack_frames_to_time(const jack_client_t *client, jack_nframes_t frames);
EXPORT jack_nframes_t jack_frame_time (const jack_client_t *);
EXPORT jack_nframes_t jack_last_frame_time (const jack_client_t *client);
EXPORT float jack_cpu_load (jack_client_t *client);
EXPORT pthread_t jack_client_thread_id (jack_client_t *);
EXPORT void jack_set_error_function (print_function);
EXPORT void jack_set_info_function (print_function);
EXPORT float jack_get_max_delayed_usecs (jack_client_t *client);
EXPORT float jack_get_xrun_delayed_usecs (jack_client_t *client);
EXPORT void jack_reset_max_delayed_usecs (jack_client_t *client);
EXPORT int jack_release_timebase (jack_client_t *client);
EXPORT int jack_set_sync_callback (jack_client_t *client,
EXPORT jack_nframes_t jack_frame_time(const jack_client_t *);
EXPORT jack_nframes_t jack_last_frame_time(const jack_client_t *client);
EXPORT float jack_cpu_load(jack_client_t *client);
EXPORT jack_native_thread_t jack_client_thread_id(jack_client_t *);
EXPORT void jack_set_error_function(print_function);
EXPORT void jack_set_info_function(print_function);
EXPORT float jack_get_max_delayed_usecs(jack_client_t *client);
EXPORT float jack_get_xrun_delayed_usecs(jack_client_t *client);
EXPORT void jack_reset_max_delayed_usecs(jack_client_t *client);
EXPORT int jack_release_timebase(jack_client_t *client);
EXPORT int jack_set_sync_callback(jack_client_t *client,
JackSyncCallback sync_callback,
void *arg);
EXPORT int jack_set_sync_timeout (jack_client_t *client,
EXPORT int jack_set_sync_timeout(jack_client_t *client,
jack_time_t timeout);
EXPORT int jack_set_timebase_callback (jack_client_t *client,
EXPORT int jack_set_timebase_callback(jack_client_t *client,
int conditional,
JackTimebaseCallback timebase_callback,
void *arg);
EXPORT int jack_transport_locate (jack_client_t *client,
EXPORT int jack_transport_locate(jack_client_t *client,
jack_nframes_t frame);
EXPORT jack_transport_state_t jack_transport_query (const jack_client_t *client,
EXPORT jack_transport_state_t jack_transport_query(const jack_client_t *client,
jack_position_t *pos);
EXPORT jack_nframes_t jack_get_current_transport_frame (const jack_client_t *client);
EXPORT int jack_transport_reposition (jack_client_t *client,
EXPORT jack_nframes_t jack_get_current_transport_frame(const jack_client_t *client);
EXPORT int jack_transport_reposition(jack_client_t *client,
jack_position_t *pos);
EXPORT void jack_transport_start (jack_client_t *client);
EXPORT void jack_transport_stop (jack_client_t *client);
EXPORT void jack_get_transport_info (jack_client_t *client,
EXPORT void jack_transport_start(jack_client_t *client);
EXPORT void jack_transport_stop(jack_client_t *client);
EXPORT void jack_get_transport_info(jack_client_t *client,
jack_transport_info_t *tinfo);
EXPORT void jack_set_transport_info (jack_client_t *client,
EXPORT void jack_set_transport_info(jack_client_t *client,
jack_transport_info_t *tinfo);

EXPORT int jack_client_real_time_priority (jack_client_t*);
EXPORT int jack_client_max_real_time_priority (jack_client_t*);
EXPORT int jack_acquire_real_time_scheduling (pthread_t thread, int priority);
EXPORT int jack_client_create_thread (jack_client_t* client,
pthread_t *thread,
EXPORT int jack_client_real_time_priority(jack_client_t*);
EXPORT int jack_client_max_real_time_priority(jack_client_t*);
EXPORT int jack_acquire_real_time_scheduling(jack_native_thread_t thread, int priority);
EXPORT int jack_client_create_thread(jack_client_t* client,
jack_native_thread_t *thread,
int priority,
int realtime, // boolean
thread_routine routine,
void *arg);
EXPORT int jack_drop_real_time_scheduling (pthread_t thread);
EXPORT int jack_drop_real_time_scheduling(jack_native_thread_t thread);

EXPORT int jack_client_stop_thread (jack_client_t* client, pthread_t thread);
EXPORT int jack_client_kill_thread (jack_client_t* client, pthread_t thread);
EXPORT int jack_client_stop_thread(jack_client_t* client, jack_native_thread_t thread);
EXPORT int jack_client_kill_thread(jack_client_t* client, jack_native_thread_t thread);
#ifndef WIN32
EXPORT void jack_set_thread_creator (jack_thread_creator_t jtc);
EXPORT void jack_set_thread_creator(jack_thread_creator_t jtc);
#endif
EXPORT char * jack_get_internal_client_name (jack_client_t *client,
EXPORT char * jack_get_internal_client_name(jack_client_t *client,
jack_intclient_t intclient);
EXPORT jack_intclient_t jack_internal_client_handle (jack_client_t *client,
const char *client_name,
EXPORT jack_intclient_t jack_internal_client_handle(jack_client_t *client,
const char* client_name,
jack_status_t *status);
EXPORT jack_intclient_t jack_internal_client_load (jack_client_t *client,
const char *client_name,
EXPORT jack_intclient_t jack_internal_client_load(jack_client_t *client,
const char* client_name,
jack_options_t options,
jack_status_t *status, ...);
EXPORT jack_intclient_t jack_internal_client_load_aux (jack_client_t *client,
const char *client_name,
EXPORT jack_intclient_t jack_internal_client_load_aux(jack_client_t *client,
const char* client_name,
jack_options_t options,
jack_status_t *status, va_list ap);

EXPORT jack_status_t jack_internal_client_unload (jack_client_t *client,
EXPORT jack_status_t jack_internal_client_unload(jack_client_t *client,
jack_intclient_t intclient);
EXPORT void jack_free(void* ptr);

EXPORT int jack_set_session_callback(jack_client_t* ext_client, JackSessionCallback session_callback, void* arg);
EXPORT jack_session_command_t *jack_session_notify(jack_client_t* ext_client, const char* target, jack_session_event_type_t ev_type, const char* path);
EXPORT int jack_session_reply(jack_client_t* ext_client, jack_session_event_t *event);
EXPORT void jack_session_event_free(jack_session_event_t* ev);
EXPORT char* jack_get_uuid_for_client_name(jack_client_t* ext_client, const char* client_name);
EXPORT char* jack_get_client_name_by_uuid(jack_client_t* ext_client, const char* client_uuid);
EXPORT int jack_reserve_client_name(jack_client_t* ext_client, const char* name, const char* uuid);
EXPORT void jack_session_commands_free(jack_session_command_t *cmds);
EXPORT int jack_client_has_session_callback(jack_client_t *client, const char* client_name);

#ifdef __cplusplus
}
#endif
@@ -256,7 +277,7 @@ static inline bool CheckPort(jack_port_id_t port_index)

static inline bool CheckBufferSize(jack_nframes_t buffer_size)
{
return (buffer_size <= BUFFER_SIZE_MAX);
return (buffer_size >= 1 && buffer_size <= BUFFER_SIZE_MAX);
}

static inline void WaitGraphChange()
@@ -278,12 +299,12 @@ static inline void WaitGraphChange()
}
}

EXPORT void jack_set_error_function (print_function func)
EXPORT void jack_set_error_function(print_function func)
{
jack_error_callback = (func == NULL) ? &default_jack_error_callback : func;
}

EXPORT void jack_set_info_function (print_function func)
EXPORT void jack_set_info_function(print_function func)
{
jack_info_callback = (func == NULL) ? &default_jack_info_callback : func;
}
@@ -526,6 +547,40 @@ EXPORT void jack_port_set_latency(jack_port_t* port, jack_nframes_t frames)
}
}

EXPORT void jack_port_get_latency_range(jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range)
{
#ifdef __CLIENTDEBUG__
JackGlobals::CheckContext("jack_port_get_latency_range");
#endif
uintptr_t port_aux = (uintptr_t)port;
jack_port_id_t myport = (jack_port_id_t)port_aux;
if (!CheckPort(myport)) {
jack_error("jack_port_get_latency_range called with an incorrect port %ld", myport);
} else {
WaitGraphChange();
JackGraphManager* manager = GetGraphManager();
if (manager)
manager->GetPort(myport)->GetLatencyRange(mode, range);
}
}

EXPORT void jack_port_set_latency_range(jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range)
{
#ifdef __CLIENTDEBUG__
JackGlobals::CheckContext("jack_port_set_latency_range");
#endif
uintptr_t port_aux = (uintptr_t)port;
jack_port_id_t myport = (jack_port_id_t)port_aux;
if (!CheckPort(myport)) {
jack_error("jack_port_set_latency_range called with an incorrect port %ld", myport);
} else {
WaitGraphChange();
JackGraphManager* manager = GetGraphManager();
if (manager)
manager->GetPort(myport)->SetLatencyRange(mode, range);
}
}

EXPORT int jack_recompute_total_latency(jack_client_t* ext_client, jack_port_t* port)
{
#ifdef __CLIENTDEBUG__
@@ -536,10 +591,10 @@ EXPORT int jack_recompute_total_latency(jack_client_t* ext_client, jack_port_t*
uintptr_t port_aux = (uintptr_t)port;
jack_port_id_t myport = (jack_port_id_t)port_aux;
if (client == NULL) {
jack_error("jack_recompute_total_latencies called with a NULL client");
jack_error("jack_recompute_total_latency called with a NULL client");
return -1;
} else if (!CheckPort(myport)) {
jack_error("jack_recompute_total_latencies called with a NULL port");
jack_error("jack_recompute_total_latency called with a NULL port");
return -1;
} else {
WaitGraphChange();
@@ -559,9 +614,7 @@ EXPORT int jack_recompute_total_latencies(jack_client_t* ext_client)
jack_error("jack_recompute_total_latencies called with a NULL client");
return -1;
} else {
WaitGraphChange();
JackGraphManager* manager = GetGraphManager();
return (manager ? manager->ComputeTotalLatencies() : -1);
return client->ComputeTotalLatencies();
}
}

@@ -988,6 +1041,20 @@ EXPORT int jack_set_xrun_callback(jack_client_t* ext_client, JackXRunCallback xr
}
}

EXPORT int jack_set_latency_callback(jack_client_t* ext_client, JackLatencyCallback latency_callback, void *arg)
{
#ifdef __CLIENTDEBUG__
JackGlobals::CheckContext("jack_set_latency_callback");
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_set_latency_callback called with a NULL client");
return -1;
} else {
return client->SetLatencyCallback(latency_callback, arg);
}
}

EXPORT int jack_set_thread_init_callback(jack_client_t* ext_client, JackThreadInitCallback init_callback, void *arg)
{
#ifdef __CLIENTDEBUG__
@@ -1396,7 +1463,7 @@ EXPORT float jack_cpu_load(jack_client_t* ext_client)
}
}

EXPORT pthread_t jack_client_thread_id(jack_client_t* ext_client)
EXPORT jack_native_thread_t jack_client_thread_id(jack_client_t* ext_client)
{
#ifdef __CLIENTDEBUG__
JackGlobals::CheckContext("jack_client_thread_id");
@@ -1404,7 +1471,7 @@ EXPORT pthread_t jack_client_thread_id(jack_client_t* ext_client)
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_client_thread_id called with a NULL client");
return (pthread_t)NULL;
return (jack_native_thread_t)NULL;
} else {
return client->GetThreadID();
}
@@ -1439,6 +1506,26 @@ EXPORT int jack_port_type_size(void)
return JACK_PORT_TYPE_SIZE;
}

EXPORT size_t jack_port_type_get_buffer_size(jack_client_t* ext_client, const char* port_type)
{
#ifdef __CLIENTDEBUG__
JackGlobals::CheckContext("jack_port_type_get_buffer_size");
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_port_type_get_buffer_size called with a NULL client");
return 0;
} else {
jack_port_type_id_t port_id = GetPortTypeId(port_type);
if (port_id == PORT_TYPES_MAX) {
jack_error("jack_port_type_get_buffer_size called with an unknown port type = %s", port_type);
return 0;
} else {
return GetPortType(port_id)->size();
}
}
}

// transport.h
EXPORT int jack_release_timebase(jack_client_t* ext_client)
{
@@ -1595,7 +1682,7 @@ EXPORT void jack_set_transport_info(jack_client_t* ext_client, jack_transport_in
{
#ifdef __CLIENTDEBUG__
JackGlobals::CheckContext("jack_set_transport_info");
#endif
#endif
jack_error("jack_set_transport_info: deprecated");
if (tinfo)
memset(tinfo, 0, sizeof(jack_transport_info_t));
@@ -1677,14 +1764,14 @@ EXPORT int jack_client_max_real_time_priority(jack_client_t* ext_client)
}
}

EXPORT int jack_acquire_real_time_scheduling(pthread_t thread, int priority)
EXPORT int jack_acquire_real_time_scheduling(jack_native_thread_t thread, int priority)
{
JackEngineControl* control = GetEngineControl();
return (control ? JackThread::AcquireRealTimeImp(thread, priority, GetEngineControl()->fPeriod, GetEngineControl()->fComputation, GetEngineControl()->fConstraint) : -1);
}

EXPORT int jack_client_create_thread(jack_client_t* client,
pthread_t *thread,
jack_native_thread_t *thread,
int priority,
int realtime, /* boolean */
thread_routine routine,
@@ -1692,28 +1779,28 @@ EXPORT int jack_client_create_thread(jack_client_t* client,
{
#ifdef __CLIENTDEBUG__
JackGlobals::CheckContext("jack_client_create_thread");
#endif
#endif
return JackThread::StartImp(thread, priority, realtime, routine, arg);
}

EXPORT int jack_drop_real_time_scheduling(pthread_t thread)
EXPORT int jack_drop_real_time_scheduling(jack_native_thread_t thread)
{
return JackThread::DropRealTimeImp(thread);
}

EXPORT int jack_client_stop_thread(jack_client_t* client, pthread_t thread)
EXPORT int jack_client_stop_thread(jack_client_t* client, jack_native_thread_t thread)
{
#ifdef __CLIENTDEBUG__
JackGlobals::CheckContext("jack_client_stop_thread");
#endif
#endif
return JackThread::StopImp(thread);
}

EXPORT int jack_client_kill_thread(jack_client_t* client, pthread_t thread)
EXPORT int jack_client_kill_thread(jack_client_t* client, jack_native_thread_t thread)
{
#ifdef __CLIENTDEBUG__
JackGlobals::CheckContext("jack_client_kill_thread");
#endif
#endif
return JackThread::KillImp(thread);
}

@@ -1725,15 +1812,15 @@ EXPORT void jack_set_thread_creator (jack_thread_creator_t jtc)
#endif

// intclient.h
EXPORT int jack_internal_client_new (const char *client_name,
const char *load_name,
const char *load_init)
EXPORT int jack_internal_client_new (const char* client_name,
const char* load_name,
const char* load_init)
{
jack_error("jack_internal_client_new: deprecated");
return -1;
}

EXPORT void jack_internal_client_close (const char *client_name)
EXPORT void jack_internal_client_close (const char* client_name)
{
jack_error("jack_internal_client_close: deprecated");
}
@@ -1803,7 +1890,7 @@ EXPORT jack_intclient_t jack_internal_client_load_aux(jack_client_t* ext_client,
}
}

EXPORT jack_intclient_t jack_internal_client_load(jack_client_t *client, const char *client_name, jack_options_t options, jack_status_t *status, ...)
EXPORT jack_intclient_t jack_internal_client_load(jack_client_t *client, const char* client_name, jack_options_t options, jack_status_t *status, ...)
{
va_list ap;
va_start(ap, status);
@@ -1847,7 +1934,7 @@ jack_get_version(
}

EXPORT
const char *
const char*
jack_get_version_string()
{
return VERSION;
@@ -1876,7 +1963,7 @@ EXPORT int jack_set_session_callback(jack_client_t* ext_client, JackSessionCallb
}
}

EXPORT jack_session_command_t *jack_session_notify(jack_client_t* ext_client, const char* target, jack_session_event_type_t ev_type, const char *path)
EXPORT jack_session_command_t *jack_session_notify(jack_client_t* ext_client, const char* target, jack_session_event_type_t ev_type, const char* path)
{
#ifdef __CLIENTDEBUG__
JackGlobals::CheckContext("jack_session_notify");
@@ -1891,7 +1978,7 @@ EXPORT jack_session_command_t *jack_session_notify(jack_client_t* ext_client, co
}
}

EXPORT int jack_session_reply(jack_client_t *ext_client, jack_session_event_t *event)
EXPORT int jack_session_reply(jack_client_t* ext_client, jack_session_event_t *event)
{
#ifdef __CLIENTDEBUG__
JackGlobals::CheckContext("jack_session_reply");
@@ -1919,7 +2006,7 @@ EXPORT void jack_session_event_free(jack_session_event_t* ev)
}
}

EXPORT char *jack_get_uuid_for_client_name( jack_client_t *ext_client, const char *client_name )
EXPORT char *jack_get_uuid_for_client_name(jack_client_t* ext_client, const char* client_name)
{
#ifdef __CLIENTDEBUG__
JackGlobals::CheckContext("jack_get_uuid_for_client_name");
@@ -1934,7 +2021,7 @@ EXPORT char *jack_get_uuid_for_client_name( jack_client_t *ext_client, const cha
}
}

EXPORT char *jack_get_client_name_by_uuid( jack_client_t *ext_client, const char *client_uuid )
EXPORT char *jack_get_client_name_by_uuid(jack_client_t* ext_client, const char* client_uuid)
{
#ifdef __CLIENTDEBUG__
JackGlobals::CheckContext("jack_get_client_name_by_uuid");
@@ -1945,11 +2032,11 @@ EXPORT char *jack_get_client_name_by_uuid( jack_client_t *ext_client, const char
jack_error("jack_get_client_name_by_uuid called with a NULL client");
return NULL;
} else {
return client->GetClientNameForUUID(client_uuid);
return client->GetClientNameByUUID(client_uuid);
}
}

EXPORT int jack_reserve_client_name( jack_client_t *ext_client, const char *name, const char *uuid )
EXPORT int jack_reserve_client_name(jack_client_t* ext_client, const char* client_name, const char* uuid)
{
#ifdef __CLIENTDEBUG__
JackGlobals::CheckContext("jack_reserve_client_name");
@@ -1960,17 +2047,17 @@ EXPORT int jack_reserve_client_name( jack_client_t *ext_client, const char *name
jack_error("jack_reserve_client_name called with a NULL client");
return -1;
} else {
return client->ReserveClientName(name, uuid);
return client->ReserveClientName(client_name, uuid);
}
}

EXPORT void jack_session_commands_free( jack_session_command_t *cmds )
EXPORT void jack_session_commands_free(jack_session_command_t *cmds)
{
if (!cmds)
return;

int i=0;
while(1) {
int i = 0;
while (1) {
if (cmds[i].client_name)
free ((char *)cmds[i].client_name);
if (cmds[i].command)
@@ -1985,3 +2072,18 @@ EXPORT void jack_session_commands_free( jack_session_command_t *cmds )

free(cmds);
}

EXPORT int jack_client_has_session_callback(jack_client_t* ext_client, const char* client_name)
{
#ifdef __CLIENTDEBUG__
JackGlobals::CheckContext("jack_client_has_session_callback");
#endif
JackClient* client = (JackClient*)ext_client;
jack_log("jack_client_has_session_callback ext_client %x client %x ", ext_client, client);
if (client == NULL) {
jack_error("jack_client_has_session_callback called with a NULL client");
return -1;
} else {
return client->ClientHasSessionCallback(client_name);
}
}

+ 78
- 22
common/JackAudioDriver.cpp View File

@@ -101,6 +101,7 @@ int JackAudioDriver::Attach()
jack_port_id_t port_index;
char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];
char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];
jack_latency_range_t range;
int i;

jack_log("JackAudioDriver::Attach fBufferSize = %ld fSampleRate = %ld", fEngineControl->fBufferSize, fEngineControl->fSampleRate);
@@ -114,7 +115,8 @@ int JackAudioDriver::Attach()
}
port = fGraphManager->GetPort(port_index);
port->SetAlias(alias);
port->SetLatency(fEngineControl->fBufferSize + fCaptureLatency);
range.min = range.max = fEngineControl->fBufferSize + fCaptureLatency;
port->SetLatencyRange(JackCaptureLatency, &range);
fCapturePortList[i] = port_index;
jack_log("JackAudioDriver::Attach fCapturePortList[i] port_index = %ld", port_index);
}
@@ -129,7 +131,8 @@ int JackAudioDriver::Attach()
port = fGraphManager->GetPort(port_index);
port->SetAlias(alias);
// Add more latency if "async" mode is used...
port->SetLatency(fEngineControl->fBufferSize + ((fEngineControl->fSyncMode) ? 0 : fEngineControl->fBufferSize) + fPlaybackLatency);
range.min = range.max = fEngineControl->fBufferSize + ((fEngineControl->fSyncMode) ? 0 : fEngineControl->fBufferSize) + fPlaybackLatency;
port->SetLatencyRange(JackPlaybackLatency, &range);
fPlaybackPortList[i] = port_index;
jack_log("JackAudioDriver::Attach fPlaybackPortList[i] port_index = %ld", port_index);

@@ -143,7 +146,8 @@ int JackAudioDriver::Attach()
} else {
port = fGraphManager->GetPort(port_index);
port->SetAlias(alias);
port->SetLatency(fEngineControl->fBufferSize);
range.min = range.max = fEngineControl->fBufferSize;
port->SetLatencyRange(JackCaptureLatency, &range);
fMonitorPortList[i] = port_index;
}
}
@@ -188,13 +192,13 @@ int JackAudioDriver::ProcessNull()
{
// Keep begin cycle time
JackDriver::CycleTakeBeginTime();
if (fEngineControl->fSyncMode) {
ProcessGraphSync();
} else {
ProcessGraphAsync();
}
// Keep end cycle time
JackDriver::CycleTakeEndTime();
WaitUntilNextCycle();
@@ -214,23 +218,24 @@ synchronize to the end of client graph execution.
int JackAudioDriver::ProcessAsync()
{
// Read input buffers for the current cycle
if (Read() < 0) {
if (Read() < 0) {
jack_error("JackAudioDriver::ProcessAsync: read error, stopping...");
return -1;
return -1;
}

// Write output buffers from the previous cycle
if (Write() < 0) {
jack_error("JackAudioDriver::ProcessAsync: write error, stopping...");
return -1;
return -1;
}

// Process graph
if (fIsMaster) {
ProcessGraphAsync();
} else {
fGraphManager->ResumeRefNum(&fClientControl, fSynchroTable);
}
// Keep end cycle time
JackDriver::CycleTakeEndTime();
return 0;
@@ -238,29 +243,38 @@ int JackAudioDriver::ProcessAsync()

/*
The driver SYNC mode: the server does synchronize to the end of client graph execution,
output buffers computed at the *current cycle* are used.
if graph process succeed, output buffers computed at the *current cycle* are used.
*/

int JackAudioDriver::ProcessSync()
{
// Read input buffers for the current cycle
if (Read() < 0) {
if (Read() < 0) {
jack_error("JackAudioDriver::ProcessSync: read error, stopping...");
return -1;
return -1;
}

// Process graph
if (fIsMaster) {
ProcessGraphSync();
if (ProcessGraphSync() < 0) {
jack_error("JackAudioDriver::ProcessSync: process error, skip cycle...");
goto end;
}
} else {
fGraphManager->ResumeRefNum(&fClientControl, fSynchroTable);
if (fGraphManager->ResumeRefNum(&fClientControl, fSynchroTable) < 0) {
jack_error("JackAudioDriver::ProcessSync: process error, skip cycle...");
goto end;
}
}
// Write output buffers from the current cycle
if (Write() < 0) {
jack_error("JackAudioDriver::ProcessSync: write error, stopping...");
return -1;
return -1;
}

end:

// Keep end cycle time
JackDriver::CycleTakeEndTime();
return 0;
@@ -269,25 +283,34 @@ int JackAudioDriver::ProcessSync()
void JackAudioDriver::ProcessGraphAsync()
{
// fBeginDateUst is set in the "low level" layer, fEndDateUst is from previous cycle
if (!fEngine->Process(fBeginDateUst, fEndDateUst))
if (!fEngine->Process(fBeginDateUst, fEndDateUst))
jack_error("JackAudioDriver::ProcessGraphAsync: Process error");
fGraphManager->ResumeRefNum(&fClientControl, fSynchroTable);
if (ProcessSlaves() < 0)
jack_error("JackAudioDriver::ProcessGraphAsync: ProcessSlaves error");
}

void JackAudioDriver::ProcessGraphSync()
int JackAudioDriver::ProcessGraphSync()
{
int res = 0;

// fBeginDateUst is set in the "low level" layer, fEndDateUst is from previous cycle
if (fEngine->Process(fBeginDateUst, fEndDateUst)) {
if (fEngine->Process(fBeginDateUst, fEndDateUst)) {
fGraphManager->ResumeRefNum(&fClientControl, fSynchroTable);
if (ProcessSlaves() < 0)
if (ProcessSlaves() < 0) {
jack_error("JackAudioDriver::ProcessGraphSync: ProcessSlaves error, engine may now behave abnormally!!");
if (fGraphManager->SuspendRefNum(&fClientControl, fSynchroTable, DRIVER_TIMEOUT_FACTOR * fEngineControl->fTimeOutUsecs) < 0)
res = -1;
}
if (fGraphManager->SuspendRefNum(&fClientControl, fSynchroTable, DRIVER_TIMEOUT_FACTOR * fEngineControl->fTimeOutUsecs) < 0) {
jack_error("JackAudioDriver::ProcessGraphSync: SuspendRefNum error, engine may now behave abnormally!!");
res = -1;
}
} else { // Graph not finished: do not activate it
jack_error("JackAudioDriver::ProcessGraphSync: Process error");
res = -1;
}

return res;
}

void JackAudioDriver::WaitUntilNextCycle()
@@ -316,4 +339,37 @@ jack_default_audio_sample_t* JackAudioDriver::GetMonitorBuffer(int port_index)
return (jack_default_audio_sample_t*)fGraphManager->GetBuffer(fMonitorPortList[port_index], fEngineControl->fBufferSize);
}

int JackAudioDriver::ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2)
{
switch (notify) {

case kLatencyCallback:
HandleLatencyCallback(value1);
break;

default:
JackDriver::ClientNotify(refnum, name, notify, sync, message, value1, value2);
break;
}

return 0;
}

void JackAudioDriver::HandleLatencyCallback(int status)
{
jack_latency_callback_mode_t mode = (status == 0) ? JackCaptureLatency : JackPlaybackLatency;

for (int i = 0; i < fCaptureChannels; i++) {
if (mode == JackPlaybackLatency) {
fGraphManager->RecalculateLatency(fCapturePortList[i], mode);
}
}

for (int i = 0; i < fPlaybackChannels; i++) {
if (mode == JackCaptureLatency) {
fGraphManager->RecalculateLatency(fPlaybackPortList[i], mode);
}
}
}

} // end of namespace

+ 9
- 5
common/JackAudioDriver.h View File

@@ -36,12 +36,12 @@ class SERVER_EXPORT JackAudioDriver : public JackDriver
protected:

void ProcessGraphAsync();
void ProcessGraphSync();
int ProcessGraphSync();
void WaitUntilNextCycle();

virtual int ProcessAsync();
virtual int ProcessSync();
int fCaptureChannels;
int fPlaybackChannels;

@@ -57,6 +57,8 @@ class SERVER_EXPORT JackAudioDriver : public JackDriver
jack_default_audio_sample_t* GetOutputBuffer(int port_index);
jack_default_audio_sample_t* GetMonitorBuffer(int port_index);

void HandleLatencyCallback(int status);

public:

JackAudioDriver(const char* name, const char* alias, JackLockedEngine* engine, JackSynchro* table);
@@ -73,7 +75,7 @@ class SERVER_EXPORT JackAudioDriver : public JackDriver
const char* playback_driver_name,
jack_nframes_t capture_latency,
jack_nframes_t playback_latency);
virtual int Open(bool capturing,
bool playing,
int inchannels,
@@ -83,18 +85,20 @@ class SERVER_EXPORT JackAudioDriver : public JackDriver
const char* playback_driver_name,
jack_nframes_t capture_latency,
jack_nframes_t playback_latency);
virtual int Process();
virtual int ProcessNull();

virtual int Attach();
virtual int Detach();
virtual int Write();

virtual int SetBufferSize(jack_nframes_t buffer_size);
virtual int SetSampleRate(jack_nframes_t sample_rate);

virtual int ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2);

};

} // end of namespace


+ 16
- 7
common/JackAudioPort.cpp View File

@@ -18,7 +18,10 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

*/

#include "JackGlobals.h"
#include "JackEngineControl.h"
#include "JackPortType.h"

#include <string.h>

#if defined (__APPLE__)
@@ -46,7 +49,7 @@ static inline void MixAudioBuffer(float* mixbuffer, float* buffer, jack_nframes_
frames = frames % 4;

while (frames_group > 0) {
#if defined (__SSE__) && !defined (__sun__)
#if defined (__SSE__) && !defined (__sun__)
__m128 vec = _mm_add_ps(_mm_load_ps(mixbuffer), _mm_load_ps(buffer));
_mm_store_ps(mixbuffer, vec);

@@ -97,7 +100,7 @@ static void AudioBufferMixdown(void* mixbuffer, void** src_buffers, int src_coun
void* buffer;

// Copy first buffer
#if defined (__SSE__) && !defined (__sun__)
#if defined (__SSE__) && !defined (__sun__)
jack_nframes_t frames_group = nframes / 4;
jack_nframes_t remaining_frames = nframes % 4;

@@ -127,12 +130,18 @@ static void AudioBufferMixdown(void* mixbuffer, void** src_buffers, int src_coun
}
}

static size_t AudioBufferSize()
{
return GetEngineControl()->fBufferSize * sizeof(float);
}

const JackPortType gAudioPortType =
{
JACK_DEFAULT_AUDIO_TYPE,
AudioBufferInit,
AudioBufferMixdown
};
{
JACK_DEFAULT_AUDIO_TYPE,
AudioBufferSize,
AudioBufferInit,
AudioBufferMixdown
};

} // namespace Jack


+ 13
- 18
common/JackChannel.h View File

@@ -12,7 +12,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

*/
@@ -20,7 +20,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#ifndef __JackChannel__
#define __JackChannel__

#include "types.h"
#include "session.h"

namespace Jack
@@ -108,43 +107,39 @@ class JackClientChannelInterface
{}
virtual void SetFreewheel(int onoff, int* result)
{}
virtual void ComputeTotalLatencies(int* result)
{}

virtual void ReleaseTimebase(int refnum, int* result)
{}

virtual void SetTimebaseCallback(int refnum, int conditional, int* result)
{}

virtual void GetInternalClientName(int refnum, int int_ref, char* name_res, int* result)
{}

virtual void InternalClientHandle(int refnum, const char* client_name, int* status, int* int_ref, int* result)
{}

virtual void InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int uuid, int* result)
{}

virtual void InternalClientUnload(int refnum, int int_ref, int* status, int* result)
{}
virtual void SessionNotify(int refnum, const char* target, jack_session_event_type_t type, const char *path, jack_session_command_t **result)
{}

virtual void SessionReply(int refnum, int *result)
virtual void SessionNotify(int refnum, const char* target, jack_session_event_type_t type, const char* path, jack_session_command_t** result)
{}

virtual void GetUUIDForClientName(int refnum, const char *client_name, char *uuid_res, int *result)
virtual void SessionReply(int refnum, int* result)
{}

virtual void GetClientNameForUUID(int refnum, const char *uuid, char *name_res, int *result)
virtual void GetUUIDForClientName(int refnum, const char* client_name, char* uuid_res, int* result)
{}

virtual void ReserveClientName(int refnum, const char *client_name, const char *uuid, int *result)
virtual void GetClientNameForUUID(int refnum, const char* uuid, char* name_res, int* result)
{}
virtual void ReserveClientName(int refnum, const char* client_name, const char *uuid, int* result)
{}
virtual void ClientHasSessionCallback(const char* client_name, int* result)
{}

virtual bool IsChannelThread()
{
return false;
{
return false;
}
};



+ 232
- 92
common/JackClient.cpp View File

@@ -13,12 +13,12 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

*/

#include "JackClient.h"
#include "JackSystemDeps.h"
#include "JackGraphManager.h"
#include "JackClientControl.h"
#include "JackEngineControl.h"
@@ -28,6 +28,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "driver_interface.h"
#include "JackLibGlobals.h"


#include <math.h>
#include <string>
#include <algorithm>
@@ -60,6 +61,9 @@ JackClient::JackClient(JackSynchro* table):fThread(this)
fTimebase = NULL;
fSync = NULL;
fThreadFun = NULL;
fSession = NULL;
fLatency = NULL;

fProcessArg = NULL;
fGraphOrderArg = NULL;
fXrunArg = NULL;
@@ -75,6 +79,8 @@ JackClient::JackClient(JackSynchro* table):fThread(this)
fSyncArg = NULL;
fTimebaseArg = NULL;
fThreadFunArg = NULL;
fSessionArg = NULL;
fLatencyArg = NULL;
}

JackClient::~JackClient()
@@ -84,17 +90,17 @@ int JackClient::Close()
{
jack_log("JackClient::Close ref = %ld", GetClientControl()->fRefNum);
int result = 0;
Deactivate();
fChannel->Stop(); // Channels is stopped first to avoid receiving notifications while closing
// Request close only if server is still running
if (JackGlobals::fServerRunning) {
fChannel->ClientClose(GetClientControl()->fRefNum, &result);
} else {
jack_log("JackClient::Close server is shutdown");
jack_log("JackClient::Close server is shutdown");
}
fChannel->Close();
fSynchroTable[GetClientControl()->fRefNum].Disconnect();
JackGlobals::fClientTable[GetClientControl()->fRefNum] = NULL;
@@ -106,7 +112,7 @@ bool JackClient::IsActive()
return (GetClientControl()) ? GetClientControl()->fActive : false;
}

pthread_t JackClient::GetThreadID()
jack_native_thread_t JackClient::GetThreadID()
{
return fThread.GetThreadID();
}
@@ -156,7 +162,7 @@ int JackClient::ClientNotify(int refnum, const char* name, int notify, int sync,

case kActivateClient:
jack_log("JackClient::kActivateClient name = %s ref = %ld ", name, refnum);
Init();
InitAux();
break;
}

@@ -188,7 +194,7 @@ int JackClient::ClientNotify(int refnum, const char* name, int notify, int sync,
res = fBufferSize(value1, fBufferSizeArg);
}
break;
case kSampleRateCallback:
jack_log("JackClient::kSampleRateCallback sample_rate = %ld", value1);
if (fSampleRate) {
@@ -219,7 +225,9 @@ int JackClient::ClientNotify(int refnum, const char* name, int notify, int sync,
fFreewheel(0, fFreewheelArg);
}
if (GetEngineControl()->fRealTime) {
fThread.AcquireRealTime();
if (fThread.AcquireRealTime() < 0) {
jack_error("JackClient::AcquireRealTime error");
}
}
break;

@@ -250,7 +258,7 @@ int JackClient::ClientNotify(int refnum, const char* name, int notify, int sync,
fPortConnect(value1, value2, 0, fPortConnectArg);
}
break;
case kPortRenameCallback:
jack_log("JackClient::kPortRenameCallback port = %ld", value1);
if (fPortRename) {
@@ -264,7 +272,7 @@ int JackClient::ClientNotify(int refnum, const char* name, int notify, int sync,
res = fXrun(fXrunArg);
}
break;
case kShutDownCallback:
jack_log("JackClient::kShutDownCallback");
if (fInfoShutdown) {
@@ -289,15 +297,109 @@ int JackClient::ClientNotify(int refnum, const char* name, int notify, int sync,
res = (fImmediateSessionReply) ? 1 : 2;
}
break;

case kLatencyCallback:
res = HandleLatencyCallback(value1);
break;
}
}

return res;
}

int JackClient::HandleLatencyCallback(int status)
{
jack_latency_callback_mode_t mode = (status == 0) ? JackCaptureLatency : JackPlaybackLatency;
jack_latency_range_t latency = { UINT32_MAX, 0 };

/* first setup all latency values of the ports.
* this is based on the connections of the ports.
*/
list<jack_port_id_t>::iterator it;

for (it = fPortList.begin(); it != fPortList.end(); it++) {
JackPort* port = GetGraphManager()->GetPort(*it);
if ((port->GetFlags() & JackPortIsOutput) && (mode == JackPlaybackLatency)) {
GetGraphManager()->RecalculateLatency(*it, mode);
}
if ((port->GetFlags() & JackPortIsInput) && (mode == JackCaptureLatency)) {
GetGraphManager()->RecalculateLatency(*it, mode);
}
}

if (!fLatency) {
/*
* default action is to assume all ports depend on each other.
* then always take the maximum latency.
*/

if (mode == JackPlaybackLatency) {
/* iterate over all OutputPorts, to find maximum playback latency
*/
for (it = fPortList.begin(); it != fPortList.end(); it++) {
JackPort* port = GetGraphManager()->GetPort(*it);
if (port->GetFlags() & JackPortIsOutput) {
jack_latency_range_t other_latency;
port->GetLatencyRange(mode, &other_latency);
if (other_latency.max > latency.max)
latency.max = other_latency.max;
if (other_latency.min < latency.min)
latency.min = other_latency.min;
}
}

if (latency.min == UINT32_MAX)
latency.min = 0;

/* now set the found latency on all input ports
*/
for (it = fPortList.begin(); it != fPortList.end(); it++) {
JackPort* port = GetGraphManager()->GetPort(*it);
if (port->GetFlags() & JackPortIsInput) {
port->SetLatencyRange(mode, &latency);
}
}
}
if (mode == JackCaptureLatency) {
/* iterate over all InputPorts, to find maximum playback latency
*/
for (it = fPortList.begin(); it != fPortList.end(); it++) {
JackPort* port = GetGraphManager()->GetPort(*it);
if (port->GetFlags() & JackPortIsInput) {
jack_latency_range_t other_latency;
port->GetLatencyRange(mode, &other_latency);
if (other_latency.max > latency.max)
latency.max = other_latency.max;
if (other_latency.min < latency.min)
latency.min = other_latency.min;
}
}

if (latency.min == UINT32_MAX)
latency.min = 0;

/* now set the found latency on all output ports
*/
for (it = fPortList.begin(); it != fPortList.end(); it++) {
JackPort* port = GetGraphManager()->GetPort(*it);
if (port->GetFlags() & JackPortIsOutput) {
port->SetLatencyRange(mode, &latency);
}
}
}
return 0;
}

/* we have a latency callback setup by the client,
* lets use it...
*/
fLatency(mode, fLatencyArg);
return 0;
}

/*!
\brief We need to start thread before activating in the server, otherwise the FW driver
connected to the client may not be activated.
connected to the client may not be activated.
*/
int JackClient::Activate()
{
@@ -310,13 +412,13 @@ int JackClient::Activate()
if (StartThread() < 0)
return -1;
}
/*
Insertion of client in the graph will cause a kGraphOrderCallback notification
Insertion of client in the graph will cause a kGraphOrderCallback notification
to be delivered by the server, the client wants to receive it.
*/
GetClientControl()->fActive = true;
// Transport related callback become "active"
GetClientControl()->fTransportSync = true;
GetClientControl()->fTransportTimebase = true;
@@ -337,18 +439,18 @@ int JackClient::Deactivate()
return 0;

GetClientControl()->fActive = false;
// Transport related callback become "unactive"
GetClientControl()->fTransportSync = false;
GetClientControl()->fTransportTimebase = false;
// We need to wait for the new engine cycle before stopping the RT thread, but this is done by ClientDeactivate
int result = -1;
fChannel->ClientDeactivate(GetClientControl()->fRefNum, &result);
jack_log("JackClient::Deactivate res = %ld", result);
// RT thread is stopped only when needed...
if (IsRealTime())
if (IsRealTime())
fThread.Kill();
return result;
}
@@ -357,15 +459,48 @@ int JackClient::Deactivate()
// RT thread management
//----------------------

void JackClient::InitAux()
{
if (fInit) {
jack_log("JackClient::Init calling client thread init callback");
fInit(fInitArg);
}
}

/*!
\brief Called once when the thread starts.
*/
bool JackClient::Init()
{
if (fInit) {
jack_log("JackClient::Init calling client thread init callback");
fInit(fInitArg);
/*
Execute buffer_size callback.

Since StartThread uses fThread.StartSync, we are sure that buffer_size callback
is executed before StartThread returns (and then IsActive will be true).
So no RT callback can be called at the same time.
*/
jack_log("JackClient::kBufferSizeCallback buffer_size = %ld", GetEngineControl()->fBufferSize);
if (fBufferSize) {
fBufferSize(GetEngineControl()->fBufferSize, fBufferSizeArg);
}

// Init callback
InitAux();

// Setup context
if (!jack_tls_set(JackGlobals::fRealTime, this))
jack_error("failed to set thread realtime key");

if (GetEngineControl()->fRealTime)
set_threaded_log_function();

// Setup RT
if (GetEngineControl()->fRealTime) {
if (fThread.AcquireRealTime(GetEngineControl()->fClientPriority) < 0) {
jack_error("JackClient::AcquireRealTime error");
}
}

return true;
}

@@ -384,12 +519,6 @@ int JackClient::StartThread()
return -1;
}

if (GetEngineControl()->fRealTime) {
if (fThread.AcquireRealTime(GetEngineControl()->fClientPriority) < 0) {
jack_error("AcquireRealTime error");
}
}

return 0;
}

@@ -399,21 +528,15 @@ int JackClient::StartThread()

bool JackClient::Execute()
{
if (!jack_tls_set(JackGlobals::fRealTime, this))
jack_error("failed to set thread realtime key");
if (GetEngineControl()->fRealTime)
set_threaded_log_function();
// Execute a dummy cycle to be sure thread has the correct properties
DummyCycle();

if (fThreadFun) {
fThreadFun(fThreadFunArg);
} else {
ExecuteThread();
}
return false;
return false;
}

void JackClient::DummyCycle()
@@ -424,15 +547,15 @@ void JackClient::DummyCycle()

inline void JackClient::ExecuteThread()
{
while (true) {
while (true) {
CycleWaitAux();
CycleSignalAux(CallProcessCallback());
}
CycleSignalAux(CallProcessCallback());
}
}

inline jack_nframes_t JackClient::CycleWaitAux()
{
if (!WaitSync())
if (!WaitSync())
Error(); // Terminates the thread
CallSyncCallbackAux();
return GetEngineControl()->fBufferSize;
@@ -443,7 +566,7 @@ inline void JackClient::CycleSignalAux(int status)
if (status == 0)
CallTimebaseCallbackAux();
SignalSync();
if (status != 0)
if (status != 0)
End(); // Terminates the thread
}

@@ -531,7 +654,7 @@ int JackClient::PortRegister(const char* port_name, const char* port_type, unsig
int result = -1;
jack_port_id_t port_index = NO_PORT;
fChannel->PortRegister(GetClientControl()->fRefNum, name.c_str(), port_type, flags, buffer_size, &port_index, &result);
if (result == 0) {
jack_log("JackClient::PortRegister ref = %ld name = %s type = %s port_index = %ld", GetClientControl()->fRefNum, name.c_str(), port_type, port_index);
fPortList.push_back(port_index);
@@ -612,6 +735,13 @@ int JackClient::SetFreeWheel(int onoff)
return result;
}

int JackClient::ComputeTotalLatencies()
{
int result = -1;
fChannel->ComputeTotalLatencies(&result);
return result;
}

/*
ShutDown is called:
- from the RT thread when Execute method fails
@@ -621,9 +751,9 @@ ShutDown is called:

void JackClient::ShutDown()
{
jack_log("ShutDown");
jack_log("JackClient::ShutDown");
JackGlobals::fServerRunning = false;
if (fInfoShutdown) {
fInfoShutdown(JackFailure, "JACK server has been closed", fInfoShutdownArg);
fInfoShutdown = NULL;
@@ -641,18 +771,18 @@ inline int JackClient::ActivateAux()
{
// If activated without RT thread...
if (IsActive() && fThread.GetStatus() != JackThread::kRunning) {
jack_log("ActivateAux");
jack_log("JackClient::ActivateAux");
// RT thread is started
if (StartThread() < 0)
return -1;
int result = -1;
GetClientControl()->fCallback[kRealTimeCallback] = IsRealTime();
fChannel->ClientActivate(GetClientControl()->fRefNum, IsRealTime(), &result);
return result;
} else {
return 0;
}
@@ -683,7 +813,7 @@ int JackClient::SetTimebaseCallback(int conditional, JackTimebaseCallback timeba
{
int result = -1;
fChannel->SetTimebaseCallback(GetClientControl()->fRefNum, conditional, &result);
if (result == 0) {
GetClientControl()->fTransportTimebase = true;
fTimebase = timebase_callback;
@@ -709,14 +839,14 @@ void JackClient::TransportLocate(jack_nframes_t frame)
jack_position_t pos;
pos.frame = frame;
pos.valid = (jack_position_bits_t)0;
jack_log("TransportLocate pos = %ld", pos.frame);
jack_log("JackClient::TransportLocate pos = %ld", pos.frame);
GetEngineControl()->fTransport.RequestNewPos(&pos);
}

int JackClient::TransportReposition(jack_position_t* pos)
{
jack_position_t tmp = *pos;
jack_log("TransportReposition pos = %ld", pos->frame);
jack_log("JackClient::TransportReposition pos = %ld", pos->frame);
if (tmp.valid & ~JACK_POSITION_MASK) {
return EINVAL;
} else {
@@ -758,11 +888,11 @@ void JackClient::CallSyncCallback()
inline void JackClient::CallSyncCallbackAux()
{
if (GetClientControl()->fTransportSync) {
JackTransportEngine& transport = GetEngineControl()->fTransport;
jack_position_t* cur_pos = transport.ReadCurrentState();
jack_transport_state_t transport_state = transport.GetState();
if (fSync != NULL) {
if (fSync(transport_state, cur_pos, fSyncArg)) {
GetClientControl()->fTransportState = JackTransportRolling;
@@ -785,21 +915,21 @@ inline void JackClient::CallTimebaseCallbackAux()
JackTransportEngine& transport = GetEngineControl()->fTransport;
int master;
bool unused;
transport.GetTimebaseMaster(master, unused);
if (GetClientControl()->fRefNum == master && fTimebase) { // Client *is* timebase...
jack_transport_state_t transport_state = transport.GetState();
jack_position_t* cur_pos = transport.WriteNextStateStart(1);
if (GetClientControl()->fTransportTimebase) {
fTimebase(transport_state, GetEngineControl()->fBufferSize, cur_pos, true, fTimebaseArg);
GetClientControl()->fTransportTimebase = false; // Callback is called only once with "new_pos" = true
fTimebase(transport_state, GetEngineControl()->fBufferSize, cur_pos, true, fTimebaseArg);
GetClientControl()->fTransportTimebase = false; // Callback is called only once with "new_pos" = true
} else if (transport_state == JackTransportRolling) {
fTimebase(transport_state, GetEngineControl()->fBufferSize, cur_pos, false, fTimebaseArg);
}
}
transport.WriteNextStateStop(1);
}
}
@@ -817,7 +947,7 @@ void JackClient::OnShutdown(JackShutdownCallback callback, void *arg)
fShutdown = callback;
}
}
void JackClient::OnInfoShutdown(JackInfoShutdownCallback callback, void *arg)
{
if (IsActive()) {
@@ -873,8 +1003,6 @@ int JackClient::SetInitCallback(JackThreadInitCallback callback, void *arg)

int JackClient::SetGraphOrderCallback(JackGraphOrderCallback callback, void *arg)
{
jack_log("SetGraphOrderCallback ");

if (IsActive()) {
jack_error("You cannot set callbacks on an active client");
return -1;
@@ -908,8 +1036,8 @@ int JackClient::SetSampleRateCallback(JackSampleRateCallback callback, void *arg
GetClientControl()->fCallback[kSampleRateCallback] = (callback != NULL);
fSampleRateArg = arg;
fSampleRate = callback;
// Now invoke it
if (callback)
// Now invoke it
if (callback)
callback(GetEngineControl()->fSampleRate, arg);
return 0;
}
@@ -1011,6 +1139,19 @@ int JackClient::SetSessionCallback(JackSessionCallback callback, void *arg)
}
}

int JackClient::SetLatencyCallback(JackLatencyCallback callback, void *arg)
{
if (IsActive()) {
jack_error("You cannot set callbacks on an active client");
return -1;
} else {
// fCallback[kLatencyCallback] must always be 'true'
fLatencyArg = arg;
fLatency = callback;
return 0;
}
}

//------------------
// Internal clients
//------------------
@@ -1072,65 +1213,64 @@ void JackClient::InternalClientUnload(int ref, jack_status_t* status)
// Session API
//------------------

jack_session_command_t *JackClient::SessionNotify( const char* target, jack_session_event_type_t type, const char* path )
jack_session_command_t* JackClient::SessionNotify(const char* target, jack_session_event_type_t type, const char* path)
{
jack_session_command_t *res;
fChannel->SessionNotify( GetClientControl()->fRefNum, target, type, path, &res );
jack_session_command_t* res;
fChannel->SessionNotify(GetClientControl()->fRefNum, target, type, path, &res);
return res;
}

int JackClient::SessionReply( jack_session_event_t *ev )
int JackClient::SessionReply(jack_session_event_t* ev)
{
if (ev->command_line) {
strncpy( GetClientControl()->fSessionCommand, ev->command_line, sizeof(GetClientControl()->fSessionCommand) );
strncpy(GetClientControl()->fSessionCommand, ev->command_line, sizeof(GetClientControl()->fSessionCommand));
} else {
GetClientControl()->fSessionCommand[0] = '\0';
}

GetClientControl()->fSessionFlags = ev->flags;

jack_log( "JackClient::SessionReply... we are here" );
jack_log("JackClient::SessionReply... we are here");
if (fChannel->IsChannelThread()) {
jack_log( "JackClient::SessionReply... in callback reply" );
jack_log( "JackClient::SessionReply... in callback reply");
fImmediateSessionReply = true;
return 0;
}

jack_log( "JackClient::SessionReply... out of cb" );
jack_log("JackClient::SessionReply... out of cb");

int res;
fChannel->SessionReply( GetClientControl()->fRefNum, &res);
return res;
int result = -1;
fChannel->SessionReply(GetClientControl()->fRefNum, &result);
return result;
}

char* JackClient::GetUUIDForClientName(const char* client_name)
{
char uuid_res[JACK_UUID_SIZE];
int result = -1;
fChannel->GetUUIDForClientName( GetClientControl()->fRefNum, client_name, uuid_res, &result);

if (result)
return NULL;

return strdup(uuid_res);
fChannel->GetUUIDForClientName(GetClientControl()->fRefNum, client_name, uuid_res, &result);
return (result) ? NULL : strdup(uuid_res);
}

char* JackClient::GetClientNameForUUID(const char* uuid)
char* JackClient::GetClientNameByUUID(const char* uuid)
{
char name_res[JACK_CLIENT_NAME_SIZE + 1];
int result = -1;
fChannel->GetClientNameForUUID(GetClientControl()->fRefNum, uuid, name_res, &result);
return (result) ? NULL : strdup(name_res);
}

if (result)
return NULL;

return strdup(name_res);
int JackClient::ReserveClientName(const char* client_name, const char* uuid)
{
int result = -1;
fChannel->ReserveClientName( GetClientControl()->fRefNum, client_name, uuid, &result);
return result;
}

int JackClient::ReserveClientName(const char *name, const char* uuid)
int JackClient::ClientHasSessionCallback(const char* client_name)
{
int result = -1;
fChannel->ReserveClientName( GetClientControl()->fRefNum, name, uuid, &result);
fChannel->ClientHasSessionCallback(client_name, &result);
return result;
}



+ 20
- 12
common/JackClient.h View File

@@ -13,7 +13,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

*/
@@ -27,7 +27,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "JackSynchro.h"
#include "JackPlatformPlug.h"
#include "JackChannel.h"
#include "types.h"
#include "session.h"
#include "varargs.h"
#include <list>
@@ -68,6 +67,7 @@ class JackClient : public JackClientInterface, public JackRunnableInterface
JackSyncCallback fSync;
JackThreadCallback fThreadFun;
JackSessionCallback fSession;
JackLatencyCallback fLatency;

void* fProcessArg;
void* fGraphOrderArg;
@@ -86,6 +86,7 @@ class JackClient : public JackClientInterface, public JackRunnableInterface
void* fSyncArg;
void* fThreadFunArg;
void* fSessionArg;
void* fLatencyArg;
char fServerName[64];

JackThread fThread; /*! Thread to execute the Process function */
@@ -94,14 +95,14 @@ class JackClient : public JackClientInterface, public JackRunnableInterface
std::list<jack_port_id_t> fPortList;

bool fImmediateSessionReply;
int StartThread();
void SetupDriverSync(bool freewheel);
bool IsActive();

void CallSyncCallback();
void CallTimebaseCallback();