+ added header translation for the JACK Audio Connection Kit library

packages/fpmake_add.inc

@@ -164,3 +164,4 @@
   add_fcl_yaml(ADirectory+IncludeTrailingPathDelimiter('fcl-yaml'));
   add_ptckvm(ADirectory+IncludeTrailingPathDelimiter('ptckvm'));
   add_fcl_fpterm(ADirectory+IncludeTrailingPathDelimiter('fcl-fpterm'));
+  add_libjack(ADirectory+IncludeTrailingPathDelimiter('libjack'));

packages/fpmake_proc.inc

@@ -930,3 +930,8 @@ end;
 
 {$include fcl-fpterm/fpmake.pp}
 
+procedure add_libjack(const ADirectory: string);
+begin
+  with Installer do
+{$include libjack/fpmake.pp}
+end;

packages/libjack/Makefile

@@ -0,0 +1,2 @@
+PACKAGE_NAME=libjack
+include ../build/Makefile.pkg

packages/libjack/fpmake.pp

@@ -0,0 +1,46 @@
+{$ifndef ALLPACKAGES}
+{$mode objfpc}{$H+}
+program fpmake;
+
+uses {$ifdef unix}cthreads,{$endif} fpmkunit;
+
+Var
+  P : TPackage;
+  T : TTarget;
+begin
+  With Installer do
+    begin
+{$endif ALLPACKAGES}
+
+    P:=AddPackage('libjack');
+    P.ShortName:='ljack';
+{$ifdef ALLPACKAGES}
+    P.Directory:=ADirectory;
+{$endif ALLPACKAGES}
+    P.Version:='3.3.1';
+    P.Author := 'Library: libjack';
+    P.License := 'Audio Server: GPL, Library: LGPL';
+    P.HomepageURL := 'https://jackaudio.org/';
+    P.Email := '';
+    P.Description := 'Headers for the JACK Audio Connection Kit library';
+    P.NeedLibC:= true;  // true for headers that indirectly link to libc?
+    P.OSes := AllUnixOSes-[qnx];
+    P.SourcePath.Add('src');
+    P.IncludePath.Add('src');
+
+    T:=P.Targets.AddUnit('jack.pp');
+    with T.Dependencies do
+      begin
+        AddInclude('systemdeps.inc');
+        AddInclude('transport.inc');
+        AddInclude('types.inc');
+        AddInclude('weakmacros.inc');
+      end;
+
+    P.NamespaceMap:='namespaces.lst';
+
+{$ifndef ALLPACKAGES}
+    Run;
+    end;
+end.
+{$endif ALLPACKAGES}

packages/libjack/namespaced/Api.Jack.pp

@@ -0,0 +1,3 @@
+unit Api.Jack;
+{$DEFINE FPC_DOTTEDUNITS}
+{$i jack.pp}

packages/libjack/src/jack.pp

@@ -0,0 +1,1509 @@
+(*
+  Copyright (C) 2001 Paul Davis
+  Copyright (C) 2004 Jack O'Quin
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Lesser General Public License as published by
+  the Free Software Foundation; either version 2.1 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  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
+  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+*)
+
+{$IFNDEF FPC_DOTTEDUNITS}
+unit jack;
+{$ENDIF FPC_DOTTEDUNITS}
+
+interface
+
+{$packrecords C}
+
+uses
+  ctypes;
+
+const
+  libjack = 'jack';
+
+type
+  uint64_t = System.UInt64;
+  uint32_t = System.UInt32;
+  int32_t = System.Int32;
+
+{$ifndef __jack_h__}
+{$define __jack_h__}
+
+//#ifdef __cplusplus
+//extern "C"
+//{
+//#endif
+
+//#include <jack/systemdeps.h>
+{$I systemdeps.inc}
+//#include <jack/types.h>
+{$I types.inc}
+//#include <jack/transport.h>
+{$I transport.inc}
+
+(**
+ * Note: More documentation can be found in jack/types.h.
+ *)
+
+    (*************************************************************
+     * NOTE: JACK_WEAK_EXPORT ***MUST*** be used on every function
+     * added to the JACK API after the 0.116.2 release.
+     *
+     * Functions that predate this release are marked with
+     * JACK_WEAK_OPTIONAL_EXPORT which can be defined at compile
+     * time in a variety of ways. The default definition is empty,
+     * so that these symbols get normal linkage. If you wish to
+     * use all JACK symbols with weak linkage, include
+     * <jack/weakjack.h> before jack.h.
+     *************************************************************)
+
+//#include <jack/weakmacros.h>
+{$I weakmacros.inc}
+
+(**
+ * Call this function to get version of the JACK, in form of several numbers
+ *
+ * @param major_ptr pointer to variable receiving major version of JACK.
+ *
+ * @param minor_ptr pointer to variable receiving minor version of JACK.
+ *
+ * @param major_ptr pointer to variable receiving micro version of JACK.
+ *
+ * @param major_ptr pointer to variable receiving protocol version of JACK.
+ *
+ *)
+procedure
+jack_get_version(
+    major_ptr: Pcint;
+    minor_ptr: Pcint;
+    micro_ptr: Pcint;
+    proto_ptr: Pcint); cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Call this function to get version of the JACK, in form of a string
+ *
+ * @return Human readable string describing JACK version being used.
+ *
+ *)
+function
+jack_get_version_string: PChar; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @defgroup ClientFunctions Creating & manipulating clients
+ * @{
+ *)
+
+(**
+ * Open an external client session with a JACK server.  This interface
+ * is more complex but more powerful than jack_client_new().  With it,
+ * clients may choose which of several servers to connect, and control
+ * whether and how to start the server automatically, if it was not
+ * already running.  There is also an option for JACK to generate a
+ * unique client name, when necessary.
+ *
+ * @param client_name of at most jack_client_name_size() characters.
+ * The name scope is local to each server.  Unless forbidden by the
+ * @ref JackUseExactName option, the server will modify this name to
+ * create a unique variant, if needed.
+ *
+ * @param options formed by OR-ing together @ref JackOptions bits.
+ * Only the @ref JackOpenOptions bits are allowed.
+ *
+ * @param status (if non-NULL) an address for JACK to return
+ * information from the open operation.  This status word is formed by
+ * OR-ing together the relevant @ref JackStatus bits.
+ *
+ *
+ * <b>Optional parameters:</b> depending on corresponding [@a options
+ * bits] additional parameters may follow @a status (in this order).
+ *
+ * @arg [@ref JackServerName] <em>(char * ) server_name</em> selects
+ * from among several possible concurrent server instances.  Server
+ * names are unique to each user.  If unspecified, use "default"
+ * unless \$JACK_DEFAULT_SERVER is defined in the process environment.
+ *
+ * @return Opaque client handle if successful.  If this is NULL, the
+ * open operation failed, @a *status includes @ref JackFailure and the
+ * caller is not a JACK client.
+ *)
+function jack_client_open (const client_name: PChar;
+                           options: jack_options_t;
+                           status: Pjack_status_t): Pjack_client_t; varargs; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+* \bold THIS FUNCTION IS DEPRECATED AND SHOULD NOT BE USED IN
+*  NEW JACK CLIENTS
+*
+* @deprecated Please use jack_client_open().
+*)
+function jack_client_new (const client_name: PChar): Pjack_client_t; cdecl; JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT;
+
+(**
+ * Disconnects an external client from a JACK server.
+ *
+ * @return 0 on success, otherwise a non-zero error code
+ *)
+function jack_client_close (client: Pjack_client_t): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return the maximum number of characters in a JACK client name
+ * including the final NULL character.  This value is a constant.
+ *)
+function jack_client_name_size: cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return pointer to actual client name.  This is useful when @ref
+ * JackUseExactName is not specified on open and @ref
+ * JackNameNotUnique status was returned.  In that case, the actual
+ * name will differ from the @a client_name requested.
+ *)
+function jack_get_client_name (client: Pjack_client_t): PChar; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Get the session ID for a client name.
+ *
+ * The session manager needs this to reassociate a client name to the session_id.
+ *
+ * The caller is responsible for calling jack_free(3) on any non-NULL
+ * returned value.
+ *)
+function jack_get_uuid_for_client_name (client: Pjack_client_t;
+                                        const client_name: PChar): PChar; cdecl; JACK_WEAK_EXPORT;
+
+(**
+ * Get the client name for a session_id.
+ *
+ * In order to snapshot the graph connections, the session manager needs to map
+ * session_ids to client names.
+ *
+ * The caller is responsible for calling jack_free(3) on any non-NULL
+ * returned value.
+ *)
+function jack_get_client_name_by_uuid (client: Pjack_client_t;
+                                       const client_uuid: PChar): PChar; cdecl; JACK_WEAK_EXPORT;
+
+(**
+ * Load an internal client into the Jack server.
+ *
+ * Internal clients run inside the JACK server process.  They can use
+ * most of the same functions as external clients.  Each internal
+ * client must declare jack_initialize() and jack_finish() entry
+ * points, called at load and unload times.  See inprocess.c for an
+ * example of how to write an internal client.
+ *
+ * @deprecated Please use jack_internal_client_load().
+ *
+ * @param client_name of at most jack_client_name_size() characters.
+ *
+ * @param load_name of a shared object file containing the code for
+ * the new client.
+ *
+ * @param load_init an arbitrary string passed to the jack_initialize()
+ * routine of the new client (may be NULL).
+ *
+ * @return 0 if successful.
+ *)
+function jack_internal_client_new (const client_name: PChar;
+                                   const load_name: PChar;
+                                   const load_init: PChar): cint; cdecl; JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT;
+
+(**
+ * Remove an internal client from a JACK server.
+ *
+ * @deprecated Please use jack_internal_client_unload().
+ *)
+procedure jack_internal_client_close (const client_name: PChar); cdecl; JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT;
+
+(**
+ * Tell the Jack server that the program is ready to start processing
+ * audio.
+ *
+ * @return 0 on success, otherwise a non-zero error code
+ *)
+function jack_activate (client: Pjack_client_t): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Tell the Jack server to remove this @a client from the process
+ * graph.  Also, disconnect all ports belonging to it, since inactive
+ * clients have no port connections.
+ *
+ * @return 0 on success, otherwise a non-zero error code
+ *)
+function jack_deactivate (client: Pjack_client_t): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return pid of client. If not available, 0 will be returned.
+ *)
+function jack_get_client_pid (const name: PChar): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return the pthread ID of the thread running the JACK client side
+ * real-time code.
+ *)
+function jack_client_thread_id (client: Pjack_client_t): jack_native_thread_t; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+///**@}*/
+
+(**
+ * @param client pointer to JACK client structure.
+ *
+ * Check if the JACK subsystem is running with -R (--realtime).
+ *
+ * @return 1 if JACK is running realtime, 0 otherwise
+ *)
+function jack_is_realtime (client: Pjack_client_t): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @defgroup NonCallbackAPI The non-callback API
+ * @{
+ *)
+
+(**
+ * \bold THIS FUNCTION IS DEPRECATED AND SHOULD NOT BE USED IN
+ *  NEW JACK CLIENTS.
+ *
+ * @deprecated Please use jack_cycle_wait() and jack_cycle_signal() functions.
+ *)
+function jack_thread_wait (client: Pjack_client_t; status: cint): jack_nframes_t; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Wait until this JACK client should process data.
+ *
+ * @param client - pointer to a JACK client structure
+ *
+ * @return the number of frames of data to process
+ *)
+function jack_cycle_wait (client: Pjack_client_t): jack_nframes_t; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Signal next clients in the graph.
+ *
+ * @param client - pointer to a JACK client structure
+ * @param status - if non-zero, calling thread should exit
+ *)
+procedure jack_cycle_signal (client: Pjack_client_t; status: cint); cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Tell the Jack server to call @a thread_callback in the RT thread.
+ * Typical use are in conjunction with @a jack_cycle_wait and @a jack_cycle_signal functions.
+ * The code in the supplied function must be suitable for real-time
+ * execution.  That means that it cannot call functions that might
+ * block for a long time. This includes malloc, free, printf,
+ * pthread_mutex_lock, sleep, wait, poll, select, pthread_join,
+ * pthread_cond_wait, etc, etc. See
+ * http://jackit.sourceforge.net/docs/design/design.html#SECTION00411000000000000000
+ * for more information.
+ *
+ * NOTE: this function cannot be called while the client is activated
+ * (after jack_activate has been called.)
+ *
+ * @return 0 on success, otherwise a non-zero error code.
+*)
+function jack_set_process_thread(client: Pjack_client_t; thread_callback: TJackThreadCallback; arg: Pointer): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+///**@}*/
+
+(**
+ * @defgroup ClientCallbacks Setting Client Callbacks
+ * @{
+ *)
+
+(**
+ * Tell JACK to call @a thread_init_callback once just after
+ * the creation of the thread in which all other callbacks
+ * will be handled.
+ *
+ * The code in the supplied function does not need to be
+ * suitable for real-time execution.
+ *
+ * NOTE: this function cannot be called while the client is activated
+ * (after jack_activate has been called.)
+ *
+ * @return 0 on success, otherwise a non-zero error code, causing JACK
+ * to remove that client from the process() graph.
+ *)
+function jack_set_thread_init_callback (client: Pjack_client_t;
+                                        thread_init_callback: TJackThreadInitCallback;
+                                        arg: Pointer): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @param client pointer to JACK client structure.
+ * @param function The jack_shutdown function pointer.
+ * @param arg The arguments for the jack_shutdown function.
+ *
+ * Register a function (and argument) to be called if and when the
+ * JACK server shuts down the client thread.  The function must
+ * be written as if it were an asynchonrous POSIX signal
+ * handler --- use only async-safe functions, and remember that it
+ * is executed from another thread.  A typical function might
+ * set a flag or write to a pipe so that the rest of the
+ * application knows that the JACK client thread has shut
+ * down.
+ *
+ * NOTE: clients do not need to call this.  It exists only
+ * to help more complex clients understand what is going
+ * on.  It should be called before jack_client_activate().
+ *
+ * NOTE: if a client calls this AND jack_on_info_shutdown(), then
+ * in case of a client thread shutdown, the callback
+ * passed to this function will not be called, and the one passed to
+ * jack_on_info_shutdown() will.
+ *
+ * NOTE: application should typically signal another thread to correctly 
+ * finish cleanup, that is by calling "jack_client_close" 
+ * (since "jack_client_close" cannot be called directly in the context 
+ * of the thread that calls the shutdown callback).
+ *)
+procedure jack_on_shutdown (client: Pjack_client_t;
+                            shutdown_callback: TJackShutdownCallback; arg: Pointer); cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @param client pointer to JACK client structure.
+ * @param function The jack_info_shutdown function pointer.
+ * @param arg The arguments for the jack_info_shutdown function.
+ *
+ * Register a function (and argument) to be called if and when the
+ * JACK server shuts down the client thread.  The function must
+ * be written as if it were an asynchonrous POSIX signal
+ * handler --- use only async-safe functions, and remember that it
+ * is executed from another thread.  A typical function might
+ * set a flag or write to a pipe so that the rest of the
+ * application knows that the JACK client thread has shut
+ * down.
+ *
+ * NOTE: clients do not need to call this.  It exists only
+ * to help more complex clients understand what is going
+ * on.  It should be called before jack_client_activate().
+ *
+ * NOTE: if a client calls this AND jack_on_shutdown(), then
+ * in case of a client thread shutdown, the callback passed to
+ * jack_on_info_shutdown() will be called.
+ *
+ * NOTE: application should typically signal another thread to correctly 
+ * finish cleanup, that is by calling "jack_client_close" 
+ * (since "jack_client_close" cannot be called directly in the context 
+ * of the thread that calls the shutdown callback).
+ *)
+procedure jack_on_info_shutdown (client: Pjack_client_t;
+                                 shutdown_callback: TJackInfoShutdownCallback; arg: Pointer); cdecl; JACK_WEAK_EXPORT;
+
+(**
+ * Tell the Jack server to call @a process_callback whenever there is
+ * work be done, passing @a arg as the second argument.
+ *
+ * The code in the supplied function must be suitable for real-time
+ * execution.  That means that it cannot call functions that might
+ * block for a long time. This includes malloc, free, printf,
+ * pthread_mutex_lock, sleep, wait, poll, select, pthread_join,
+ * pthread_cond_wait, etc, etc. See
+ * http://jackit.sourceforge.net/docs/design/design.html#SECTION00411000000000000000
+ * for more information.
+ *
+ * NOTE: this function cannot be called while the client is activated
+ * (after jack_activate has been called.)
+ *
+ * @return 0 on success, otherwise a non-zero error code.
+ *)
+function jack_set_process_callback (client: Pjack_client_t;
+                                    process_callback: TJackProcessCallback;
+                                    arg: Pointer): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Tell the Jack server to call @a freewheel_callback
+ * whenever we enter or leave "freewheel" mode, passing @a
+ * arg as the second argument. The first argument to the
+ * callback will be non-zero if JACK is entering freewheel
+ * mode, and zero otherwise.
+ *
+ * All "notification events" are received in a separated non RT thread,
+ * the code in the supplied function does not need to be
+ * suitable for real-time execution.
+ *
+ * NOTE: this function cannot be called while the client is activated
+ * (after jack_activate has been called.)
+ *
+ * @return 0 on success, otherwise a non-zero error code.
+ *)
+function jack_set_freewheel_callback (client: Pjack_client_t;
+                                      freewheel_callback: TJackFreewheelCallback;
+                                      arg: Pointer): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Tell JACK to call @a bufsize_callback whenever the size of the the
+ * buffer that will be passed to the @a process_callback is about to
+ * change.  Clients that depend on knowing the buffer size must supply
+ * a @a bufsize_callback before activating themselves.
+ *
+ * All "notification events" are received in a separated non RT thread,
+ * the code in the supplied function does not need to be
+ * suitable for real-time execution.
+ *
+ * NOTE: this function cannot be called while the client is activated
+ * (after jack_activate has been called.)
+ *
+ * @param client pointer to JACK client structure.
+ * @param bufsize_callback function to call when the buffer size changes.
+ * @param arg argument for @a bufsize_callback.
+ *
+ * @return 0 on success, otherwise a non-zero error code
+ *)
+function jack_set_buffer_size_callback (client: Pjack_client_t;
+                                        bufsize_callback: TJackBufferSizeCallback;
+                                        arg: Pointer): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Tell the Jack server to call @a srate_callback whenever the system
+ * sample rate changes.
+ *
+ * All "notification events" are received in a separated non RT thread,
+ * the code in the supplied function does not need to be
+ * suitable for real-time execution.
+ *
+ * NOTE: this function cannot be called while the client is activated
+ * (after jack_activate has been called.)
+ *
+ * @return 0 on success, otherwise a non-zero error code
+ *)
+function jack_set_sample_rate_callback (client: Pjack_client_t;
+                                        srate_callback: TJackSampleRateCallback;
+                                        arg: Pointer): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Tell the JACK server to call @a client_registration_callback whenever a
+ * client is registered or unregistered, passing @a arg as a parameter.
+ *
+ * All "notification events" are received in a separated non RT thread,
+ * the code in the supplied function does not need to be
+ * suitable for real-time execution.
+ *
+ * NOTE: this function cannot be called while the client is activated
+ * (after jack_activate has been called.)
+ *
+ * @return 0 on success, otherwise a non-zero error code
+ *)
+function jack_set_client_registration_callback (client: Pjack_client_t;
+                                                registration_callback: TJackClientRegistrationCallback;
+                                                arg: Pointer): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Tell the JACK server to call @a registration_callback whenever a
+ * port is registered or unregistered, passing @a arg as a parameter.
+ *
+ * All "notification events" are received in a separated non RT thread,
+ * the code in the supplied function does not need to be
+ * suitable for real-time execution.
+ *
+ * NOTE: this function cannot be called while the client is activated
+ * (after jack_activate has been called.)
+ *
+ * @return 0 on success, otherwise a non-zero error code
+ *)
+function jack_set_port_registration_callback (client: Pjack_client_t;
+                                              registration_callback: TJackPortRegistrationCallback;
+                                              arg: Pointer): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Tell the JACK server to call @a connect_callback whenever a
+ * port is connected or disconnected, passing @a arg as a parameter.
+ *
+ * All "notification events" are received in a separated non RT thread,
+ * the code in the supplied function does not need to be
+ * suitable for real-time execution.
+ *
+ * NOTE: this function cannot be called while the client is activated
+ * (after jack_activate has been called.)
+ *
+ * @return 0 on success, otherwise a non-zero error code
+ *)
+function jack_set_port_connect_callback (client: Pjack_client_t;
+                                         connect_callback: TJackPortConnectCallback;
+                                         arg: Pointer): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+ (**
+ * Tell the JACK server to call @a rename_callback whenever a
+ * port is renamed, passing @a arg as a parameter.
+ *
+ * All "notification events" are received in a separated non RT thread,
+ * the code in the supplied function does not need to be
+ * suitable for real-time execution.
+ *
+ * NOTE: this function cannot be called while the client is activated
+ * (after jack_activate has been called.)
+ *
+ * @return 0 on success, otherwise a non-zero error code
+ *)
+function jack_set_port_rename_callback (client: Pjack_client_t;
+                                        rename_callback: TJackPortRenameCallback;
+                                        arg: Pointer): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Tell the JACK server to call @a graph_callback whenever the
+ * processing graph is reordered, passing @a arg as a parameter.
+ *
+ * All "notification events" are received in a separated non RT thread,
+ * the code in the supplied function does not need to be
+ * suitable for real-time execution.
+ *
+ * NOTE: this function cannot be called while the client is activated
+ * (after jack_activate has been called.)
+ *
+ * @return 0 on success, otherwise a non-zero error code
+ *)
+function jack_set_graph_order_callback (client: Pjack_client_t;
+                                        graph_callback: TJackGraphOrderCallback;
+                                        arg: Pointer): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Tell the JACK server to call @a xrun_callback whenever there is a
+ * xrun, passing @a arg as a parameter.
+ *
+ * All "notification events" are received in a separated non RT thread,
+ * the code in the supplied function does not need to be
+ * suitable for real-time execution.
+ *
+ * NOTE: this function cannot be called while the client is activated
+ * (after jack_activate has been called.)
+ *
+ * @return 0 on success, otherwise a non-zero error code
+ *)
+function jack_set_xrun_callback (client: Pjack_client_t;
+                                 xrun_callback: TJackXRunCallback; arg: Pointer): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Tell the Jack server to call @a latency_callback whenever it
+ * is necessary to recompute the latencies for some or all
+ * Jack ports.
+ *
+ * @a latency_callback will be called twice each time it is
+ * needed, once being passed JackCaptureLatency and once
+ * JackPlaybackLatency. See @ref LatencyFunctions for
+ * the definition of each type of latency and related functions.
+ *
+ * <b>IMPORTANT: Most JACK clients do NOT need to register a latency
+ * callback.</b>
+ *
+ * Clients that meet any of the following conditions do NOT
+ * need to register a latency callback:
+ *
+ *    - have only input ports
+ *    - have only output ports
+ *    - their output is totally unrelated to their input
+ *    - their output is not delayed relative to their input
+ *        (i.e. data that arrives in a given process()
+ *         callback is processed and output again in the
+ *         same callback)
+ *
+ * Clients NOT registering a latency callback MUST also
+ * satisfy this condition:
+ *
+ *    - have no multiple distinct internal signal pathways
+ *
+ * This means that if your client has more than 1 input and
+ * output port, and considers them always "correlated"
+ * (e.g. as a stereo pair), then there is only 1 (e.g. stereo)
+ * signal pathway through the client. This would be true,
+ * for example, of a stereo FX rack client that has a
+ * left/right input pair and a left/right output pair.
+ *
+ * However, this is somewhat a matter of perspective. The
+ * same FX rack client could be connected so that its
+ * two input ports were connected to entirely separate
+ * sources. Under these conditions, the fact that the client
+ * does not register a latency callback MAY result
+ * in port latency values being incorrect.
+ *
+ * Clients that do not meet any of those conditions SHOULD
+ * register a latency callback.
+ *
+ * Another case is when a client wants to use
+ * @ref jack_port_get_latency_range(), which only returns meaningful
+ * values when ports get connected and latency values change.
+ *
+ * See the documentation for @ref jack_port_set_latency_range()
+ * on how the callback should operate. Remember that the @a mode
+ * argument given to the latency callback will need to be
+ * passed into @ref jack_port_set_latency_range()
+ *
+ * @return 0 on success, otherwise a non-zero error code
+ *)
+function jack_set_latency_callback (client: Pjack_client_t;
+                                    latency_callback: TJackLatencyCallback;
+                                    arg: Pointer): cint; cdecl; JACK_WEAK_EXPORT;
+///**@}*/
+
+(**
+ * @defgroup ServerClientControl Controlling & querying JACK server operation
+ * @{
+ *)
+
+(**
+ * Start/Stop JACK's "freewheel" mode.
+ *
+ * When in "freewheel" mode, JACK no longer waits for
+ * any external event to begin the start of the next process
+ * cycle.
+ *
+ * As a result, freewheel mode causes "faster than realtime"
+ * execution of a JACK graph. If possessed, real-time
+ * scheduling is dropped when entering freewheel mode, and
+ * if appropriate it is reacquired when stopping.
+ *
+ * IMPORTANT: on systems using capabilities to provide real-time
+ * scheduling (i.e. Linux kernel 2.4), if onoff is zero, this function
+ * must be called from the thread that originally called jack_activate().
+ * This restriction does not apply to other systems (e.g. Linux kernel 2.6
+ * or OS X).
+ *
+ * @param client pointer to JACK client structure
+ * @param onoff  if non-zero, freewheel mode starts. Otherwise
+ *                  freewheel mode ends.
+ *
+ * @return 0 on success, otherwise a non-zero error code.
+ *)
+function jack_set_freewheel(client: Pjack_client_t; onoff: cint): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Change the buffer size passed to the @a process_callback.
+ *
+ * This operation stops the JACK engine process cycle, then calls all
+ * registered @a bufsize_callback functions before restarting the
+ * process cycle.  This will cause a gap in the audio flow, so it
+ * should only be done at appropriate stopping points.
+ *
+ * @see jack_set_buffer_size_callback()
+ *
+ * @param client pointer to JACK client structure.
+ * @param nframes new buffer size.  Must be a power of two.
+ *
+ * @return 0 on success, otherwise a non-zero error code
+ *)
+function jack_set_buffer_size (client: Pjack_client_t; nframes: jack_nframes_t): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return the sample rate of the jack system, as set by the user when
+ * jackd was started.
+ *)
+function jack_get_sample_rate (client: Pjack_client_t): jack_nframes_t; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return the current maximum size that will ever be passed to the @a
+ * process_callback.  It should only be used *before* the client has
+ * been activated.  This size may change, clients that depend on it
+ * must register a @a bufsize_callback so they will be notified if it
+ * does.
+ *
+ * @see jack_set_buffer_size_callback()
+ *)
+function jack_get_buffer_size (client: Pjack_client_t): jack_nframes_t; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Old-style interface to become the timebase for the entire JACK
+ * subsystem.
+ *
+ * @deprecated This function still exists for compatibility with the
+ * earlier transport interface, but it does nothing.  Instead, see
+ * transport.h and use jack_set_timebase_callback().
+ *
+ * @return ENOSYS, function not implemented.
+ *)
+function jack_engine_takeover_timebase (client: Pjack_client_t): cint; cdecl; JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT;
+
+(**
+ * @return the current CPU load estimated by JACK.  This is a running
+ * average of the time it takes to execute a full process cycle for
+ * all clients as a percentage of the real time available per cycle
+ * determined by the buffer size and sample rate.
+ *)
+function jack_cpu_load (client: Pjack_client_t): cfloat; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+///**@}*/
+
+(**
+ * @defgroup PortFunctions Creating & manipulating ports
+ * @{
+ *)
+
+(**
+ * Create a new port for the client. This is an object used for moving
+ * data of any type in or out of the client.  Ports may be connected
+ * in various ways.
+ *
+ * Each port has a short name.  The port's full name contains the name
+ * of the client concatenated with a colon (:) followed by its short
+ * name.  The jack_port_name_size() is the maximum length of this full
+ * name.  Exceeding that will cause the port registration to fail and
+ * return NULL.
+ *
+ * The @a port_name must be unique among all ports owned by this client.
+ * If the name is not unique, the registration will fail.
+ *
+ * All ports have a type, which may be any non-NULL and non-zero
+ * length string, passed as an argument.  Some port types are built
+ * into the JACK API, currently only JACK_DEFAULT_AUDIO_TYPE.
+ *
+ * @param client pointer to JACK client structure.
+ * @param port_name non-empty short name for the new port (not
+ * including the leading @a "client_name:"). Must be unique.
+ * @param port_type port type name.  If longer than
+ * jack_port_type_size(), only that many characters are significant.
+ * @param flags @ref JackPortFlags bit mask.
+ * @param buffer_size must be non-zero if this is not a built-in @a
+ * port_type.  Otherwise, it is ignored.
+ *
+ * @return jack_port_t pointer on success, otherwise NULL.
+ *)
+function jack_port_register (client: Pjack_client_t;
+                             const port_name: PChar;
+                             const port_type: PChar;
+                             flags: culong;
+                             buffer_size: culong): Pjack_port_t; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Remove the port from the client, disconnecting any existing
+ * connections.
+ *
+ * @return 0 on success, otherwise a non-zero error code
+ *)
+function jack_port_unregister (client: Pjack_client_t; port: Pjack_port_t): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * This returns a pointer to the memory area associated with the
+ * specified port. For an output port, it will be a memory area
+ * that can be written to; for an input port, it will be an area
+ * containing the data from the port's connection(s), or
+ * zero-filled. if there are multiple inbound connections, the data
+ * will be mixed appropriately.
+ *
+ * FOR OUTPUT PORTS ONLY : DEPRECATED in Jack 2.0 !!
+ * ---------------------------------------------------
+ * You may cache the value returned, but only between calls to
+ * your "blocksize" callback. For this reason alone, you should
+ * either never cache the return value or ensure you have
+ * a "blocksize" callback and be sure to invalidate the cached
+ * address from there.
+ *
+ * Caching output ports is DEPRECATED in Jack 2.0, due to some new optimization (like "pipelining").
+ * Port buffers have to be retrieved in each callback for proper functioning.
+ *)
+function jack_port_get_buffer (port: Pjack_port_t; nframes: jack_nframes_t): Pointer; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return the UUID of the jack_port_t
+ *
+ * @see jack_uuid_to_string() to convert into a string representation
+ *)
+function jack_port_uuid (const port: Pjack_port_t): jack_uuid_t; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return the full name of the jack_port_t (including the @a
+ * "client_name:" prefix).
+ *
+ * @see jack_port_name_size().
+ *)
+function jack_port_name (const port: Pjack_port_t): PChar; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return the short name of the jack_port_t (not including the @a
+ * "client_name:" prefix).
+ *
+ * @see jack_port_name_size().
+ *)
+function jack_port_short_name (const port: Pjack_port_t): PChar; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return the @ref JackPortFlags of the jack_port_t.
+ *)
+function jack_port_flags (const port: Pjack_port_t): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return the @a port type, at most jack_port_type_size() characters
+ * including a final NULL.
+ *)
+function jack_port_type (const port: Pjack_port_t): PChar; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+ (**
+ * @return the @a port type id.
+ *)
+function jack_port_type_id (const port: Pjack_port_t): jack_port_type_id_t; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return TRUE if the jack_port_t belongs to the jack_client_t.
+ *)
+function jack_port_is_mine (const client: Pjack_client_t; const port: Pjack_port_t): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return number of connections to or from @a port.
+ *
+ * @pre The calling client must own @a port.
+ *)
+function jack_port_connected (const port: Pjack_port_t): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return TRUE if the locally-owned @a port is @b directly connected
+ * to the @a port_name.
+ *
+ * @see jack_port_name_size()
+ *)
+function jack_port_connected_to (const port: Pjack_port_t;
+                                 const port_name: PChar): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return a null-terminated array of full port names to which the @a
+ * port is connected.  If none, returns NULL.
+ *
+ * The caller is responsible for calling jack_free() on any non-NULL
+ * returned value.
+ *
+ * @param port locally owned jack_port_t pointer.
+ *
+ * @see jack_port_name_size(), jack_port_get_all_connections()
+ *)
+function jack_port_get_connections (const port: Pjack_port_t): PPChar; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return a null-terminated array of full port names to which the @a
+ * port is connected.  If none, returns NULL.
+ *
+ * The caller is responsible for calling jack_free() on any non-NULL
+ * returned value.
+ *
+ * This differs from jack_port_get_connections() in two important
+ * respects:
+ *
+ *     1) You may not call this function from code that is
+ *          executed in response to a JACK event. For example,
+ *          you cannot use it in a GraphReordered handler.
+ *
+ *     2) You need not be the owner of the port to get information
+ *          about its connections.
+ *
+ * @see jack_port_name_size()
+ *)
+function jack_port_get_all_connections (const client: Pjack_client_t;
+                                        const port: Pjack_port_t): PPChar; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ *
+ * @deprecated This function will be removed from a future version
+ * of JACK. Do not use it. There is no replacement. It has
+ * turned out to serve essentially no purpose in real-life
+ * JACK clients.
+ *)
+function jack_port_tie (src: Pjack_port_t; dst: Pjack_port_t): cint; cdecl; JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT;
+
+(**
+ *
+ * @deprecated This function will be removed from a future version
+ * of JACK. Do not use it. There is no replacement. It has
+ * turned out to serve essentially no purpose in real-life
+ * JACK clients.
+ *)
+function jack_port_untie (port: Pjack_port_t): cint; cdecl; JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT;
+
+(**
+ * \bold THIS FUNCTION IS DEPRECATED AND SHOULD NOT BE USED IN
+ *  NEW JACK CLIENTS
+ *
+ * Modify a port's short name.  May be called at any time.  If the
+ * resulting full name (including the @a "client_name:" prefix) is
+ * longer than jack_port_name_size(), it will be truncated.
+ *
+ * @return 0 on success, otherwise a non-zero error code.
+ *)
+function jack_port_set_name (port: Pjack_port_t; const port_name: PChar): cint; cdecl; JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT;
+
+(**
+ * Modify a port's short name.  May NOT be called from a callback handling a server event.
+ * If the resulting full name (including the @a "client_name:" prefix) is
+ * longer than jack_port_name_size(), it will be truncated.
+ *
+ * @return 0 on success, otherwise a non-zero error code.
+ *
+ * This differs from jack_port_set_name() by triggering PortRename notifications to
+ * clients that have registered a port rename handler.
+ *)
+function jack_port_rename (client: Pjack_client_t; port: Pjack_port_t; const port_name: PChar): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Set @a alias as an alias for @a port.  May be called at any time.
+ * If the alias is longer than jack_port_name_size(), it will be truncated.
+ *
+ * After a successful call, and until JACK exits or
+ * @function jack_port_unset_alias() is called, @alias may be
+ * used as a alternate name for the port.
+ *
+ * Ports can have up to two aliases - if both are already
+ * set, this function will return an error.
+ *
+ * @return 0 on success, otherwise a non-zero error code.
+ *)
+function jack_port_set_alias (port: Pjack_port_t; const alias: PChar): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Remove @a alias as an alias for @a port.  May be called at any time.
+ *
+ * After a successful call, @a alias can no longer be
+ * used as a alternate name for the port.
+ *
+ * @return 0 on success, otherwise a non-zero error code.
+ *)
+function jack_port_unset_alias (port: jack_port_t; const alias: PChar): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Get any aliases known for @port.
+ *
+ * @return the number of aliases discovered for the port
+ *)
+function jack_port_get_aliases (const port: Pjack_port_t; {char* const aliases[2]} aliases: PPChar): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * If @ref JackPortCanMonitor is set for this @a port, turn input
+ * monitoring on or off.  Otherwise, do nothing.
+ *)
+function jack_port_request_monitor (port: Pjack_port_t; onoff: cint): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * If @ref JackPortCanMonitor is set for this @a port_name, turn input
+ * monitoring on or off.  Otherwise, do nothing.
+ *
+ * @return 0 on success, otherwise a non-zero error code.
+ *
+ * @see jack_port_name_size()
+ *)
+function jack_port_request_monitor_by_name (client: Pjack_client_t;
+                                            const port_name: PChar; onoff: cint): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * If @ref JackPortCanMonitor is set for a port, this function turns
+ * on input monitoring if it was off, and turns it off if only one
+ * request has been made to turn it on.  Otherwise it does nothing.
+ *
+ * @return 0 on success, otherwise a non-zero error code
+ *)
+function jack_port_ensure_monitor (port: Pjack_port_t; onoff: cint): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return TRUE if input monitoring has been requested for @a port.
+ *)
+function jack_port_monitoring_input (port: Pjack_port_t): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Establish a connection between two ports.
+ *
+ * When a connection exists, data written to the source port will
+ * be available to be read at the destination port.
+ *
+ * @pre The port types must be identical.
+ *
+ * @pre The @ref JackPortFlags of the @a source_port must include @ref
+ * JackPortIsOutput.
+ *
+ * @pre The @ref JackPortFlags of the @a destination_port must include
+ * @ref JackPortIsInput.
+ *
+ * @return 0 on success, EEXIST if the connection is already made,
+ * otherwise a non-zero error code
+ *)
+function jack_connect (client: Pjack_client_t;
+                       const source_port: PChar;
+                       const destination_port: PChar): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Remove a connection between two ports.
+ *
+ * @pre The port types must be identical.
+ *
+ * @pre The @ref JackPortFlags of the @a source_port must include @ref
+ * JackPortIsOutput.
+ *
+ * @pre The @ref JackPortFlags of the @a destination_port must include
+ * @ref JackPortIsInput.
+ *
+ * @return 0 on success, otherwise a non-zero error code
+ *)
+function jack_disconnect (client: Pjack_client_t;
+                          const source_port: PChar;
+                          const destination_port: PChar): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Perform the same function as jack_disconnect() using port handles
+ * rather than names.  This avoids the name lookup inherent in the
+ * name-based version.
+ *
+ * Clients connecting their own ports are likely to use this function,
+ * while generic connection clients (e.g. patchbays) would use
+ * jack_disconnect().
+ *)
+function jack_port_disconnect (client: Pjack_client_t; port: Pjack_port_t): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return the maximum number of characters in a full JACK port name
+ * including the final NULL character.  This value is a constant.
+ *
+ * A port's full name contains the owning client name concatenated
+ * with a colon (:) followed by its short name and a NULL
+ * character.
+ *)
+function jack_port_name_size: cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return the maximum number of characters in a JACK port type name
+ * including the final NULL character.  This value is a constant.
+ *)
+function jack_port_type_size: cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return the buffersize of a port of type @arg port_type.
+ *
+ * this function may only be called in a buffer_size callback.
+ *)
+function jack_port_type_get_buffer_size (client: Pjack_client_t; const port_type: PChar): csize_t; cdecl; JACK_WEAK_EXPORT;
+
+///**@}*/
+
+(**
+ * @defgroup LatencyFunctions Managing and determining latency
+ * @{
+ *
+ * The purpose of JACK's latency API is to allow clients to
+ * easily answer two questions:
+ *
+ * - How long has it been since the data read from a port arrived
+ *   at the edge of the JACK graph (either via a physical port
+ *   or being synthesized from scratch)?
+ *
+ * - How long will it be before the data written to a port arrives
+ *   at the edge of a JACK graph?
+
+ * To help answering these two questions, all JACK ports have two
+ * latency values associated with them, both measured in frames:
+ *
+ * <b>capture latency</b>: how long since the data read from
+ *                  the buffer of a port arrived at
+ *                  a port marked with JackPortIsTerminal.
+ *                  The data will have come from the "outside
+ *                  world" if the terminal port is also
+ *                  marked with JackPortIsPhysical, or
+ *                  will have been synthesized by the client
+ *                  that owns the terminal port.
+ *
+ * <b>playback latency</b>: how long until the data
+ *                   written to the buffer of port will reach a port
+ *                   marked with JackPortIsTerminal.
+ *
+ * Both latencies might potentially have more than one value
+ * because there may be multiple pathways to/from a given port
+ * and a terminal port. Latency is therefore generally
+ * expressed a min/max pair.
+ *
+ * In most common setups, the minimum and maximum latency
+ * are the same, but this design accommodates more complex
+ * routing, and allows applications (and thus users) to
+ * detect cases where routing is creating an anomalous
+ * situation that may either need fixing or more
+ * sophisticated handling by clients that care about
+ * latency.
+ *
+ * See also @ref jack_set_latency_callback for details on how
+ * clients that add latency to the signal path should interact
+ * with JACK to ensure that the correct latency figures are
+ * used.
+ *)
+
+(**
+ * The port latency is zero by default. Clients that control
+ * physical hardware with non-zero latency should call this
+ * to set the latency to its correct value. Note that the value
+ * should include any systemic latency present "outside" the
+ * physical hardware controlled by the client. For example,
+ * for a client controlling a digital audio interface connected
+ * to an external digital converter, the latency setting should
+ * include both buffering by the audio interface *and* the converter.
+ *
+ * @deprecated This method will be removed in the next major
+ * release of JACK. It should not be used in new code, and should
+ * be replaced by a latency callback that calls @ref
+ * jack_port_set_latency_range().
+ *)
+procedure jack_port_set_latency (port: Pjack_port_t; nframes: jack_nframes_t); cdecl; JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT;
+
+(**
+ * return the latency range defined by @a mode for
+ * @a port, in frames.
+ *
+ * See @ref LatencyFunctions for the definition of each latency value.
+ *
+ * This function is best used from callbacks, specifically the latency callback.
+ * Before a port is connected, this returns the default latency: zero.
+ * Therefore it only makes sense to call jack_port_get_latency_range() when
+ * the port is connected, and that gets signalled by the latency callback.
+ * See @ref jack_set_latency_callback() for details.
+ *)
+procedure jack_port_get_latency_range (port: Pjack_port_t; mode: jack_latency_callback_mode_t; range: Pjack_latency_range_t); cdecl; JACK_WEAK_EXPORT;
+
+(**
+ * set the minimum and maximum latencies defined by
+ * @a mode for @a port, in frames.
+ *
+ * See @ref LatencyFunctions for the definition of each latency value.
+ *
+ * This function should ONLY be used inside a latency
+ * callback. The client should determine the current
+ * value of the latency using @ref jack_port_get_latency_range()
+ * (called using the same mode as @a mode)
+ * and then add some number of frames to that reflects
+ * latency added by the client.
+ *
+ * How much latency a client adds will vary
+ * dramatically. For most clients, the answer is zero
+ * and there is no reason for them to register a latency
+ * callback and thus they should never call this
+ * function.
+ *
+ * More complex clients that take an input signal,
+ * transform it in some way and output the result but
+ * not during the same process() callback will
+ * generally know a single constant value to add
+ * to the value returned by @ref jack_port_get_latency_range().
+ *
+ * Such clients would register a latency callback (see
+ * @ref jack_set_latency_callback) and must know what input
+ * ports feed which output ports as part of their
+ * internal state. Their latency callback will update
+ * the ports' latency values appropriately.
+ *
+ * A pseudo-code example will help. The @a mode argument to the latency
+ * callback will determine whether playback or capture
+ * latency is being set. The callback will use
+ * @ref jack_port_set_latency_range() as follows:
+ *
+ * \code
+ * jack_latency_range_t range;
+ * if (mode == JackPlaybackLatency) {
+ *  foreach input_port in (all self-registered port) {
+ *   jack_port_get_latency_range (port_feeding_input_port, JackPlaybackLatency, &range);
+ *   range.min += min_delay_added_as_signal_flows_from port_feeding to input_port;
+ *   range.max += max_delay_added_as_signal_flows_from port_feeding to input_port;
+ *   jack_port_set_latency_range (input_port, JackPlaybackLatency, &range);
+ *  }
+ * } else if (mode == JackCaptureLatency) {
+ *  foreach output_port in (all self-registered port) {
+ *   jack_port_get_latency_range (port_fed_by_output_port, JackCaptureLatency, &range);
+ *   range.min += min_delay_added_as_signal_flows_from_output_port_to_fed_by_port;
+ *   range.max += max_delay_added_as_signal_flows_from_output_port_to_fed_by_port;
+ *   jack_port_set_latency_range (output_port, JackCaptureLatency, &range);
+ *  }
+ * }
+ * \endcode
+ *
+ * In this relatively simple pseudo-code example, it is assumed that
+ * each input port or output is connected to only 1 output or input
+ * port respectively.
+ *
+ * If a port is connected to more than 1 other port, then the
+ * range.min and range.max values passed to @ref
+ * jack_port_set_latency_range() should reflect the minimum and
+ * maximum values across all connected ports.
+ *
+ * See the description of @ref jack_set_latency_callback for more
+ * information.
+ *)
+procedure jack_port_set_latency_range (port: Pjack_port_t; mode: jack_latency_callback_mode_t; range: Pjack_latency_range_t); cdecl; JACK_WEAK_EXPORT;
+
+(**
+ * Request a complete recomputation of all port latencies. This
+ * can be called by a client that has just changed the internal
+ * latency of its port using  jack_port_set_latency
+ * and wants to ensure that all signal pathways in the graph
+ * are updated with respect to the values that will be returned
+ * by  jack_port_get_total_latency. It allows a client
+ * to change multiple port latencies without triggering a
+ * recompute for each change.
+ *
+ * @return zero for successful execution of the request. non-zero
+ *         otherwise.
+ *)
+function jack_recompute_total_latencies (client: Pjack_client_t): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return the time (in frames) between data being available or
+ * delivered at/to a port, and the time at which it arrived at or is
+ * delivered to the "other side" of the port.  E.g. for a physical
+ * audio output port, this is the time between writing to the port and
+ * when the signal will leave the connector.  For a physical audio
+ * input port, this is the time between the sound arriving at the
+ * connector and the corresponding frames being readable from the
+ * port.
+ *
+ * @deprecated This method will be removed in the next major
+ * release of JACK. It should not be used in new code, and should
+ * be replaced by jack_port_get_latency_range() in any existing
+ * use cases.
+ *)
+function jack_port_get_latency (port: Pjack_port_t): jack_nframes_t; cdecl; JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT;
+
+(**
+ * The maximum of the sum of the latencies in every
+ * connection path that can be drawn between the port and other
+ * ports with the @ref JackPortIsTerminal flag set.
+ *
+ * @deprecated This method will be removed in the next major
+ * release of JACK. It should not be used in new code, and should
+ * be replaced by jack_port_get_latency_range() in any existing
+ * use cases.
+ *)
+function jack_port_get_total_latency (client: Pjack_client_t;
+                                      port: Pjack_port_t): jack_nframes_t; cdecl; JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT;
+
+(**
+ * Request a complete recomputation of a port's total latency. This
+ * can be called by a client that has just changed the internal
+ * latency of its port using  jack_port_set_latency
+ * and wants to ensure that all signal pathways in the graph
+ * are updated with respect to the values that will be returned
+ * by  jack_port_get_total_latency.
+ *
+ * @return zero for successful execution of the request. non-zero
+ *         otherwise.
+ *
+ * @deprecated This method will be removed in the next major
+ * release of JACK. It should not be used in new code, and should
+ * be replaced by jack_recompute_total_latencies() in any existing
+ * use cases.
+ *)
+function jack_recompute_total_latency (client: Pjack_client_t; port: Pjack_port_t): cint; cdecl; JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT;
+
+///**@}*/
+
+(**
+ * @defgroup PortSearching Looking up ports
+ * @{
+ *)
+
+(**
+ * @param port_name_pattern A regular expression used to select
+ * ports by name.  If NULL or of zero length, no selection based
+ * on name will be carried out.
+ * @param type_name_pattern A regular expression used to select
+ * ports by type.  If NULL or of zero length, no selection based
+ * on type will be carried out.
+ * @param flags A value used to select ports by their flags.
+ * If zero, no selection based on flags will be carried out.
+ *
+ * @return a NULL-terminated array of ports that match the specified
+ * arguments.  The caller is responsible for calling jack_free() any
+ * non-NULL returned value.
+ *
+ * @see jack_port_name_size(), jack_port_type_size()
+ *)
+function jack_get_ports (client: Pjack_client_t;
+                         const port_name_pattern: PChar;
+                         const type_name_pattern: PChar;
+                         flags: culong): PPChar; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return address of the jack_port_t named @a port_name.
+ *
+ * @see jack_port_name_size()
+ *)
+function jack_port_by_name (client: Pjack_client_t; const port_name: PChar): Pjack_port_t; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return address of the jack_port_t of a @a port_id.
+ *)
+function jack_port_by_id (client: Pjack_client_t;
+                          port_id: jack_port_id_t): Pjack_port_t; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+///**@}*/
+
+(**
+ * @defgroup TimeFunctions Handling time
+ * @{
+ *
+ * JACK time is in units of 'frames', according to the current sample rate.
+ * The absolute value of frame times is meaningless, frame times have meaning
+ * only relative to each other.
+ *)
+
+(**
+ * @return the estimated time in frames that has passed since the JACK
+ * server began the current process cycle.
+ *)
+function jack_frames_since_cycle_start (const client: Pjack_client_t): jack_nframes_t; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return the estimated current time in frames.
+ * This function is intended for use in other threads (not the process
+ * callback).  The return value can be compared with the value of
+ * jack_last_frame_time to relate time in other threads to JACK time.
+ *)
+function jack_frame_time (const client: Pjack_client_t): jack_nframes_t; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return the precise time at the start of the current process cycle.
+ * This function may only be used from the process callback, and can
+ * be used to interpret timestamps generated by jack_frame_time() in
+ * other threads with respect to the current process cycle.
+ *
+ * This is the only jack time function that returns exact time:
+ * when used during the process callback it always returns the same
+ * value (until the next process callback, where it will return
+ * that value + nframes, etc).  The return value is guaranteed to be
+ * monotonic and linear in this fashion unless an xrun occurs.
+ * If an xrun occurs, clients must check this value again, as time
+ * may have advanced in a non-linear way (e.g. cycles may have been skipped).
+ *)
+function jack_last_frame_time (const client: Pjack_client_t): jack_nframes_t; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * This function may only be used from the process callback.
+ * It provides the internal cycle timing information as used by
+ * most of the other time related functions. This allows the
+ * caller to map between frame counts and microseconds with full
+ * precision (i.e. without rounding frame times to integers),
+ * and also provides e.g. the microseconds time of the start of
+ * the current cycle directly (it has to be computed otherwise).
+ *
+ * If the return value is zero, the following information is
+ * provided in the variables pointed to by the arguments:
+ *
+ * current_frames: the frame time counter at the start of the
+ *                 current cycle, same as jack_last_frame_time().
+ * current_usecs:  the microseconds time at the start of the
+ *                 current cycle.
+ * next_usecs:     the microseconds time of the start of the next
+ *                 next cycle as computed by the DLL.
+ * period_usecs:   the current best estimate of the period time in
+ *                  microseconds.
+ *
+ * NOTES:
+ * 
+ * Because of the types used, all the returned values except period_usecs
+ * are unsigned. In computations mapping between frames and microseconds
+ * *signed* differences are required. The easiest way is to compute those
+ * separately and assign them to the appropriate signed variables,
+ * int32_t for frames and int64_t for usecs. See the implementation of
+ * jack_frames_to_time() and Jack_time_to_frames() for an example.
+ * 
+ * Unless there was an xrun, skipped cycles, or the current cycle is the
+ * first after freewheeling or starting Jack, the value of current_usecs
+ * will always be the value of next_usecs of the previous cycle.
+ *
+ * The value of period_usecs will in general NOT be exactly equal to
+ * the difference of next_usecs and current_usecs. This is because to
+ * ensure stability of the DLL and continuity of the mapping, a fraction
+ * of the loop error must be included in next_usecs. For an accurate
+ * mapping between frames and microseconds, the difference of next_usecs
+ * and current_usecs should be used, and not period_usecs.
+ *
+ * @return zero if OK, non-zero otherwise.
+ *)
+function jack_get_cycle_times(const client: Pjack_client_t;
+                              current_frames: Pjack_nframes_t;
+                              current_usecs:  Pjack_time_t;
+                              next_usecs:     Pjack_time_t;
+                              period_usecs:   Pcfloat): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+                  
+(**
+ * @return the estimated time in microseconds of the specified frame time
+ *)
+function jack_frames_to_time(const client: Pjack_client_t; nframes: jack_nframes_t): jack_time_t; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return the estimated time in frames for the specified system time.
+ *)
+function jack_time_to_frames(const client: Pjack_client_t; time: jack_time_t): jack_nframes_t; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * @return return JACK's current system time in microseconds,
+ *         using the JACK clock source.
+ *
+ * The value returned is guaranteed to be monotonic, but not linear.
+ *)
+function jack_get_time: jack_time_t; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+///**@}*/
+
+(**
+ * @defgroup ErrorOutput Controlling error/information output
+ * @{
+ *)
+
+(**
+ * Display JACK error message.
+ *
+ * Set via jack_set_error_function(), otherwise a JACK-provided
+ * default will print @a msg (plus a newline) to stderr.
+ *
+ * @param msg error message text (no newline at end).
+ *)
+type
+  TJackErrorFunction = procedure (const msg: PChar); cdecl;
+var
+  jack_error_callback: TJackErrorFunction; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Set the @ref jack_error_callback for error message display.
+ * Set it to NULL to restore default_jack_error_callback function.
+ *
+ * The JACK library provides two built-in callbacks for this purpose:
+ * default_jack_error_callback() and silent_jack_error_callback().
+ *)
+procedure jack_set_error_function (func: TJackErrorFunction); cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Display JACK info message.
+ *
+ * Set via jack_set_info_function(), otherwise a JACK-provided
+ * default will print @a msg (plus a newline) to stdout.
+ *
+ * @param msg info message text (no newline at end).
+ *)
+type
+  TJackInfoFunction = procedure (const msg: PChar); cdecl;
+var
+  jack_info_callback: TJackInfoFunction; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Set the @ref jack_info_callback for info message display.
+ * Set it to NULL to restore default_jack_info_callback function.
+ *
+ * The JACK library provides two built-in callbacks for this purpose:
+ * default_jack_info_callback() and silent_jack_info_callback().
+ *)
+procedure jack_set_info_function (func: TJackInfoFunction); cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+///**@}*/
+
+(**
+ * The free function to be used on memory returned by jack_port_get_connections,
+ * jack_port_get_all_connections, jack_get_ports and jack_get_internal_client_name functions.
+ * This is MANDATORY on Windows when otherwise all nasty runtime version related crashes can occur.
+ * Developers are strongly encouraged to use this function instead of the standard "free" function in new code.
+ *
+ * @param ptr the memory pointer to be deallocated.
+ *)
+procedure jack_free(ptr: Pointer); cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+
+//#ifdef __cplusplus
+//}
+//#endif
+
+{$endif __jack_h__}
+
+implementation
+
+end.
+

packages/libjack/src/systemdeps.inc

@@ -0,0 +1,145 @@
+(*
+Copyright (C) 2004-2012 Grame
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*)
+
+{$ifndef __jack_systemdeps_h__}
+{$define __jack_systemdeps_h__}
+
+(*#ifndef POST_PACKED_STRUCTURE
+
+    #ifdef __GNUC__
+        /* POST_PACKED_STRUCTURE needs to be a macro which
+           expands into a compiler directive. The directive must
+           tell the compiler to arrange the preceding structure
+           declaration so that it is packed on byte-boundaries rather 
+           than use the natural alignment of the processor and/or
+           compiler.
+        */
+
+        #define PRE_PACKED_STRUCTURE
+        #define POST_PACKED_STRUCTURE __attribute__((__packed__))
+
+    #else
+    
+        #ifdef _MSC_VER
+            #define PRE_PACKED_STRUCTURE1 __pragma(pack(push,1))
+            #define PRE_PACKED_STRUCTURE    PRE_PACKED_STRUCTURE1
+            /* PRE_PACKED_STRUCTURE needs to be a macro which
+            expands into a compiler directive. The directive must
+            tell the compiler to arrange the following structure
+            declaration so that it is packed on byte-boundaries rather
+            than use the natural alignment of the processor and/or
+            compiler.
+            */
+            #define POST_PACKED_STRUCTURE ;__pragma(pack(pop))
+            /* and POST_PACKED_STRUCTURE needs to be a macro which
+            restores the packing to its previous setting */
+        #else
+            #define PRE_PACKED_STRUCTURE
+            #define POST_PACKED_STRUCTURE
+        #endif /* _MSC_VER */
+
+    #endif /* __GNUC__ */
+
+#endif
+
+#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(GNU_WIN32)
+
+    #ifdef __MINGW32__
+    #  include <winsock2.h> // mingw gives warning if we include windows.h before winsock2.h
+    #endif
+
+    #include <windows.h>
+
+    #ifdef _MSC_VER     /* Microsoft compiler */
+        #define __inline__ inline
+        #if (!defined(int8_t) && !defined(_STDINT_H))
+            #define __int8_t_defined
+            typedef INT8 int8_t;
+            typedef UINT8 uint8_t;
+            typedef INT16 int16_t;
+            typedef UINT16 uint16_t;
+            typedef INT32 int32_t;
+            typedef UINT32 uint32_t;
+            typedef INT64 int64_t;
+            typedef UINT64 uint64_t;
+        #endif
+    #elif __MINGW32__   /* MINGW */
+        #include <stdint.h>
+        #include <sys/types.h>
+    #else               /* other compilers ...*/
+        #include <inttypes.h>
+        #include <pthread.h>
+        #include <sys/types.h>
+    #endif
+
+    #if !defined(_PTHREAD_H) && !defined(PTHREAD_WIN32)
+        /**
+         *  to make jack API independent of different thread implementations,
+         *  we define jack_native_thread_t to HANDLE here.
+         */
+        typedef HANDLE jack_native_thread_t;
+    #else
+        #ifdef PTHREAD_WIN32            // Added by JE - 10-10-2011
+            #include <ptw32/pthread.h>  // Makes sure we #include the ptw32 version !
+        #endif
+        /**
+         *  to make jack API independent of different thread implementations,
+         *  we define jack_native_thread_t to pthread_t here.
+         */
+        typedef pthread_t jack_native_thread_t;
+    #endif
+
+#endif /* _WIN32 && !__CYGWIN__ && !GNU_WIN32 */
+
+#if defined(__APPLE__) || defined(__linux__) || defined(__sun__) || defined(sun) || defined(__unix__) || defined(__CYGWIN__) || defined(GNU_WIN32)
+
+    #if defined(__CYGWIN__) || defined(GNU_WIN32)
+        #include <stdint.h>
+    #endif
+        #include <inttypes.h>
+        #include <pthread.h>
+        #include <sys/types.h>
+
+        /**
+         *  to make jack API independent of different thread implementations,
+         *  we define jack_native_thread_t to pthread_t here.
+         */
+        typedef pthread_t jack_native_thread_t;
+
+#endif /* __APPLE__ || __linux__ || __sun__ || sun */*)
+
+type
+  jack_native_thread_t = System.TThreadID;
+
+(*#if (defined(__arm__) || defined(__aarch64__) || defined(__mips__) || defined(__ppc__) || defined(__powerpc__)) && !defined(__APPLE__)
+    #undef POST_PACKED_STRUCTURE
+    #define POST_PACKED_STRUCTURE
+#endif /* __arm__ || __aarch64__ || __mips__ || __ppc__ || __powerpc__ */
+
+/** define JACK_LIB_EXPORT, useful for internal clients */
+#if defined(_WIN32)
+    #define JACK_LIB_EXPORT __declspec(dllexport)
+#elif defined(__GNUC__)
+    #define JACK_LIB_EXPORT __attribute__((visibility("default")))
+#else
+    #define JACK_LIB_EXPORT
+#endif*)
+
+{$endif __jack_systemdeps_h__}
+

packages/libjack/src/t_jack.h2paschk

@@ -0,0 +1,115 @@
+# OpenBSD RTL-to-C structure compatibility checker description file
+#
+# Use
+#   h2paschk t_jack.h2paschk
+#
+# ...to generate Pascal and C code, then make sure they both compile and that
+# the Pascal program produces the same output as the C program for each
+# supported architecture.
+
+@Pascal uses jack;
+@Pascal begin
+
+@C #include <jack/jack.h>
+@C #include <stdio.h>
+@C #include <stddef.h>
+@C int main()
+@C {
+
+@type jack_native_thread_t
+@type jack_uuid_t
+@type jack_shmsize_t
+@type jack_nframes_t
+@constant JACK_MAX_FRAMES
+@type jack_time_t
+@constant JACK_LOAD_INIT_LIMIT
+@type jack_intclient_t
+#@type jack_port_t
+#@type jack_client_t
+@type jack_port_id_t
+@type jack_port_type_id_t
+@constant JackOpenOptions
+@constant JackLoadOptions
+@type jack_options_t
+@type jack_status_t
+@type jack_latency_callback_mode_t
+@type TJackLatencyCallback,JackLatencyCallback
+
+@record jack_latency_range_t
+.min
+.max
+
+@type TJackProcessCallback,JackProcessCallback
+@type TJackThreadCallback,JackThreadCallback
+@type TJackThreadInitCallback,JackThreadInitCallback
+@type TJackGraphOrderCallback,JackGraphOrderCallback
+@type TJackXRunCallback,JackXRunCallback
+@type TJackBufferSizeCallback,JackBufferSizeCallback
+@type TJackSampleRateCallback,JackSampleRateCallback
+@type TJackPortRegistrationCallback,JackPortRegistrationCallback
+@type TJackClientRegistrationCallback,JackClientRegistrationCallback
+@type TJackPortConnectCallback,JackPortConnectCallback
+@type TJackPortRenameCallback,JackPortRenameCallback
+@type TJackFreewheelCallback,JackFreewheelCallback
+@type TJackShutdownCallback,JackShutdownCallback
+@type TJackInfoShutdownCallback,JackInfoShutdownCallback
+
+#@stringconstant JACK_DEFAULT_AUDIO_TYPE
+#@stringconstant JACK_DEFAULT_MIDI_TYPE
+
+@type jack_default_audio_sample_t
+@type jack_transport_state_t
+@type jack_unique_t
+@type jack_position_bits_t
+@constant JACK_POSITION_MASK
+
+@record jack_position_t
+.unique_1
+.usecs
+.frame_rate
+.frame
+.valid
+.bar
+.beat
+.tick
+.bar_start_tick
+.beats_per_bar
+.beat_type
+.ticks_per_beat
+.beats_per_minute
+.frame_time
+.next_time
+.bbt_offset
+.audio_frames_per_video_frame
+.video_offset
+.tick_double
+.padding
+.unique_2
+
+@type TJackSyncCallback,JackSyncCallback
+@type TJackTimebaseCallback,JackTimebaseCallback
+@type jack_transport_bits_t
+
+@record jack_transport_info_t
+.frame_rate
+.usecs
+.valid
+.transport_state
+.frame
+.loop_start
+.loop_end
+.smpte_offset
+.smpte_frame_rate
+.bar
+.beat
+.tick
+.bar_start_tick
+.beats_per_bar
+.beat_type
+.ticks_per_beat
+.beats_per_minute
+
+@C   return 0;
+@C }
+
+@Pascal end.

packages/libjack/src/transport.inc

@@ -0,0 +1,250 @@
+(*
+    Copyright (C) 2002 Paul Davis
+    Copyright (C) 2003 Jack O'Quin
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 2.1 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    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
+    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+*)
+
+{$ifndef __jack_transport_h__}
+{$define __jack_transport_h__}
+
+//#ifdef __cplusplus
+//extern "C" {
+//#endif
+
+//#include <jack/types.h>
+{$I types.inc}
+//#include <jack/weakmacros.h>
+{$I weakmacros.inc}
+
+(**
+ * @defgroup TransportControl Transport and Timebase control
+ * @{
+ *)
+
+(**
+ * Called by the timebase master to release itself from that
+ * responsibility.
+ *
+ * If the timebase master releases the timebase or leaves the JACK
+ * graph for any reason, the JACK engine takes over at the start of
+ * the next process cycle.  The transport state does not change.  If
+ * rolling, it continues to play, with frame numbers as the only
+ * available position information.
+ *
+ * @see jack_set_timebase_callback
+ *
+ * @param client the JACK client structure.
+ *
+ * @return 0 on success, otherwise a non-zero error code.
+ *)
+function jack_release_timebase (client: Pjack_client_t): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Register (or unregister) as a slow-sync client, one that cannot
+ * respond immediately to transport position changes.
+ *
+ * The @a sync_callback will be invoked at the first available
+ * opportunity after its registration is complete.  If the client is
+ * currently active this will be the following process cycle,
+ * otherwise it will be the first cycle after calling jack_activate().
+ * After that, it runs according to the ::JackSyncCallback rules.
+ * Clients that don't set a @a sync_callback are assumed to be ready
+ * immediately any time the transport wants to start.
+ *
+ * @param client the JACK client structure.
+ * @param sync_callback is a realtime function that returns TRUE when
+ * the client is ready.  Setting @a sync_callback to NULL declares that
+ * this client no longer requires slow-sync processing.
+ * @param arg an argument for the @a sync_callback function.
+ *
+ * @return 0 on success, otherwise a non-zero error code.
+ *)
+function jack_set_sync_callback (client: Pjack_client_t;
+                                 sync_callback: TJackSyncCallback;
+                                 arg: Pointer): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Set the timeout value for slow-sync clients.
+ *
+ * This timeout prevents unresponsive slow-sync clients from
+ * completely halting the transport mechanism.  The default is two
+ * seconds.  When the timeout expires, the transport starts rolling,
+ * even if some slow-sync clients are still unready.  The @a
+ * sync_callbacks of these clients continue being invoked, giving them
+ * a chance to catch up.
+ *
+ * @see jack_set_sync_callback
+ *
+ * @param client the JACK client structure.
+ * @param timeout is delay (in microseconds) before the timeout expires.
+ *
+ * @return 0 on success, otherwise a non-zero error code.
+ *)
+function jack_set_sync_timeout (client: Pjack_client_t;
+                                timeout: jack_time_t): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Register as timebase master for the JACK subsystem.
+ *
+ * The timebase master registers a callback that updates extended
+ * position information such as beats or timecode whenever necessary.
+ * Without this extended information, there is no need for this
+ * function.
+ *
+ * There is never more than one master at a time.  When a new client
+ * takes over, the former @a timebase_callback is no longer called.
+ * Taking over the timebase may be done conditionally, so it fails if
+ * there was a master already.
+ *
+ * @param client the JACK client structure.
+ * @param conditional non-zero for a conditional request.
+ * @param timebase_callback is a realtime function that returns
+ * position information.
+ * @param arg an argument for the @a timebase_callback function.
+ *
+ * @return
+ *   - 0 on success;
+ *   - EBUSY if a conditional request fails because there was already a
+ *   timebase master;
+ *   - other non-zero error code.
+ *)
+function jack_set_timebase_callback (client: Pjack_client_t;
+                                     conditional: cint;
+                                     timebase_callback: TJackTimebaseCallback;
+                                     arg: Pointer): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Reposition the transport to a new frame number.
+ *
+ * May be called at any time by any client.  The new position takes
+ * effect in two process cycles.  If there are slow-sync clients and
+ * the transport is already rolling, it will enter the
+ * ::JackTransportStarting state and begin invoking their @a
+ * sync_callbacks until ready.  This function is realtime-safe.
+ *
+ * @see jack_transport_reposition, jack_set_sync_callback
+ *
+ * @param client the JACK client structure.
+ * @param frame frame number of new transport position.
+ *
+ * @return 0 if valid request, non-zero otherwise.
+ *)
+function jack_transport_locate (client: Pjack_client_t;
+                                frame: jack_nframes_t): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Query the current transport state and position.
+ *
+ * This function is realtime-safe, and can be called from any thread.
+ * If called from the process thread, @a pos corresponds to the first
+ * frame of the current cycle and the state returned is valid for the
+ * entire cycle.
+ *
+ * @param client the JACK client structure.
+ * @param pos pointer to structure for returning current transport
+ * position; @a pos->valid will show which fields contain valid data.
+ * If @a pos is NULL, do not return position information.
+ *
+ * @return Current transport state.
+ *)
+function jack_transport_query (const client: Pjack_client_t;
+                               pos: Pjack_position_t): jack_transport_state_t; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Return an estimate of the current transport frame,
+ * including any time elapsed since the last transport
+ * positional update.
+ *
+ * @param client the JACK client structure
+ *)
+function jack_get_current_transport_frame (const client: Pjack_client_t): jack_nframes_t; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Request a new transport position.
+ *
+ * May be called at any time by any client.  The new position takes
+ * effect in two process cycles.  If there are slow-sync clients and
+ * the transport is already rolling, it will enter the
+ * ::JackTransportStarting state and begin invoking their @a
+ * sync_callbacks until ready.  This function is realtime-safe.
+ *
+ * @see jack_transport_locate, jack_set_sync_callback
+ *
+ * @param client the JACK client structure.
+ * @param pos requested new transport position.
+ *
+ * @return 0 if valid request, EINVAL if position structure rejected.
+ *)
+function jack_transport_reposition (client: Pjack_client_t;
+                                    const pos: Pjack_position_t): cint; cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Start the JACK transport rolling.
+ *
+ * Any client can make this request at any time.  It takes effect no
+ * sooner than the next process cycle, perhaps later if there are
+ * slow-sync clients.  This function is realtime-safe.
+ *
+ * @see jack_set_sync_callback
+ *
+ * @param client the JACK client structure.
+ *)
+procedure jack_transport_start (client: Pjack_client_t); cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Stop the JACK transport.
+ *
+ * Any client can make this request at any time.  It takes effect on
+ * the next process cycle.  This function is realtime-safe.
+ *
+ * @param client the JACK client structure.
+ *)
+procedure jack_transport_stop (client: Pjack_client_t); cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Gets the current transport info structure (deprecated).
+ *
+ * @param client the JACK client structure.
+ * @param tinfo current transport info structure.  The "valid" field
+ * describes which fields contain valid data.
+ *
+ * @deprecated This is for compatibility with the earlier transport
+ * interface.  Use jack_transport_query(), instead.
+ *
+ * @pre Must be called from the process thread.
+ *)
+procedure jack_get_transport_info (client: Pjack_client_t;
+                                   tinfo: Pjack_transport_info_t); cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+(**
+ * Set the transport info structure (deprecated).
+ *
+ * @deprecated This function still exists for compatibility with the
+ * earlier transport interface, but it does nothing.  Instead, define
+ * a ::JackTimebaseCallback.
+ *)
+procedure jack_set_transport_info (client: Pjack_client_t;
+                                   tinfo: Pjack_transport_info_t); cdecl; JACK_OPTIONAL_WEAK_EXPORT;
+
+///**@}*/
+
+//#ifdef __cplusplus
+//}
+//#endif
+
+{$endif __jack_transport_h__}
+

packages/libjack/src/types.inc

@@ -0,0 +1,820 @@
+(*
+  Copyright (C) 2001 Paul Davis
+  Copyright (C) 2004 Jack O'Quin
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Lesser General Public License as published by
+  the Free Software Foundation; either version 2.1 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  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
+  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+*)
+
+{$ifndef __jack_types_h__}
+{$define __jack_types_h__}
+
+//#include <jack/systemdeps.h>
+{$I systemdeps.inc}
+
+type
+  PPjack_uuid_t = ^Pjack_uuid_t;
+  Pjack_uuid_t = ^jack_uuid_t;
+  jack_uuid_t = uint64_t;
+
+  PPjack_shmsize_t = ^Pjack_shmsize_t;
+  Pjack_shmsize_t = ^jack_shmsize_t;
+  jack_shmsize_t = int32_t;
+
+(**
+ * Type used to represent sample frame counts.
+ *)
+  PPjack_nframes_t = ^Pjack_nframes_t;
+  Pjack_nframes_t = ^jack_nframes_t;
+  jack_nframes_t = uint32_t;
+
+(**
+ * Maximum value that can be stored in jack_nframes_t
+ *)
+const
+  JACK_MAX_FRAMES = 4294967295;   { This should be UINT32_MAX, but C++ has a problem with that. }
+
+(**
+ * Type used to represent the value of free running
+ * monotonic clock with units of microseconds.
+ *)
+type
+  PPjack_time_t = ^Pjack_time_t;
+  Pjack_time_t = ^jack_time_t;
+  jack_time_t = uint64_t;
+
+(**
+ *  Maximum size of @a load_init string passed to an internal client
+ *  jack_initialize() function via jack_internal_client_load().
+ *)
+const
+  JACK_LOAD_INIT_LIMIT = 1024;
+
+(**
+ *  jack_intclient_t is an opaque type representing a loaded internal
+ *  client.  You may only access it using the API provided in @ref
+ *  intclient.h "<jack/intclient.h>".
+ *)
+type
+  PPjack_intclient_t = ^Pjack_intclient_t;
+  Pjack_intclient_t = ^jack_intclient_t;
+  jack_intclient_t = uint64_t;
+
+(**
+ *  jack_port_t is an opaque type.  You may only access it using the
+ *  API provided.
+ *)
+//typedef struct _jack_port jack_port_t;
+  PPjack_port_t = ^Pjack_port_t;
+  Pjack_port_t = ^jack_port_t;
+  jack_port_t = record end;
+
+(**
+ *  jack_client_t is an opaque type.  You may only access it using the
+ *  API provided.
+ *)
+//typedef struct _jack_client jack_client_t;
+  PPjack_client_t = ^Pjack_client_t;
+  Pjack_client_t = ^jack_client_t;
+  jack_client_t = record end;
+
+(**
+ *  Ports have unique ids. A port registration callback is the only
+ *  place you ever need to know their value.
+ *)
+  PPjack_port_id_t = ^jack_port_id_t;
+  Pjack_port_id_t = ^jack_port_id_t;
+  jack_port_id_t = uint32_t;
+
+  PPjack_port_type_id_t = ^Pjack_port_type_id_t;
+  Pjack_port_type_id_t = ^jack_port_type_id_t;
+  jack_port_type_id_t = uint32_t;
+
+(**
+ *  @ref jack_options_t bits
+ *)
+  JackOptions = (
+
+    (**
+     * Null value to use when no option bits are needed.
+     *)
+    JackNullOption = $00,
+
+    (**
+     * Do not automatically start the JACK server when it is not
+     * already running.  This option is always selected if
+     * \$JACK_NO_START_SERVER is defined in the calling process
+     * environment.
+     *)
+    JackNoStartServer = $01,
+
+    (**
+     * Use the exact client name requested.  Otherwise, JACK
+     * automatically generates a unique one, if needed.
+     *)
+    JackUseExactName = $02,
+
+    (**
+     * Open with optional <em>(char * ) server_name</em> parameter.
+     *)
+    JackServerName = $04,
+
+    (**
+     * Load internal client from optional <em>(char * )
+     * load_name</em>.  Otherwise use the @a client_name.
+     *)
+    JackLoadName = $08,
+
+    (**
+     * Pass optional <em>(char * ) load_init</em> string to the
+     * jack_initialize() entry point of an internal client.
+     *)
+    JackLoadInit = $10,
+
+     (**
+      * pass a SessionID Token this allows the sessionmanager to identify the client again.
+      *)
+    JackSessionID = $20
+);
+
+(** Valid options for opening an external client. *)
+const
+  JackOpenOptions = JackOptions(Ord(JackSessionID) or Ord(JackServerName) or Ord(JackNoStartServer) or Ord(JackUseExactName));
+
+(** Valid options for loading an internal client. *)
+  JackLoadOptions = JackOptions(Ord(JackLoadInit) or Ord(JackLoadName) or Ord(JackUseExactName));
+
+(**
+ *  Options for several JACK operations, formed by OR-ing together the
+ *  relevant @ref JackOptions bits.
+ *)
+type
+  PPjack_options_t = ^Pjack_options_t;
+  Pjack_options_t = ^jack_options_t;
+  jack_options_t = JackOptions;
+
+(**
+ *  @ref jack_status_t bits
+ *)
+  JackStatus = (
+
+    (**
+     * Overall operation failed.
+     *)
+    JackFailure = $01,
+
+    (**
+     * The operation contained an invalid or unsupported option.
+     *)
+    JackInvalidOption = $02,
+
+    (**
+     * The desired client name was not unique.  With the @ref
+     * JackUseExactName option this situation is fatal.  Otherwise,
+     * the name was modified by appending a dash and a two-digit
+     * number in the range "-01" to "-99".  The
+     * jack_get_client_name() function will return the exact string
+     * that was used.  If the specified @a client_name plus these
+     * extra characters would be too long, the open fails instead.
+     *)
+    JackNameNotUnique = $04,
+
+    (**
+     * The JACK server was started as a result of this operation.
+     * Otherwise, it was running already.  In either case the caller
+     * is now connected to jackd, so there is no race condition.
+     * When the server shuts down, the client will find out.
+     *)
+    JackServerStarted = $08,
+
+    (**
+     * Unable to connect to the JACK server.
+     *)
+    JackServerFailed = $10,
+
+    (**
+     * Communication error with the JACK server.
+     *)
+    JackServerError = $20,
+
+    (**
+     * Requested client does not exist.
+     *)
+    JackNoSuchClient = $40,
+
+    (**
+     * Unable to load internal client
+     *)
+    JackLoadFailure = $80,
+
+    (**
+     * Unable to initialize client
+     *)
+    JackInitFailure = $100,
+
+    (**
+     * Unable to access shared memory
+     *)
+    JackShmFailure = $200,
+
+    (**
+     * Client's protocol version does not match
+     *)
+    JackVersionError = $400,
+
+    (**
+     * Backend error
+     *)
+    JackBackendError = $800,
+
+    (**
+     * Client zombified failure
+     *)
+    JackClientZombie = $1000
+);
+
+(**
+ *  Status word returned from several JACK operations, formed by
+ *  OR-ing together the relevant @ref JackStatus bits.
+ *)
+  PPjack_status_t = ^Pjack_status_t;
+  Pjack_status_t = ^jack_status_t;
+  jack_status_t = JackStatus;
+
+(**
+ *  @ref jack_latency_callback_mode_t
+ *)
+  JackLatencyCallbackMode = (
+
+     (**
+      * Latency Callback for Capture Latency.
+      * Input Ports have their latency value setup.
+      * In the Callback the client needs to set the latency of the output ports
+      *)
+     JackCaptureLatency,
+
+     (**
+      * Latency Callback for Playback Latency.
+      * Output Ports have their latency value setup.
+      * In the Callback the client needs to set the latency of the input ports
+      *)
+     JackPlaybackLatency
+
+);
+
+(**
+ *  Type of Latency Callback (Capture or Playback)
+ *)
+  PPjack_latency_callback_mode_t = ^Pjack_latency_callback_mode_t;
+  Pjack_latency_callback_mode_t = ^jack_latency_callback_mode_t;
+  jack_latency_callback_mode_t = JackLatencyCallbackMode;
+
+(**
+ * Prototype for the client supplied function that is called
+ * by the engine when port latencies need to be recalculated
+ *
+ * @param mode playback or capture latency
+ * @param arg pointer to a client supplied data
+ *
+ * @return zero on success, non-zero on error
+ *)
+//typedef void (*JackLatencyCallback)(jack_latency_callback_mode_t mode, void *arg);
+  TJackLatencyCallback = procedure(mode: jack_latency_callback_mode_t; arg: Pointer); cdecl;
+
+(**
+ * the new latency API operates on Ranges.
+ *)
+//PRE_PACKED_STRUCTURE
+  _jack_latency_range = packed record
+    (**
+     * minimum latency
+     *)
+    min: jack_nframes_t;
+    (**
+     * maximum latency
+     *)
+    max: jack_nframes_t;
+  end;
+//} POST_PACKED_STRUCTURE;
+
+//typedef struct _jack_latency_range jack_latency_range_t;
+  PPjack_latency_range_t = ^Pjack_latency_range_t;
+  Pjack_latency_range_t = ^jack_latency_range_t;
+  jack_latency_range_t = _jack_latency_range;
+
+(**
+ * Prototype for the client supplied function that is called
+ * by the engine anytime there is work to be done.
+ *
+ * @pre nframes == jack_get_buffer_size()
+ * @pre nframes == pow(2,x)
+ *
+ * @param nframes number of frames to process
+ * @param arg pointer to a client supplied structure
+ *
+ * @return zero on success, non-zero on error
+ *)
+//typedef int (*JackProcessCallback)(jack_nframes_t nframes, void *arg);
+  TJackProcessCallback = function(nframes: jack_nframes_t; arg: Pointer): cint; cdecl;
+
+(**
+ * Prototype for the client thread routine called
+ * by the engine when the client is inserted in the graph.
+ *
+ * @param arg pointer to a client supplied structure
+ *
+ *)
+//typedef void *(*JackThreadCallback)(void* arg);
+  TJackThreadCallback = function(arg: Pointer): Pointer; cdecl;
+
+(**
+ * Prototype for the client supplied function that is called
+ * once after the creation of the thread in which other
+ * callbacks will be made. Special thread characteristics
+ * can be set from this callback, for example. This is a
+ * highly specialized callback and most clients will not
+ * and should not use it.
+ *
+ * @param arg pointer to a client supplied structure
+ *
+ * @return void
+ *)
+//typedef void (*JackThreadInitCallback)(void *arg);
+  TJackThreadInitCallback = procedure(arg: Pointer); cdecl;
+
+(**
+ * Prototype for the client supplied function that is called
+ * whenever the processing graph is reordered.
+ *
+ * @param arg pointer to a client supplied structure
+ *
+ * @return zero on success, non-zero on error
+ *)
+//typedef int (*JackGraphOrderCallback)(void *arg);
+  TJackGraphOrderCallback = function(arg: Pointer): cint; cdecl;
+
+(**
+ * Prototype for the client-supplied function that is called whenever
+ * an xrun has occurred.
+ *
+ * @see jack_get_xrun_delayed_usecs()
+ *
+ * @param arg pointer to a client supplied structure
+ *
+ * @return zero on success, non-zero on error
+ *)
+//typedef int (*JackXRunCallback)(void *arg);
+  TJackXRunCallback = function(arg: Pointer): cint; cdecl;
+
+(**
+ * Prototype for the @a bufsize_callback that is invoked whenever the
+ * JACK engine buffer size changes.  Although this function is called
+ * in the JACK process thread, the normal process cycle is suspended
+ * during its operation, causing a gap in the audio flow.  So, the @a
+ * bufsize_callback can allocate storage, touch memory not previously
+ * referenced, and perform other operations that are not realtime
+ * safe.
+ *
+ * @param nframes buffer size
+ * @param arg pointer supplied by jack_set_buffer_size_callback().
+ *
+ * @return zero on success, non-zero on error
+ *)
+//typedef int (*JackBufferSizeCallback)(jack_nframes_t nframes, void *arg);
+  TJackBufferSizeCallback = function(nframes: jack_nframes_t; arg: Pointer): cint; cdecl;
+
+(**
+ * Prototype for the client supplied function that is called
+ * when the engine sample rate changes.
+ *
+ * @param nframes new engine sample rate
+ * @param arg pointer to a client supplied structure
+ *
+ * @return zero on success, non-zero on error
+ *)
+//typedef int (*JackSampleRateCallback)(jack_nframes_t nframes, void *arg);
+  TJackSampleRateCallback = function(nframes: jack_nframes_t; arg: Pointer): cint; cdecl;
+
+(**
+ * Prototype for the client supplied function that is called
+ * whenever a port is registered or unregistered.
+ *
+ * @param port the ID of the port
+ * @param arg pointer to a client supplied data
+ * @param register non-zero if the port is being registered,
+ *                     zero if the port is being unregistered
+ *)
+//typedef void (*JackPortRegistrationCallback)(jack_port_id_t port, int /* register */, void *arg);
+  TJackPortRegistrationCallback = procedure(port: jack_port_id_t; register: cint; arg: Pointer); cdecl;
+
+(**
+ * Prototype for the client supplied function that is called
+ * whenever a client is registered or unregistered.
+ *
+ * @param name a null-terminated string containing the client name
+ * @param register non-zero if the client is being registered,
+ *                     zero if the client is being unregistered
+ * @param arg pointer to a client supplied structure
+ *)
+//typedef void (*JackClientRegistrationCallback)(const char* name, int /* register */, void *arg);
+  TJackClientRegistrationCallback = procedure(name: PChar; register: cint; arg: Pointer); cdecl;
+
+(**
+ * Prototype for the client supplied function that is called
+ * whenever a port is connected or disconnected.
+ *
+ * @param a one of two ports connected or disconnected
+ * @param b one of two ports connected or disconnected
+ * @param connect non-zero if ports were connected
+ *                    zero if ports were disconnected
+ * @param arg pointer to a client supplied data
+ *)
+//typedef void (*JackPortConnectCallback)(jack_port_id_t a, jack_port_id_t b, int connect, void* arg);
+  TJackPortConnectCallback = procedure(a, b: jack_port_id_t; connect: cint; arg: Pointer); cdecl;
+
+(**
+ * Prototype for the client supplied function that is called
+ * whenever the port name has been changed.
+ *
+ * @param port the port that has been renamed
+ * @param new_name the new name
+ * @param arg pointer to a client supplied structure
+ *)
+//typedef void (*JackPortRenameCallback)(jack_port_id_t port, const char* old_name, const char* new_name, void *arg);
+  TJackPortRenameCallback = procedure(port: jack_port_id_t; old_name, new_name: PChar; arg: Pointer); cdecl;
+
+(**
+ * Prototype for the client supplied function that is called
+ * whenever jackd starts or stops freewheeling.
+ *
+ * @param starting non-zero if we start starting to freewheel, zero otherwise
+ * @param arg pointer to a client supplied structure
+ *)
+//typedef void (*JackFreewheelCallback)(int starting, void *arg);
+  TJackFreewheelCallback = procedure(starting: cint; arg: Pointer); cdecl;
+
+(**
+ * Prototype for the client supplied function that is called
+ * whenever jackd is shutdown. Note that after server shutdown,
+ * the client pointer is *not* deallocated by libjack,
+ * the application is responsible to properly use jack_client_close()
+ * to release client resources. Warning: jack_client_close() cannot be
+ * safely used inside the shutdown callback and has to be called outside of
+ * the callback context.
+ *
+ * @param arg pointer to a client supplied structure
+ *)
+//typedef void (*JackShutdownCallback)(void *arg);
+  TJackShutdownCallback = procedure(arg: Pointer); cdecl;
+
+(**
+ * Prototype for the client supplied function that is called
+ * whenever jackd is shutdown. Note that after server shutdown,
+ * the client pointer is *not* deallocated by libjack,
+ * the application is responsible to properly use jack_client_close()
+ * to release client resources. Warning: jack_client_close() cannot be
+ * safely used inside the shutdown callback and has to be called outside of
+ * the callback context.
+
+ * @param code a status word, formed by OR-ing together the relevant @ref JackStatus bits.
+ * @param reason a string describing the shutdown reason (backend failure, server crash... etc...). 
+ * Note that this string will not be available anymore after the callback returns, so possibly copy it.
+ * @param arg pointer to a client supplied structure
+ *)
+//typedef void (*JackInfoShutdownCallback)(jack_status_t code, const char* reason, void *arg);
+  TJackInfoShutdownCallback = procedure(code: jack_status_t; reason: PChar; arg: Pointer); cdecl;
+
+(**
+ * Used for the type argument of jack_port_register() for default
+ * audio ports and midi ports.
+ *)
+const
+  JACK_DEFAULT_AUDIO_TYPE = '32 bit float mono audio';
+  JACK_DEFAULT_MIDI_TYPE = '8 bit raw midi';
+
+(**
+ * For convenience, use this typedef if you want to be able to change
+ * between float and double. You may want to typedef sample_t to
+ * jack_default_audio_sample_t in your application.
+ *)
+//typedef float jack_default_audio_sample_t;
+type
+  PPjack_default_audio_sample_t = ^Pjack_default_audio_sample_t;
+  Pjack_default_audio_sample_t = ^jack_default_audio_sample_t;
+  jack_default_audio_sample_t = cfloat;
+
+(**
+ *  A port has a set of flags that are formed by AND-ing together the
+ *  desired values from the list below. The flags "JackPortIsInput" and
+ *  "JackPortIsOutput" are mutually exclusive and it is an error to use
+ *  them both.
+ *)
+  JackPortFlags = (
+
+    (**
+     * if JackPortIsInput is set, then the port can receive
+     * data.
+     *)
+    JackPortIsInput = $1,
+
+    (**
+     * if JackPortIsOutput is set, then data can be read from
+     * the port.
+     *)
+    JackPortIsOutput = $2,
+
+    (**
+     * if JackPortIsPhysical is set, then the port corresponds
+     * to some kind of physical I/O connector.
+     *)
+    JackPortIsPhysical = $4,
+
+    (**
+     * if JackPortCanMonitor is set, then a call to
+     * jack_port_request_monitor() makes sense.
+     *
+     * Precisely what this means is dependent on the client. A typical
+     * result of it being called with TRUE as the second argument is
+     * that data that would be available from an output port (with
+     * JackPortIsPhysical set) is sent to a physical output connector
+     * as well, so that it can be heard/seen/whatever.
+     *
+     * Clients that do not control physical interfaces
+     * should never create ports with this bit set.
+     *)
+    JackPortCanMonitor = $8,
+
+    (**
+     * JackPortIsTerminal means:
+     *
+     *  for an input port: the data received by the port
+     *                    will not be passed on or made
+     *                     available at any other port
+     *
+     * for an output port: the data available at the port
+     *                    does not originate from any other port
+     *
+     * Audio synthesizers, I/O hardware interface clients, HDR
+     * systems are examples of clients that would set this flag for
+     * their ports.
+     *)
+    JackPortIsTerminal = $10
+
+);
+
+(**
+ * Transport states.
+ *)
+  PPjack_transport_state_t = ^Pjack_transport_state_t;
+  Pjack_transport_state_t = ^jack_transport_state_t;
+  jack_transport_state_t = (
+
+    (* the order matters for binary compatibility *)
+    JackTransportStopped = 0,       (**< Transport halted *)
+    JackTransportRolling = 1,       (**< Transport playing *)
+    JackTransportLooping = 2,       (**< For OLD_TRANSPORT, now ignored *)
+    JackTransportStarting = 3,      (**< Waiting for sync ready *)
+    JackTransportNetStarting = 4       (**< Waiting for sync ready on the network*)
+
+);
+
+  PPjack_unique_t = ^Pjack_unique_t;
+  Pjack_unique_t = ^jack_unique_t;
+  jack_unique_t = uint64_t;         (**< Unique ID (opaque) *)
+
+(**
+ * Optional struct jack_position_t fields.
+ *)
+  jack_position_bits_t = (
+
+    JackPositionBBT      = $10,  (**< Bar, Beat, Tick *)
+    JackPositionTimecode = $20,  (**< External timecode *)
+    JackBBTFrameOffset   = $40,  (**< Frame offset of BBT information *)
+    JackAudioVideoRatio  = $80,  (**< audio frames per video frame *)
+    JackVideoFrameOffset = $100, (**< frame offset of first video frame *)
+    JackTickDouble       = $200  (**< double-resolution tick *)
+
+);
+
+(** all valid position bits *)
+const
+  JACK_POSITION_MASK = jack_position_bits_t(Ord(JackPositionBBT) or Ord(JackPositionTimecode));
+{$define EXTENDED_TIME_INFO}
+
+(** transport tick_double member is available for use *)
+{$define JACK_TICK_DOUBLE}
+
+type
+//PRE_PACKED_STRUCTURE
+  _jack_position = packed record
+
+    (* these four cannot be set from clients: the server sets them *)
+    unique_1:           jack_unique_t;  (**< unique ID *)
+    usecs:              jack_time_t;    (**< monotonic, free-rolling *)
+    frame_rate:         jack_nframes_t; (**< current frame rate (per second) *)
+    frame:              jack_nframes_t; (**< frame number, always present *)
+
+    valid:              jack_position_bits_t; (**< which other fields are valid *)
+
+    (* JackPositionBBT fields: *)
+    bar:                int32_t;        (**< current bar *)
+    beat:               int32_t;        (**< current beat-within-bar *)
+    tick:               int32_t;        (**< current tick-within-beat *)
+    bar_start_tick:     cdouble;
+
+    beats_per_bar:      cfloat;         (**< time signature "numerator" *)
+    beat_type:          cfloat;         (**< time signature "denominator" *)
+    ticks_per_beat:     cdouble;
+    beats_per_minute:   cdouble;
+
+    (* JackPositionTimecode fields:     (EXPERIMENTAL: could change) *)
+    frame_time:         cdouble;        (**< current time in seconds *)
+    next_time:          cdouble;        (**< next sequential frame_time
+                         (unless repositioned) *)
+
+    (* JackBBTFrameOffset fields: *)
+    bbt_offset:         jack_nframes_t; (**< frame offset for the BBT fields
+                         (the given bar, beat, and tick
+                         values actually refer to a time
+                         frame_offset frames before the
+                         start of the cycle), should
+                         be assumed to be 0 if
+                         JackBBTFrameOffset is not
+                         set. If JackBBTFrameOffset is
+                         set and this value is zero, the BBT
+                         time refers to the first frame of this
+                         cycle. If the value is positive,
+                         the BBT time refers to a frame that
+                         many frames before the start of the
+                         cycle. *)
+
+    (* JACK video positional data (experimental) *)
+
+    audio_frames_per_video_frame: cfloat; (**< number of audio frames
+                         per video frame. Should be assumed
+                         zero if JackAudioVideoRatio is not
+                         set. If JackAudioVideoRatio is set
+                         and the value is zero, no video
+                         data exists within the JACK graph *)
+
+    video_offset: jack_nframes_t;   (**< audio frame at which the first video
+                         frame in this cycle occurs. Should
+                         be assumed to be 0 if JackVideoFrameOffset
+                         is not set. If JackVideoFrameOffset is
+                         set, but the value is zero, there is
+                         no video frame within this cycle. *)
+
+    (* JACK extra transport fields *)
+
+    tick_double: cdouble; (**< current tick-within-beat in double resolution.
+                         Should be assumed zero if JackTickDouble is not set.
+                         Since older versions of JACK do not expose this variable,
+                         the macro JACK_TICK_DOUBLE is provided,
+                         which can be used as build-time detection. *)
+
+    (* For binary compatibility, new fields should be allocated from
+     * this padding area with new valid bits controlling access, so
+     * the existing structure size and offsets are preserved. *)
+    padding: array [0..4] of int32_t;
+
+    (* When (unique_1 == unique_2) the contents are consistent. *)
+    unique_2: jack_unique_t;       (**< unique ID *)
+
+  end;// POST_PACKED_STRUCTURE;
+
+  PPjack_position_t = ^Pjack_position_t;
+  Pjack_position_t = ^jack_position_t;
+  jack_position_t = _jack_position;
+
+(**
+    * Prototype for the @a sync_callback defined by slow-sync clients.
+    * When the client is active, this callback is invoked just before
+    * process() in the same thread.  This occurs once after registration,
+    * then subsequently whenever some client requests a new position, or
+    * the transport enters the ::JackTransportStarting state.  This
+    * realtime function must not wait.
+    *
+    * The transport @a state will be:
+    *
+    *   - ::JackTransportStopped when a new position is requested;
+    *   - ::JackTransportStarting when the transport is waiting to start;
+    *   - ::JackTransportRolling when the timeout has expired, and the
+    *   position is now a moving target.
+    *
+    * @param state current transport state.
+    * @param pos new transport position.
+    * @param arg the argument supplied by jack_set_sync_callback().
+    *
+    * @return TRUE (non-zero) when ready to roll.
+    *)
+  TJackSyncCallback = function(state: jack_transport_state_t;
+                               pos: Pjack_position_t;
+                               arg: Pointer): cint; cdecl;
+
+
+(**
+  * Prototype for the @a timebase_callback used to provide extended
+  * position information.  Its output affects all of the following
+  * process cycle.  This realtime function must not wait.
+  *
+  * This function is called immediately after process() in the same
+  * thread whenever the transport is rolling, or when any client has
+  * requested a new position in the previous cycle.  The first cycle
+  * after jack_set_timebase_callback() is also treated as a new
+  * position, or the first cycle after jack_activate() if the client
+  * had been inactive.
+  *
+  * The timebase master may not use its @a pos argument to set @a
+  * pos->frame.  To change position, use jack_transport_reposition() or
+  * jack_transport_locate().  These functions are realtime-safe, the @a
+  * timebase_callback can call them directly.
+  *
+  * @param state current transport state.
+  * @param nframes number of frames in current period.
+  * @param pos address of the position structure for the next cycle; @a
+  * pos->frame will be its frame number.  If @a new_pos is FALSE, this
+  * structure contains extended position information from the current
+  * cycle.  If TRUE, it contains whatever was set by the requester.
+  * The @a timebase_callback's task is to update the extended
+  * information here.
+  * @param new_pos TRUE (non-zero) for a newly requested @a pos, or for
+  * the first cycle after the @a timebase_callback is defined.
+  * @param arg the argument supplied by jack_set_timebase_callback().
+  *)
+  TJackTimebaseCallback = procedure(state: jack_transport_state_t;
+                                    nframes: jack_nframes_t;
+                                    pos: Pjack_position_t;
+                                    new_pos: cint;
+                                    arg: Pointer); cdecl;
+
+(*********************************************************************
+    * The following interfaces are DEPRECATED.  They are only provided
+    * for compatibility with the earlier JACK transport implementation.
+    *********************************************************************)
+
+(**
+ * Optional struct jack_transport_info_t fields.
+ *
+ * @see jack_position_bits_t.
+ *)
+  jack_transport_bits_t = (
+
+    JackTransportState = $1,    (**< Transport state *)
+    JackTransportPosition = $2, (**< Frame number *)
+    JackTransportLoop = $4,     (**< Loop boundaries (ignored) *)
+    JackTransportSMPTE = $8,    (**< SMPTE (ignored) *)
+    JackTransportBBT = $10      (**< Bar, Beat, Tick *)
+
+  );
+
+(**
+ * Deprecated struct for transport position information.
+ *
+ * @deprecated This is for compatibility with the earlier transport
+ * interface.  Use the jack_position_t struct, instead.
+ *)
+  PPjack_transport_info_t = ^Pjack_transport_info_t;
+  Pjack_transport_info_t = ^jack_transport_info_t;
+  jack_transport_info_t = record
+
+    (* these two cannot be set from clients: the server sets them *)
+
+    frame_rate: jack_nframes_t;          (**< current frame rate (per second) *)
+    usecs: jack_time_t;          (**< monotonic, free-rolling *)
+
+    valid: jack_transport_bits_t;        (**< which fields are legal to read *)
+    transport_state: jack_transport_state_t;
+    frame: jack_nframes_t;
+    loop_start: jack_nframes_t;
+    loop_end: jack_nframes_t;
+
+    smpte_offset: clong;  (**< SMPTE offset (from frame 0) *)
+    smpte_frame_rate: cfloat;     (**< 29.97, 30, 24 etc. *)
+
+    bar: cint;
+    beat: cint;
+    tick: cint;
+    bar_start_tick: cdouble;
+
+    beats_per_bar: cfloat;
+    beat_type: cfloat;
+    ticks_per_beat: cdouble;
+    beats_per_minute: cdouble;
+
+  end;
+
+
+{$endif __jack_types_h__}
+

packages/libjack/src/weakmacros.inc

@@ -0,0 +1,104 @@
+(*
+    Copyright (C) 2010 Paul Davis
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 2.1 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    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
+    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+*)
+
+{$ifndef __weakmacros_h__}
+{$define __weakmacros_h__}
+
+
+(*************************************************************
+ * NOTE: JACK_WEAK_EXPORT ***MUST*** be used on every function
+ * added to the JACK API after the 0.116.2 release.
+ *
+ * Functions that predate this release are marked with
+ * JACK_WEAK_OPTIONAL_EXPORT which can be defined at compile
+ * time in a variety of ways. The default definition is empty,
+ * so that these symbols get normal linkage. If you wish to
+ * use all JACK symbols with weak linkage, include
+ * <jack/weakjack.h> before jack.h.
+ *************************************************************)
+
+{$macro on}
+{$define JACK_OPTIONAL_WEAK_EXPORT := external libjack}
+{$define JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT := external libjack; deprecated}
+{$define JACK_WEAK_EXPORT := weakexternal libjack}
+
+(*#ifdef __APPLE__
+#define WEAK_ATTRIBUTE weak_import
+#else
+#define WEAK_ATTRIBUTE __weak__
+#endif
+
+#ifndef JACK_WEAK_EXPORT
+#ifdef __GNUC__
+/* JACK_WEAK_EXPORT needs to be a macro which
+   expands into a compiler directive. If non-null, the directive
+   must tell the compiler to arrange for weak linkage of
+   the symbol it used with. For this to work full may
+   require linker arguments in the client as well.
+*/
+
+#ifdef _WIN32
+    /*
+        Not working with __declspec(dllexport) so normal linking
+        Linking with JackWeakAPI.cpp will be the preferred way.
+    */
+    #define JACK_WEAK_EXPORT
+#else
+    #define JACK_WEAK_EXPORT __attribute__((WEAK_ATTRIBUTE))
+#endif
+
+#else
+/* Add other things here for non-gcc platforms */
+
+#ifdef _WIN32
+#define JACK_WEAK_EXPORT
+#endif
+
+#endif
+#endif
+
+#ifndef JACK_WEAK_EXPORT
+#define JACK_WEAK_EXPORT
+#endif
+
+#ifndef JACK_OPTIONAL_WEAK_EXPORT
+#define JACK_OPTIONAL_WEAK_EXPORT
+#endif
+
+#ifndef JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT
+#ifdef __GNUC__
+#define JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT __attribute__((__deprecated__))
+#else
+/* Add other things here for non-gcc platforms */
+
+#ifdef _WIN32
+#define JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT
+#endif
+
+#endif /* __GNUC__ */
+
+#ifndef JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT
+#define JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT
+#endif
+
+#endif
+*)
+
+{$endif __weakmacros_h__}
+