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.
3836 Commits
7 Branches
61MB
Tree: 1ef6fb90e6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1ef6fb90e6'
${ noResults }
jack2/linux/alsa/alsa_driver.h

331 lines
9.4KB
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. #ifdef __QNXNTO__

  25. #include <sys/asoundlib.h>

  26. #else

  27. #include <alsa/asoundlib.h>

  28. #endif

  29. 

  30. #include "bitset.h"

  31. 

  32. #if __BYTE_ORDER == __LITTLE_ENDIAN

  33. #define IS_LE 0

  34. #define IS_BE 1

  35. #elif __BYTE_ORDER == __BIG_ENDIAN

  36. #define IS_LE 1

  37. #define IS_BE 0

  38. #endif

  39. 

  40. #define TRUE 1

  41. #define FALSE 0

  42. 

  43. #include "types.h"

  44. #include "hardware.h"

  45. #include "driver.h"

  46. #include "memops.h"

  47. #include "alsa_midi.h"

  48. 

  49. #ifdef __QNXNTO__

  50. #define SND_PCM_FORMAT_S16_LE      SND_PCM_SFMT_S16_LE

  51. #define SND_PCM_FORMAT_S16_BE      SND_PCM_SFMT_S16_BE

  52. #define SND_PCM_FORMAT_S24_LE      SND_PCM_SFMT_S24_LE

  53. #define SND_PCM_FORMAT_S24_BE      SND_PCM_SFMT_S24_BE

  54. #define SND_PCM_FORMAT_S32_LE      SND_PCM_SFMT_S32_LE

  55. #define SND_PCM_FORMAT_S32_BE      SND_PCM_SFMT_S32_BE

  56. #define SND_PCM_FORMAT_FLOAT_LE    SND_PCM_SFMT_FLOAT_LE

  57. #define SND_PCM_STATE_SUSPENDED    SND_PCM_STATUS_SUSPENDED

  58. #define SND_PCM_STATE_XRUN         SND_PCM_STATUS_UNDERRUN

  59. #define SND_PCM_STREAM_PLAYBACK    SND_PCM_CHANNEL_PLAYBACK

  60. #define SND_PCM_STREAM_CAPTURE     SND_PCM_CHANNEL_CAPTURE

  61. 

  62. typedef unsigned long              snd_pcm_uframes_t;

  63. typedef signed long                snd_pcm_sframes_t;

  64. typedef int32_t                    alsa_driver_default_format_t;

  65. #endif

  66. 

  67. #ifdef __cplusplus

  68. extern "C"

  69. {

  70. #endif

  71. 

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

  73.                                    unsigned long src_bytes,

  74.                                    unsigned long src_skip_bytes);

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

  76.                                    unsigned long src_bytes,

  77.                                    unsigned long dst_skip_bytes,

  78.                                    dither_state_t *state);

  79. 

  80. typedef struct _alsa_device {

  81. #ifdef __QNXNTO__

  82.     unsigned int                  playback_sample_format;

  83.     unsigned int                  capture_sample_format;

  84.     void                          *capture_areas;

  85.     void                          *playback_areas;

  86.     void                          *capture_areas_ptr;

  87.     void                          *playback_areas_ptr;

  88. #else

  89.     snd_pcm_format_t              playback_sample_format;

  90.     snd_pcm_format_t              capture_sample_format;

  91.     const snd_pcm_channel_area_t *capture_areas;

  92.     const snd_pcm_channel_area_t *playback_areas;

  93. #endif

  94.     snd_pcm_t *playback_handle;

  95.     snd_pcm_t *capture_handle;

  96. 

  97.     char *playback_name;

  98.     char *capture_name;

  99. 

  100.     char **playback_addr;

  101.     char **capture_addr;

  102. 

  103.     channel_t playback_channel_offset;

  104.     channel_t capture_channel_offset;

  105. 

  106.     channel_t playback_nchannels;

  107.     channel_t capture_nchannels;

  108.     channel_t max_nchannels;

  109.     channel_t user_nchannels;

  110. 

  111.     bitset_t channels_not_done;

  112.     bitset_t channels_done;

  113. 

  114.     char quirk_bswap;

  115. 

  116.     ReadCopyFunction read_via_copy;

  117.     WriteCopyFunction write_via_copy;

  118. 

  119.     unsigned long interleave_unit;

  120.     unsigned long *capture_interleave_skip;

  121.     unsigned long *playback_interleave_skip;

  122. 

  123.     char playback_interleaved;

  124.     char capture_interleaved;

  125. 

  126.     unsigned long *silent;

  127. 

  128.     unsigned long playback_sample_bytes;

  129.     unsigned long capture_sample_bytes;

  130. 

  131.     /* is this device linked to first device */

  132.     int capture_linked;

  133.     int playback_linked;

  134. 

  135.     int capture_xrun_count;

  136.     int playback_xrun_count;

  137. 

  138.     jack_hardware_t *hw;

  139.     char *alsa_driver;

  140. } alsa_device_t;

  141. 

  142. typedef struct _alsa_driver {

  143. 

  144.     JACK_DRIVER_NT_DECL

  145. 

  146. #ifndef __QNXNTO__

  147.     snd_pcm_hw_params_t          *playback_hw_params;

  148.     snd_pcm_sw_params_t          *playback_sw_params;

  149.     snd_pcm_hw_params_t          *capture_hw_params;

  150.     snd_pcm_sw_params_t          *capture_sw_params;

  151. #endif

  152.     int                           poll_timeout_ms;

  153.     jack_time_t                   poll_last;

  154.     jack_time_t                   poll_next;

  155.     struct pollfd                *pfd;

  156.     unsigned int                  playback_nfds;

  157.     unsigned int                  capture_nfds;

  158.     channel_t                     playback_nchannels;

  159.     channel_t                     capture_nchannels;

  160. 

  161.     jack_nframes_t                frame_rate;

  162.     jack_nframes_t                frames_per_cycle;

  163.     jack_nframes_t                capture_frame_latency;

  164.     jack_nframes_t                playback_frame_latency;

  165. 

  166.     unsigned long                 user_nperiods;

  167.     unsigned int                  playback_nperiods;

  168.     unsigned int                  capture_nperiods;

  169.     snd_ctl_t                    *ctl_handle;

  170.     jack_client_t                *client;

  171. 

  172.     unsigned long input_monitor_mask;

  173. 

  174.     char soft_mode;

  175.     char hw_monitoring;

  176.     char hw_metering;

  177.     char all_monitor_in;

  178.     char with_monitor_ports;

  179.     char has_clock_sync_reporting;

  180.     char has_hw_monitoring;

  181.     char has_hw_metering;

  182. 

  183.     int             dither;

  184.     dither_state_t *dither_state;

  185. 

  186.     SampleClockMode clock_mode;

  187.     JSList *clock_sync_listeners;

  188.     pthread_mutex_t clock_sync_lock;

  189. 

  190.     int poll_late;

  191.     int xrun_count;

  192.     int process_count;

  193. 

  194.     alsa_midi_t *midi;

  195.     int xrun_recovery;

  196. 

  197.     alsa_device_t *devices;

  198.     int devices_count;

  199.     int devices_c_count;

  200.     int devices_p_count;

  201. } alsa_driver_t;

  202. 

  203. static inline void

  204. alsa_driver_mark_channel_done (alsa_driver_t *driver, alsa_device_t *device, channel_t chn) {

  205. 	bitset_remove (device->channels_not_done, chn);

  206. 	device->silent[chn] = 0;

  207. }

  208. 

  209. static inline void

  210. alsa_driver_silence_on_channel (alsa_driver_t *driver, alsa_device_t *device, channel_t chn,

  211. 				jack_nframes_t nframes) {

  212. 	if (device->playback_interleaved) {

  213. 		memset_interleave

  214. 			(device->playback_addr[chn],

  215. 			 0, nframes * device->playback_sample_bytes,

  216. 			 device->interleave_unit,

  217. 			 device->playback_interleave_skip[chn]);

  218. 	} else {

  219. 		memset (device->playback_addr[chn], 0,

  220. 			nframes * device->playback_sample_bytes);

  221. 	}

  222.     alsa_driver_mark_channel_done (driver, device, chn);

  223. }

  224. 

  225. static inline void

  226. alsa_driver_silence_on_channel_no_mark (alsa_driver_t *driver, alsa_device_t *device, channel_t chn,

  227. 					jack_nframes_t nframes) {

  228. 	if (device->playback_interleaved) {

  229. 		memset_interleave

  230. 			(device->playback_addr[chn],

  231. 			 0, nframes * device->playback_sample_bytes,

  232. 			 device->interleave_unit,

  233. 			 device->playback_interleave_skip[chn]);

  234. 	} else {

  235. 		memset (device->playback_addr[chn], 0,

  236. 			nframes * device->playback_sample_bytes);

  237. 	}

  238. }

  239. 

  240. static inline void

  241. alsa_driver_read_from_channel (alsa_driver_t *driver,

  242.                    alsa_device_t *device,

  243. 			       channel_t channel,

  244. 			       jack_default_audio_sample_t *buf,

  245. 			       jack_nframes_t nsamples)

  246. {

  247. 	device->read_via_copy (buf,

  248. 			       device->capture_addr[channel],

  249. 			       nsamples,

  250. 			       device->capture_interleave_skip[channel]);

  251. }

  252. 

  253. static inline void

  254. alsa_driver_write_to_channel (alsa_driver_t *driver,

  255.                   alsa_device_t *device,

  256. 			      channel_t channel,

  257. 			      jack_default_audio_sample_t *buf,

  258. 			      jack_nframes_t nsamples)

  259. {

  260. 	device->write_via_copy (device->playback_addr[channel],

  261. 				buf,

  262. 				nsamples,

  263. 				device->playback_interleave_skip[channel],

  264. 				driver->dither_state+channel);

  265. 	alsa_driver_mark_channel_done (driver, device, channel);

  266. }

  267. 

  268. int

  269. alsa_driver_reset_parameters (alsa_driver_t *driver,

  270. 			      jack_nframes_t frames_per_cycle,

  271. 			      jack_nframes_t user_nperiods,

  272. 			      jack_nframes_t rate);

  273. 

  274. jack_driver_t *

  275. alsa_driver_new (char *name, char **capture_alsa_devices,

  276. 		 char **playback_alsa_devices,

  277. 		 const char *capture_names,

  278. 		 const char *playback_names,

  279. 		 jack_client_t *client,

  280. 		 jack_nframes_t frames_per_cycle,

  281. 		 jack_nframes_t user_nperiods,

  282. 		 jack_nframes_t rate,

  283. 		 int hw_monitoring,

  284. 		 int hw_metering,

  285. 		 int capturing_count,

  286. 		 int playing_count,

  287. 		 DitherAlgorithm dither,

  288. 		 int soft_mode,

  289. 		 int monitor,

  290. 		 int user_capture_nchnls,

  291. 		 int user_playback_nchnls,

  292. 		 int shorts_first,

  293. 		 jack_nframes_t capture_latency,

  294. 		 jack_nframes_t playback_latency,

  295. 		 alsa_midi_t *midi_driver

  296. 		 );

  297. void

  298. alsa_driver_delete (alsa_driver_t *driver);

  299. 

  300. int

  301. alsa_driver_start (alsa_driver_t *driver);

  302. 

  303. int

  304. alsa_driver_stop (alsa_driver_t *driver);

  305. 

  306. jack_nframes_t

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

  308. 		  *delayed_usecs);

  309. 

  310. int

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

  312. 

  313. int

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

  315. 

  316. // Code implemented in JackAlsaDriver.cpp

  317. 

  318. void ReadInput(alsa_device_t *device, jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nread);

  319. void MonitorInput();

  320. void ClearOutput();

  321. void WriteOutput(alsa_device_t *device, jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nwritten);

  322. void SetTime(jack_time_t time);

  323. int Restart();

  324. 

  325. #ifdef __cplusplus

  326. }

  327. #endif

  328. 

  329. 

  330. #endif /* __jack_alsa_driver_h__ */