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.
1421 Commits
4 Branches
11MB
Tree: fe66547ea2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'fe66547ea2'
${ noResults }
jack1/jack/engine.h

267 lines
8.9KB
Raw Blame History 

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

  2. /*

  3.     Copyright (C) 2001-2003 Paul Davis

  4.     

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

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

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

  8.     (at your option) any later version.

  9. 

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

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

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

  13.     GNU General Public License for more details.

  14. 

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

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

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

  18. 

  19. */

  20. 

  21. #ifndef __jack_engine_h__

  22. #define __jack_engine_h__

  23. 

  24. #include <jack/jack.h>

  25. #include <jack/internal.h>

  26. #include <jack/driver_interface.h>

  27. 

  28. struct _jack_driver;

  29. struct _jack_client_internal;

  30. struct _jack_port_internal;

  31. 

  32. /* Structures is allocated by the engine in local memory to keep track

  33.  * of port buffers and connections. 

  34.  */

  35. typedef struct {

  36.     jack_shm_info_t* shm_info;

  37.     jack_shmsize_t   offset;

  38. } jack_port_buffer_info_t;

  39. 

  40. /* The engine keeps an array of these in its local memory. */

  41. typedef struct _jack_port_internal {

  42.     struct _jack_port_shared *shared;

  43.     JSList                   *connections;

  44.     jack_port_buffer_info_t  *buffer_info;

  45. } jack_port_internal_t;

  46. 

  47. /* The engine's internal port type structure. */

  48. typedef struct _jack_port_buffer_list {

  49.     pthread_mutex_t          lock;	/* only lock within server */

  50.     JSList	            *freelist;	/* list of free buffers */

  51.     jack_port_buffer_info_t *info;	/* jack_buffer_info_t array */

  52. } jack_port_buffer_list_t;

  53. 

  54. typedef struct _jack_reserved_name {

  55.     jack_client_id_t uuid;

  56.     char name[JACK_CLIENT_NAME_SIZE];

  57. } jack_reserved_name_t;

  58. 

  59. #define JACKD_WATCHDOG_TIMEOUT 10000

  60. #define JACKD_CLIENT_EVENT_TIMEOUT 2000

  61. 

  62. /* The main engine structure in local memory. */

  63. struct _jack_engine {

  64.     jack_control_t        *control;

  65. 

  66.     JSList                *drivers;

  67.     struct _jack_driver   *driver;

  68.     jack_driver_desc_t    *driver_desc;

  69.     JSList                *driver_params;

  70. 

  71.     JSList                *slave_drivers;

  72. 

  73.     /* these are "callbacks" made by the driver backend */

  74.     int  (*set_buffer_size) (struct _jack_engine *, jack_nframes_t frames);

  75.     int  (*set_sample_rate) (struct _jack_engine *, jack_nframes_t frames);

  76.     int  (*run_cycle)	    (struct _jack_engine *, jack_nframes_t nframes,

  77. 			     float delayed_usecs);

  78.     void (*delay)	    (struct _jack_engine *, float delayed_usecs);

  79.     void (*transport_cycle_start) (struct _jack_engine *, jack_time_t time);

  80.     void (*driver_exit)     (struct _jack_engine *);

  81. 

  82.     /* "private" sections starts here */

  83. 

  84.     /* engine serialization -- use precedence for deadlock avoidance */

  85.     pthread_mutex_t request_lock; /* precedes client_lock */

  86.     pthread_rwlock_t client_lock;

  87.     pthread_mutex_t port_lock;

  88.     pthread_mutex_t problem_lock; /* must hold write lock on client_lock */

  89.     int		    process_errors;

  90.     int		    period_msecs;

  91. 

  92.     /* Time to wait for clients in msecs.  Used when jackd is run

  93.      * without realtime priority enabled. */

  94.     int		    client_timeout_msecs;

  95. 

  96.     /* info on the shm segment containing this->control */

  97. 

  98.     jack_shm_info_t control_shm;

  99. 

  100.     /* address-space local port buffer and segment info, 

  101.        indexed by the port type_id 

  102.     */

  103.     jack_port_buffer_list_t port_buffers[JACK_MAX_PORT_TYPES];

  104.     jack_shm_info_t         port_segment[JACK_MAX_PORT_TYPES];

  105. 

  106.     unsigned int    port_max;

  107.     pthread_t	    server_thread;

  108.     pthread_t	    watchdog_thread;

  109. 

  110.     int		    fds[2];

  111.     int		    cleanup_fifo[2];

  112.     jack_client_id_t next_client_id;

  113.     size_t	    pfd_size;

  114.     size_t	    pfd_max;

  115.     struct pollfd  *pfd;

  116.     char	    fifo_prefix[PATH_MAX+1];

  117.     int		   *fifo;

  118.     unsigned long   fifo_size;

  119. 

  120.     /* session handling */

  121.     int		    session_reply_fd;

  122.     int		    session_pending_replies;

  123. 

  124.     unsigned long   external_client_cnt;

  125.     int		    rtpriority;

  126.     volatile char   freewheeling;

  127.     volatile char   stop_freewheeling;

  128.     jack_client_id_t fwclient;

  129.     pthread_t       freewheel_thread;

  130.     char	    verbose;

  131.     char	    do_munlock;

  132.     const char	   *server_name;

  133.     char	    temporary;

  134.     int		    reordered;

  135.     int		    watchdog_check;

  136.     int		    feedbackcount;

  137.     int             removing_clients;

  138.     pid_t           wait_pid;

  139.     int             nozombies;

  140.     volatile int    problems;

  141.     volatile int    new_clients_allowed;    

  142. 

  143.     /* these lists are protected by `client_lock' */

  144.     JSList	   *clients;

  145.     JSList	   *clients_waiting;

  146.     JSList	   *reserved_client_names;

  147. 

  148.     jack_port_internal_t    *internal_ports;

  149.     jack_client_internal_t  *timebase_client;

  150.     jack_port_buffer_info_t *silent_buffer;

  151.     jack_client_internal_t  *current_client;

  152. 

  153. #define JACK_ENGINE_ROLLING_COUNT 32

  154. #define JACK_ENGINE_ROLLING_INTERVAL 1024

  155. 

  156.     jack_time_t rolling_client_usecs[JACK_ENGINE_ROLLING_COUNT];

  157.     int		    rolling_client_usecs_cnt;

  158.     int		    rolling_client_usecs_index;

  159.     int		    rolling_interval;

  160.     float	    max_usecs;

  161.     float	    spare_usecs;

  162. 

  163.     int first_wakeup;

  164.     

  165. #ifdef JACK_USE_MACH_THREADS

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

  167.     mach_port_t servertask, bp;

  168.     int portnum;

  169. #endif

  170. 

  171.     /* used for port names munging */

  172.     int audio_out_cnt;

  173.     int audio_in_cnt;

  174.     int midi_out_cnt;

  175.     int midi_in_cnt;

  176. };

  177. 

  178. /* public functions */

  179. 

  180. jack_engine_t  *jack_engine_new (int real_time, int real_time_priority,

  181. 				 int do_mlock, int do_unlock,

  182. 				 const char *server_name, int temporary,

  183. 				 int verbose, int client_timeout,

  184. 				 unsigned int port_max,

  185.                                  pid_t waitpid, jack_nframes_t frame_time_offset, int nozombies, 

  186. 				 JSList *drivers);

  187. void		jack_engine_delete (jack_engine_t *);

  188. int		jack_run (jack_engine_t *engine);

  189. int		jack_wait (jack_engine_t *engine);

  190. int		jack_engine_load_driver (jack_engine_t *engine,

  191. 					 jack_driver_desc_t * driver_desc,

  192. 					 JSList * driver_params);

  193. int		jack_engine_load_slave_driver (jack_engine_t *engine,

  194. 					       jack_driver_desc_t * driver_desc,

  195. 					       JSList * driver_params);

  196. void		jack_dump_configuration(jack_engine_t *engine, int take_lock);

  197. 

  198. /* private engine functions */

  199. void		jack_engine_reset_rolling_usecs (jack_engine_t *engine);

  200. int		internal_client_request (void* ptr, jack_request_t *request);

  201. int		jack_get_fifo_fd (jack_engine_t *engine,

  202. 				  unsigned int which_fifo);

  203. 

  204. extern jack_timer_type_t clock_source;

  205. 

  206. extern jack_client_internal_t *

  207. jack_client_internal_by_id (jack_engine_t *engine, jack_client_id_t id);

  208. 

  209. #define jack_rdlock_graph(e) { DEBUG ("acquiring graph read lock"); if (pthread_rwlock_rdlock (&e->client_lock)) abort(); }

  210. #define jack_lock_graph(e) { DEBUG ("acquiring graph write lock"); if (pthread_rwlock_wrlock (&e->client_lock)) abort(); }

  211. #define jack_try_rdlock_graph(e) pthread_rwlock_tryrdlock (&e->client_lock)

  212. #define jack_unlock_graph(e) { DEBUG ("release graph lock"); if (pthread_rwlock_unlock (&e->client_lock)) abort(); }

  213. 

  214. #define jack_trylock_problems(e) pthread_mutex_trylock (&e->problem_lock)

  215. #define jack_lock_problems(e) { DEBUG ("acquiring problem lock"); if (pthread_mutex_lock (&e->problem_lock)) abort(); }

  216. #define jack_unlock_problems(e) { DEBUG ("release problem lock"); if (pthread_mutex_unlock (&e->problem_lock)) abort(); }

  217. 

  218. #if 0

  219. static inline void jack_rdlock_graph (jack_engine_t* engine) {

  220. 	DEBUG ("acquiring graph read lock");

  221. 	pthread_rwlock_rdlock (&engine->client_lock);

  222. }

  223. 

  224. static inline void jack_lock_graph (jack_engine_t* engine) {

  225. 	DEBUG ("acquiring graph lock");

  226. 	pthread_rwlock_wrlock (&engine->client_lock);

  227. }

  228. 

  229. static inline int jack_try_rdlock_graph (jack_engine_t *engine)

  230. {

  231. 	DEBUG ("TRYING to acquiring graph read lock");

  232. 	return pthread_rwlock_tryrdlock (&engine->client_lock);

  233. }

  234. 

  235. static inline void jack_unlock_graph (jack_engine_t* engine) 

  236. {

  237. 	DEBUG ("releasing graph lock");

  238. 	pthread_rwlock_unlock (&engine->client_lock);

  239. }

  240. #endif

  241. 

  242. static inline unsigned int jack_power_of_two (unsigned int n)

  243. {

  244. 	return !(n & (n - 1));

  245. }

  246. 

  247. /* Internal port handling interfaces for JACK engine. */

  248. void	jack_port_clear_connections (jack_engine_t *engine,

  249. 				     jack_port_internal_t *port);

  250. void	jack_port_registration_notify (jack_engine_t *, jack_port_id_t, int);

  251. void	jack_port_release (jack_engine_t *engine, jack_port_internal_t *);

  252. void	jack_sort_graph (jack_engine_t *engine);

  253. int     jack_stop_freewheeling (jack_engine_t* engine, int engine_exiting);

  254. jack_client_internal_t *

  255. jack_client_by_name (jack_engine_t *engine, const char *name);

  256. 

  257. int  jack_deliver_event (jack_engine_t *, jack_client_internal_t *, jack_event_t *);

  258. void

  259. jack_engine_signal_problems (jack_engine_t* engine);

  260. 

  261. int

  262. jack_drivers_start (jack_engine_t *engine);

  263. int

  264. jack_add_slave_driver (jack_engine_t *engine, struct _jack_driver *driver);

  265. 

  266. #endif /* __jack_engine_h__ */