jackaudio
/
jack1
mirror of https://github.com/jackaudio/jack1
1
0
Fork 0
Code Releases 19 Activity
jack1 codebase
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
593 Commits
4 Branches
7.3MB
Tree: 4e1c06db7a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4e1c06db7a'
${ noResults }
jack1/jack/internal.h

429 lines
12KB
Raw Blame History 

  1. /* -*- mode: c; c-file-style: "bsd"; -*- */

  2. /*

  3.     Internal shared data and functions.

  4. 

  5.     If you edit this file, you should carefully consider changing the

  6.     JACK_PROTOCOL_VERSION in configure.in.

  7. 

  8.     Copyright (C) 2001-2003 Paul Davis

  9.     

  10.     This program is free software; you can redistribute it and/or modify

  11.     it under the terms of the GNU General Public License as published by

  12.     the Free Software Foundation; either version 2 of the License, or

  13.     (at your option) any later version.

  14. 

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

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

  17.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  18.     GNU General Public License for more details.

  19. 

  20.     You should have received a copy of the GNU General Public License

  21.     along with this program; if not, write to the Free Software

  22.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  23. 

  24.     $Id$

  25. */

  26. 

  27. #ifndef __jack_internal_h__

  28. #define __jack_internal_h__

  29. 

  30. #include <stdlib.h>

  31. #include <unistd.h>

  32. #include <limits.h>

  33. #include <dlfcn.h>

  34. #include <pthread.h>

  35. #include <sys/types.h>

  36. #include <sys/time.h>

  37. 

  38. /* Needed by <sysdeps/time.h> */

  39. extern void jack_error (const char *fmt, ...);

  40. 

  41. #include <jack/jack.h>

  42. #include <jack/types.h>

  43. #include <jack/port.h>

  44. #include <jack/transport.h>

  45. #include <sysdeps/time.h>

  46. #include <sysdeps/atomicity.h>

  47. 

  48. #ifdef JACK_USE_MACH_THREADS

  49. #include <sysdeps/mach_port.h>

  50. #endif

  51. 

  52. #ifdef DEBUG_ENABLED

  53. #define DEBUG(format,args...) \

  54. 	fprintf (stderr, "jack:%5d:%" PRIu64 " %s:%s:%d: " format "\n", getpid(), jack_get_microseconds(), __FILE__, __FUNCTION__, __LINE__ , ## args)

  55. #else

  56. #if JACK_CPP_VARARGS_BROKEN

  57.     #define DEBUG(format...)

  58. #else

  59.     #define DEBUG(format,args...)

  60. #endif

  61. #endif

  62. 

  63. /* Enable preemption checking for Linux Realtime Preemption kernels.

  64.  *

  65.  * This checks if any RT-safe code section does anything to cause CPU

  66.  * preemption.  Examples are sleep() or other system calls that block.

  67.  * If a problem is detected, the kernel writes a syslog entry, and

  68.  * sends SIGUSR2 to the client.

  69.  */

  70. #ifdef DO_PREEMPTION_CHECKING

  71. #define CHECK_PREEMPTION(engine, onoff) \

  72. 	if ((engine)->real_time) gettimeofday (1, (onoff))

  73. #else

  74. #define CHECK_PREEMPTION(engine, onoff)

  75. #endif

  76. 

  77. #ifndef	FALSE

  78. #define	FALSE	(0)

  79. #endif

  80. 

  81. #ifndef	TRUE

  82. #define	TRUE	(1)

  83. #endif

  84. 

  85. typedef struct _jack_engine  jack_engine_t;

  86. typedef struct _jack_request jack_request_t;

  87. 

  88. typedef void * dlhandle;

  89. 

  90. typedef enum {

  91.     TransportCommandNone = 0,

  92.     TransportCommandStart = 1,

  93.     TransportCommandStop = 2,

  94. } transport_command_t;

  95. 

  96. typedef struct {

  97.     volatile jack_time_t guard1;

  98.     volatile jack_nframes_t frames;

  99.     volatile jack_time_t stamp;

  100.     volatile jack_time_t guard2;

  101. } jack_frame_timer_t;

  102. 

  103. /* JACK engine shared memory data structure. */

  104. typedef struct {

  105. 

  106.     jack_transport_state_t transport_state;

  107.     volatile transport_command_t transport_cmd;

  108.     transport_command_t	  previous_cmd;	/* previous transport_cmd */

  109.     jack_position_t	  current_time;	/* position for current cycle */

  110.     jack_position_t	  pending_time;	/* position for next cycle */

  111.     jack_position_t	  request_time;	/* latest requested position */

  112.     jack_unique_t	  prev_request; /* previous request unique ID */

  113.     volatile _Atomic_word seq_number;	/* unique ID sequence number */

  114.     int8_t		  new_pos;	/* new position this cycle */

  115.     int8_t		  pending_pos;	/* new position request pending */

  116.     jack_nframes_t	  pending_frame; /* pending frame number */

  117.     int32_t		  sync_clients;	/* number of active_slowsync clients */

  118.     int32_t		  sync_remain;	/* number of them with sync_poll */

  119.     jack_time_t           sync_timeout;

  120.     jack_time_t           sync_time_left;

  121.     jack_frame_timer_t    frame_timer;

  122.     int32_t		  internal;

  123.     jack_nframes_t        frames_at_cycle_start;

  124.     pid_t                 engine_pid;

  125.     jack_nframes_t	  buffer_size;

  126.     int8_t		  real_time;

  127.     int8_t		  do_mlock;

  128.     int8_t		  do_munlock;

  129.     int32_t		  client_priority;

  130.     int32_t		  has_capabilities;

  131.     float                 cpu_load;

  132.     float		  xrun_delayed_usecs;

  133.     uint32_t		  port_max;

  134.     int32_t		  engine_ok;

  135.     jack_port_type_id_t	  n_port_types;

  136.     jack_port_type_info_t port_types[JACK_MAX_PORT_TYPES];

  137.     jack_port_shared_t    ports[0];

  138. 

  139. } jack_control_t;

  140. 

  141. typedef enum  {

  142.   BufferSizeChange,

  143.   SampleRateChange,

  144.   AttachPortSegment,

  145.   PortConnected,

  146.   PortDisconnected,

  147.   GraphReordered,

  148.   PortRegistered,

  149.   PortUnregistered,

  150.   XRun,

  151.   StartFreewheel,

  152.   StopFreewheel

  153. } EventType;

  154. 

  155. typedef struct {

  156.     EventType type;

  157.     union {

  158. 	uint32_t n;

  159. 	jack_port_id_t port_id;

  160. 	jack_port_id_t self_id;

  161.     } x;

  162.     union {

  163. 	uint32_t n;

  164. 	jack_port_type_id_t ptid;

  165. 	jack_port_id_t other_id;

  166.     } y;

  167. } jack_event_t;

  168. 

  169. typedef enum {

  170. 	ClientInternal, /* connect request just names .so */

  171. 	ClientDriver,   /* code is loaded along with driver */

  172. 	ClientExternal  /* client is in another process */

  173. } ClientType;

  174. 

  175. typedef enum {

  176. 	NotTriggered,

  177. 	Triggered,

  178. 	Running,

  179. 	Finished

  180. } jack_client_state_t;

  181. 

  182. /* JACK client shared memory data structure. */

  183. typedef volatile struct {

  184. 

  185.     volatile jack_client_id_t id;         /* w: engine r: engine and client */

  186.     volatile jack_nframes_t  nframes;     /* w: engine r: client */

  187.     volatile jack_client_state_t state;   /* w: engine and client r: engine */

  188.     volatile char	name[JACK_CLIENT_NAME_SIZE];

  189.     volatile ClientType type;             /* w: engine r: engine and client */

  190.     volatile int8_t     active;           /* w: engine r: engine and client */

  191.     volatile int8_t     dead;             /* r/w: engine */

  192.     volatile int8_t	timed_out;        /* r/w: engine */

  193.     volatile int8_t     is_timebase;	  /* w: engine, r: engine and client */

  194.     volatile int8_t     timebase_new;	  /* w: engine and client, r: engine */

  195.     volatile int8_t     is_slowsync;	  /* w: engine, r: engine and client */

  196.     volatile int8_t     active_slowsync;  /* w: engine, r: engine and client */

  197.     volatile int8_t     sync_poll;        /* w: engine and client, r: engine */

  198.     volatile int8_t     sync_new;         /* w: engine and client, r: engine */

  199.     volatile pid_t      pid;              /* w: client r: engine; client pid */

  200.     volatile pid_t      pgrp;             /* w: client r: engine; client pgrp */

  201.     volatile uint64_t	signalled_at;

  202.     volatile uint64_t	awake_at;

  203.     volatile uint64_t	finished_at;

  204. 

  205.     /* JOQ: all these pointers are trouble for 32/64 compatibility,

  206.      * they should move to non-shared memory. 

  207.      */

  208. 

  209.     /* callbacks 

  210.      */

  211.     JackProcessCallback process;

  212.     void *process_arg;

  213.     JackThreadInitCallback thread_init;

  214.     void *thread_init_arg;

  215.     JackBufferSizeCallback bufsize;

  216.     void *bufsize_arg;

  217.     JackSampleRateCallback srate;

  218.     void *srate_arg;

  219.     JackPortRegistrationCallback port_register;

  220.     void *port_register_arg;

  221.     JackGraphOrderCallback graph_order;

  222.     void *graph_order_arg;

  223.     JackXRunCallback xrun;

  224.     void *xrun_arg;

  225.     JackSyncCallback sync_cb;

  226.     void *sync_arg;

  227.     JackTimebaseCallback timebase_cb;

  228.     void *timebase_arg;

  229.     JackFreewheelCallback freewheel_cb;

  230.     void *freewheel_arg;

  231. 	

  232.     /* external clients: set by libjack

  233.      * internal clients: set by engine */

  234.     int (*deliver_request)(void*, jack_request_t*); /* JOQ: 64/32 bug! */

  235.     void *deliver_arg;

  236. 

  237.     /* for engine use only */

  238.     void *private_client;

  239. 

  240. } jack_client_control_t;

  241. 

  242. typedef struct {

  243.     

  244.     int32_t    load;

  245.     ClientType type;

  246.     jack_options_t options;

  247. 

  248.     char name[JACK_CLIENT_NAME_SIZE];

  249.     char object_path[PATH_MAX+1];

  250.     char object_data[1024];

  251. 

  252. } jack_client_connect_request_t;

  253. 

  254. typedef struct {

  255. 

  256.     uint32_t	protocol_v;

  257.     jack_status_t status;

  258. 

  259.     jack_shm_info_t client_shm;

  260.     jack_shm_info_t engine_shm;

  261. 

  262.     char	fifo_prefix[PATH_MAX+1];

  263. 

  264.     int32_t	realtime;

  265.     int32_t	realtime_priority;

  266. 

  267.     char name[JACK_CLIENT_NAME_SIZE];	/* unique name, if assigned */

  268. 

  269.     /* these two are valid only for internal clients */

  270.     jack_client_control_t *client_control;

  271.     jack_control_t        *engine_control;

  272. 

  273. #ifdef JACK_USE_MACH_THREADS

  274.     /* specific resources for server/client real-time thread communication */

  275.     int32_t	portnum;

  276. #endif

  277. 

  278. } jack_client_connect_result_t;

  279. 

  280. typedef struct {

  281.     jack_client_id_t client_id;

  282. } jack_client_connect_ack_request_t;

  283. 

  284. typedef struct {

  285.     int8_t status;

  286. } jack_client_connect_ack_result_t;

  287. 

  288. typedef enum {

  289. 	RegisterPort = 1,

  290. 	UnRegisterPort = 2,

  291. 	ConnectPorts = 3,

  292. 	DisconnectPorts = 4, 

  293. 	SetTimeBaseClient = 5,

  294. 	ActivateClient = 6,

  295. 	DeactivateClient = 7,

  296. 	DisconnectPort = 8,

  297. 	SetClientCapabilities = 9,

  298. 	GetPortConnections = 10,

  299. 	GetPortNConnections = 11,

  300. 	ResetTimeBaseClient = 12,

  301. 	SetSyncClient = 13,

  302. 	ResetSyncClient = 14,

  303. 	SetSyncTimeout = 15,

  304. 	SetBufferSize = 16,

  305. 	FreeWheel = 17,

  306. 	StopFreeWheel = 18,

  307. 	IntClientHandle = 19,

  308. 	IntClientLoad = 20,

  309. 	IntClientName = 21,

  310. 	IntClientUnload = 22

  311. } RequestType;

  312. 

  313. struct _jack_request {

  314.     

  315.     RequestType type;

  316.     union {

  317. 	struct {

  318. 	    char name[JACK_PORT_NAME_SIZE];

  319. 	    char type[JACK_PORT_TYPE_SIZE];

  320. 	    uint32_t         flags;

  321. 	    jack_shmsize_t   buffer_size;

  322. 	    jack_port_id_t   port_id;

  323. 	    jack_client_id_t client_id;

  324. 	} port_info;

  325. 	struct {

  326. 	    char source_port[JACK_PORT_NAME_SIZE];

  327. 	    char destination_port[JACK_PORT_NAME_SIZE];

  328. 	} connect;

  329. 	struct {

  330. 	    int32_t nports;

  331. 	    const char **ports;		/* JOQ: 32/64 problem? */

  332. 	} port_connections;

  333. 	struct {

  334. 	    jack_client_id_t client_id;

  335. 	    int32_t conditional;

  336. 	} timebase;

  337. 	struct {

  338. 	    jack_options_t options;

  339. 	    jack_client_id_t id;

  340. 	    char name[JACK_CLIENT_NAME_SIZE];

  341. 	    char path[PATH_MAX+1];

  342. 	    char init[JACK_LOAD_INIT_LIMIT];

  343. 	} intclient;

  344. 	jack_client_id_t client_id;

  345. 	jack_nframes_t nframes;

  346. 	jack_time_t timeout;

  347.     } x;

  348.     int32_t status;

  349. };

  350. 

  351. /* Per-client structure allocated in the server's address space.

  352.  * It's here because its not part of the engine structure.

  353.  */

  354. 

  355. typedef struct _jack_client_internal {

  356. 

  357.     jack_client_control_t *control;

  358. 

  359.     int        request_fd;

  360.     int        event_fd;

  361.     int        subgraph_start_fd;

  362.     int        subgraph_wait_fd;

  363.     JSList    *ports;    /* protected by engine->client_lock */

  364.     JSList    *truefeeds;    /* protected by engine->client_lock */

  365.     JSList    *sortfeeds;    /* protected by engine->client_lock */

  366.     int	       fedcount;

  367.     int	       tfedcount;

  368.     jack_shm_info_t control_shm;

  369.     unsigned long execution_order;

  370.     struct  _jack_client_internal *next_client; /* not a linked list! */

  371.     dlhandle handle;

  372.     int     (*initialize)(jack_client_t*, const char*); /* int. clients only */

  373.     void    (*finish)(void *);		/* internal clients only */

  374.     int      error;

  375.     

  376. #ifdef JACK_USE_MACH_THREADS

  377.     /* specific resources for server/client real-time thread communication */

  378.     mach_port_t serverport;

  379.     trivial_message message;

  380.     int running;

  381.     int portnum;

  382. #endif /* JACK_USE_MACH_THREADS */

  383.     

  384. } jack_client_internal_t;

  385. 

  386. extern int  jack_client_handle_port_connection (jack_client_t *client,

  387. 						jack_event_t *event);

  388. extern jack_client_t *jack_driver_client_new (jack_engine_t *,

  389. 					      const char *client_name);

  390. extern jack_client_t *jack_client_alloc_internal (jack_client_control_t*,

  391. 						  jack_engine_t*);

  392. 

  393. /* internal clients call this. it's defined in jack/engine.c */

  394. void handle_internal_client_request (jack_control_t*, jack_request_t*);

  395. 

  396. extern char *jack_tmpdir;

  397. 

  398. extern char *jack_user_dir (void);

  399. 

  400. extern char *jack_server_dir (const char *server_name);

  401. 

  402. extern void *jack_zero_filled_buffer;

  403. 

  404. extern jack_port_functions_t jack_builtin_audio_functions;

  405. 

  406. extern jack_port_type_info_t jack_builtin_port_types[];

  407. 

  408. extern void jack_client_invalidate_port_buffers (jack_client_t *client);

  409. 

  410. extern void jack_transport_copy_position (jack_position_t *from,

  411. 					  jack_position_t *to);

  412. extern void jack_call_sync_client (jack_client_t *client);

  413. 

  414. extern void jack_call_timebase_master (jack_client_t *client);

  415. 

  416. extern char *jack_default_server_name (void);

  417. 

  418. void silent_jack_error_callback (const char *desc);

  419. 

  420. /* needed for port management */

  421. jack_port_t *jack_port_by_id_int (const jack_client_t *client,

  422. 				  jack_port_id_t id, int* free);

  423. 

  424. jack_port_t *jack_port_by_name_int (jack_client_t *client,

  425. 				    const char *port_name);

  426. 

  427. #endif /* __jack_internal_h__ */