jackaudio
/
jack2
mirror of https://github.com/jackaudio/jack2
1
0
Fork 0
Code Releases 45 Activity
jack2 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.
3564 Commits
8 Branches
440MB
Tree: dde9f29a8e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'dde9f29a8e'
${ noResults }
jack2/linux/alsa/alsa_driver.h

291 lines
8.8KB
Raw Blame History 

  1. /*

  2.     Copyright (C) 2001 Paul Davis

  3. 

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

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

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

  7.     (at your option) any later version.

  8. 

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

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

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

  12.     GNU General Public License for more details.

  13. 

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

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

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

  17. 

  18.     $Id: alsa_driver.h 945 2006-05-04 15:14:45Z pbd $

  19. */

  20. 

  21. #ifndef __jack_alsa_driver_h__

  22. #define __jack_alsa_driver_h__

  23. 

  24. #include <alsa/asoundlib.h>

  25. #include "bitset.h"

  26. 

  27. #if __BYTE_ORDER == __LITTLE_ENDIAN

  28. #define IS_LE 0

  29. #define IS_BE 1

  30. #elif __BYTE_ORDER == __BIG_ENDIAN

  31. #define IS_LE 1

  32. #define IS_BE 0

  33. #endif

  34. 

  35. #define TRUE 1

  36. #define FALSE 0

  37. 

  38. #include "types.h"

  39. #include "hardware.h"

  40. #include "driver.h"

  41. #include "memops.h"

  42. #include "alsa_midi.h"

  43. 

  44. #ifdef __cplusplus

  45. extern "C"

  46. {

  47. #endif

  48. 

  49. typedef void (*ReadCopyFunction)  (jack_default_audio_sample_t *dst, char *src,

  50.                                    unsigned long src_bytes,

  51.                                    unsigned long src_skip_bytes);

  52. typedef void (*WriteCopyFunction) (char *dst, jack_default_audio_sample_t *src,

  53.                                    unsigned long src_bytes,

  54.                                    unsigned long dst_skip_bytes,

  55.                                    dither_state_t *state);

  56. 

  57. typedef struct _alsa_driver {

  58. 

  59.     JACK_DRIVER_NT_DECL

  60. 

  61.     int                           poll_timeout;

  62.     jack_time_t                   poll_last;

  63.     jack_time_t                   poll_next;

  64.     char                        **playback_addr;

  65.     char                        **capture_addr;

  66.     const snd_pcm_channel_area_t *capture_areas;

  67.     const snd_pcm_channel_area_t *playback_areas;

  68.     struct pollfd                *pfd;

  69.     unsigned int                  playback_nfds;

  70.     unsigned int                  capture_nfds;

  71.     unsigned long                 interleave_unit;

  72.     unsigned long                *capture_interleave_skip;

  73.     unsigned long                *playback_interleave_skip;

  74.     channel_t                     max_nchannels;

  75.     channel_t                     user_nchannels;

  76.     channel_t                     playback_nchannels;

  77.     channel_t                     capture_nchannels;

  78.     unsigned long                 playback_sample_bytes;

  79.     unsigned long                 capture_sample_bytes;

  80. 

  81.     jack_nframes_t                frame_rate;

  82.     jack_nframes_t                frames_per_cycle;

  83.     jack_nframes_t                capture_frame_latency;

  84.     jack_nframes_t                playback_frame_latency;

  85. 

  86.     unsigned long                *silent;

  87.     char                         *alsa_name_playback;

  88.     char                         *alsa_name_capture;

  89.     char                         *alsa_driver;

  90.     bitset_t			  channels_not_done;

  91.     bitset_t			  channels_done;

  92.     snd_pcm_format_t              playback_sample_format;

  93.     snd_pcm_format_t              capture_sample_format;

  94.     float                         max_sample_val;

  95.     unsigned long                 user_nperiods;

  96.     unsigned int                  playback_nperiods;

  97.     unsigned int                  capture_nperiods;

  98.     unsigned long                 last_mask;

  99.     snd_ctl_t                    *ctl_handle;

  100.     snd_pcm_t                    *playback_handle;

  101.     snd_pcm_t                    *capture_handle;

  102.     snd_pcm_hw_params_t          *playback_hw_params;

  103.     snd_pcm_sw_params_t          *playback_sw_params;

  104.     snd_pcm_hw_params_t          *capture_hw_params;

  105.     snd_pcm_sw_params_t          *capture_sw_params;

  106.     jack_hardware_t              *hw;

  107.     ClockSyncStatus              *clock_sync_data;

  108.     jack_client_t                *client;

  109.     JSList                       *capture_ports;

  110.     JSList                       *playback_ports;

  111.     JSList                       *monitor_ports;

  112. 

  113.     unsigned long input_monitor_mask;

  114. 

  115.     char soft_mode;

  116.     char hw_monitoring;

  117.     char hw_metering;

  118.     char all_monitor_in;

  119.     char capture_and_playback_not_synced;

  120.     char playback_interleaved;

  121.     char capture_interleaved;

  122.     char with_monitor_ports;

  123.     char has_clock_sync_reporting;

  124.     char has_hw_monitoring;

  125.     char has_hw_metering;

  126.     char quirk_bswap;

  127.     char hw_timestamping;

  128. 

  129.     ReadCopyFunction read_via_copy;

  130.     WriteCopyFunction write_via_copy;

  131. 

  132.     int             dither;

  133.     dither_state_t *dither_state;

  134. 

  135.     SampleClockMode clock_mode;

  136.     JSList *clock_sync_listeners;

  137.     pthread_mutex_t clock_sync_lock;

  138.     unsigned long next_clock_sync_listener_id;

  139. 

  140.     int running;

  141.     int run;

  142. 

  143.     int poll_late;

  144.     int xrun_count;

  145.     int process_count;

  146. 

  147.     alsa_midi_t *midi;

  148.     int xrun_recovery;

  149. 

  150. } alsa_driver_t;

  151. 

  152. static inline void

  153. alsa_driver_mark_channel_done (alsa_driver_t *driver, channel_t chn) {

  154. 	bitset_remove (driver->channels_not_done, chn);

  155. 	driver->silent[chn] = 0;

  156. }

  157. 

  158. static inline void

  159. alsa_driver_silence_on_channel (alsa_driver_t *driver, channel_t chn,

  160. 				jack_nframes_t nframes) {

  161. 	if (driver->playback_interleaved) {

  162. 		memset_interleave

  163. 			(driver->playback_addr[chn],

  164. 			 0, nframes * driver->playback_sample_bytes,

  165. 			 driver->interleave_unit,

  166. 			 driver->playback_interleave_skip[chn]);

  167. 	} else {

  168. 		memset (driver->playback_addr[chn], 0,

  169. 			nframes * driver->playback_sample_bytes);

  170. 	}

  171. 	alsa_driver_mark_channel_done (driver,chn);

  172. }

  173. 

  174. static inline void

  175. alsa_driver_silence_on_channel_no_mark (alsa_driver_t *driver, channel_t chn,

  176. 					jack_nframes_t nframes) {

  177. 	if (driver->playback_interleaved) {

  178. 		memset_interleave

  179. 			(driver->playback_addr[chn],

  180. 			 0, nframes * driver->playback_sample_bytes,

  181. 			 driver->interleave_unit,

  182. 			 driver->playback_interleave_skip[chn]);

  183. 	} else {

  184. 		memset (driver->playback_addr[chn], 0,

  185. 			nframes * driver->playback_sample_bytes);

  186. 	}

  187. }

  188. 

  189. static inline void

  190. alsa_driver_read_from_channel (alsa_driver_t *driver,

  191. 			       channel_t channel,

  192. 			       jack_default_audio_sample_t *buf,

  193. 			       jack_nframes_t nsamples)

  194. {

  195. 	driver->read_via_copy (buf,

  196. 			       driver->capture_addr[channel],

  197. 			       nsamples,

  198. 			       driver->capture_interleave_skip[channel]);

  199. }

  200. 

  201. static inline void

  202. alsa_driver_write_to_channel (alsa_driver_t *driver,

  203. 			      channel_t channel,

  204. 			      jack_default_audio_sample_t *buf,

  205. 			      jack_nframes_t nsamples)

  206. {

  207. 	driver->write_via_copy (driver->playback_addr[channel],

  208. 				buf,

  209. 				nsamples,

  210. 				driver->playback_interleave_skip[channel],

  211. 				driver->dither_state+channel);

  212. 	alsa_driver_mark_channel_done (driver, channel);

  213. }

  214. 

  215. void  alsa_driver_silence_untouched_channels (alsa_driver_t *driver,

  216. 					      jack_nframes_t nframes);

  217. void  alsa_driver_set_clock_sync_status (alsa_driver_t *driver, channel_t chn,

  218. 					 ClockSyncStatus status);

  219. int   alsa_driver_listen_for_clock_sync_status (alsa_driver_t *,

  220. 						ClockSyncListenerFunction,

  221. 						void *arg);

  222. int   alsa_driver_stop_listen_for_clock_sync_status (alsa_driver_t *,

  223. 						     unsigned int);

  224. void  alsa_driver_clock_sync_notify (alsa_driver_t *, channel_t chn,

  225. 				     ClockSyncStatus);

  226. 

  227. int

  228. alsa_driver_reset_parameters (alsa_driver_t *driver,

  229. 			      jack_nframes_t frames_per_cycle,

  230. 			      jack_nframes_t user_nperiods,

  231. 			      jack_nframes_t rate);

  232. 

  233. jack_driver_t *

  234. alsa_driver_new (char *name, char *playback_alsa_device,

  235. 		 char *capture_alsa_device,

  236. 		 jack_client_t *client,

  237. 		 jack_nframes_t frames_per_cycle,

  238. 		 jack_nframes_t user_nperiods,

  239. 		 jack_nframes_t rate,

  240. 		 int hw_monitoring,

  241. 		 int hw_metering,

  242. 		 int capturing,

  243. 		 int playing,

  244. 		 DitherAlgorithm dither,

  245. 		 int soft_mode,

  246. 		 int monitor,

  247. 		 int user_capture_nchnls,

  248. 		 int user_playback_nchnls,

  249. 		 int shorts_first,

  250. 		 jack_nframes_t capture_latency,

  251. 		 jack_nframes_t playback_latency,

  252. 		 alsa_midi_t *midi_driver,

  253. 		 int hw_timestamping

  254. 		 );

  255. void

  256. alsa_driver_delete (alsa_driver_t *driver);

  257. 

  258. int

  259. alsa_driver_start (alsa_driver_t *driver);

  260. 

  261. int

  262. alsa_driver_stop (alsa_driver_t *driver);

  263. 

  264. jack_nframes_t

  265. alsa_driver_wait (alsa_driver_t *driver, int extra_fd, int *status, float

  266. 		  *delayed_usecs);

  267. 

  268. int

  269. alsa_driver_read (alsa_driver_t *driver, jack_nframes_t nframes);

  270. 

  271. int

  272. alsa_driver_write (alsa_driver_t* driver, jack_nframes_t nframes);

  273. 

  274. jack_time_t jack_get_microseconds(void);

  275. 

  276. // Code implemented in JackAlsaDriver.cpp

  277. 

  278. void ReadInput(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nread);

  279. void MonitorInput();

  280. void ClearOutput();

  281. void WriteOutput(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nwritten);

  282. void SetTime(jack_time_t time);

  283. int Restart();

  284. 

  285. #ifdef __cplusplus

  286. }

  287. #endif

  288. 

  289. 

  290. #endif /* __jack_alsa_driver_h__ */