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

383 lines
11KB
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_FORMAT_UNKNOWN     SND_PCM_SFMT_SPECIAL

  58. #define SND_PCM_STATE_PREPARED     SND_PCM_STATUS_PREPARED

  59. #define SND_PCM_STATE_SUSPENDED    SND_PCM_STATUS_SUSPENDED

  60. #define SND_PCM_STATE_XRUN         SND_PCM_STATUS_UNDERRUN

  61. #define SND_PCM_STATE_RUNNING      SND_PCM_STATUS_RUNNING

  62. #define SND_PCM_STATE_NOTREADY     SND_PCM_STATUS_NOTREADY

  63. #define SND_PCM_STREAM_PLAYBACK    SND_PCM_CHANNEL_PLAYBACK

  64. #define SND_PCM_STREAM_CAPTURE     SND_PCM_CHANNEL_CAPTURE

  65. 

  66. typedef unsigned long              snd_pcm_uframes_t;

  67. typedef signed long                snd_pcm_sframes_t;

  68. typedef int32_t                    alsa_driver_default_format_t;

  69. #else

  70. #define SND_PCM_STATE_NOTREADY     (SND_PCM_STATE_LAST + 1)

  71. #endif

  72. 

  73. #define ALSA_DRIVER_FEAT_BACKEND_EVAL_ON_INIT (1 << 0)

  74. #define ALSA_DRIVER_FEAT_BACKEND_CLOSE_IDLE  (1 << 1)

  75. #define ALSA_DRIVER_FEAT_UNLINKED_DEVS     (1 << 2)

  76. 

  77. #ifdef __cplusplus

  78. extern "C"

  79. {

  80. #endif

  81. 

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

  83.                                    unsigned long src_bytes,

  84.                                    unsigned long src_skip_bytes);

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

  86.                                    unsigned long src_bytes,

  87.                                    unsigned long dst_skip_bytes,

  88.                                    dither_state_t *state);

  89. 

  90. typedef struct _alsa_device {

  91. #ifdef __QNXNTO__

  92.     unsigned int                  playback_sample_format;

  93.     unsigned int                  capture_sample_format;

  94.     void                          *capture_areas;

  95.     void                          *playback_areas;

  96.     void                          *capture_areas_ptr;

  97.     void                          *playback_areas_ptr;

  98. #else

  99.     snd_pcm_format_t              playback_sample_format;

  100.     snd_pcm_format_t              capture_sample_format;

  101.     const snd_pcm_channel_area_t *capture_areas;

  102.     const snd_pcm_channel_area_t *playback_areas;

  103. #endif

  104.     snd_pcm_t *playback_handle;

  105.     snd_pcm_t *capture_handle;

  106. 

  107.     char *playback_name;

  108.     char *capture_name;

  109. 

  110.     char **playback_addr;

  111.     char **capture_addr;

  112. 

  113.     channel_t playback_channel_offset;

  114.     channel_t capture_channel_offset;

  115. 

  116.     channel_t playback_nchannels;

  117.     channel_t capture_nchannels;

  118.     channel_t max_nchannels;

  119.     channel_t user_nchannels;

  120. 

  121.     bitset_t channels_not_done;

  122.     bitset_t channels_done;

  123. 

  124.     char quirk_bswap;

  125. 

  126.     ReadCopyFunction read_via_copy;

  127.     WriteCopyFunction write_via_copy;

  128. 

  129.     unsigned long interleave_unit;

  130.     unsigned long *capture_interleave_skip;

  131.     unsigned long *playback_interleave_skip;

  132. 

  133.     char playback_interleaved;

  134.     char capture_interleaved;

  135. 

  136.     unsigned long *silent;

  137. 

  138.     unsigned long playback_sample_bytes;

  139.     unsigned long capture_sample_bytes;

  140. 

  141.     /* device is 'snd_pcm_link' to a group, only 1 group of linked devices is allowed */

  142.     int capture_linked;

  143.     int playback_linked;

  144. 

  145.     int capture_xrun_count;

  146.     int playback_xrun_count;

  147. 

  148.     /* desired state of device, decided by JackAlsaDriver */

  149.     int capture_target_state;

  150.     int playback_target_state;

  151. 

  152.     jack_hardware_t *hw;

  153.     snd_ctl_t *ctl_handle;

  154.     char *alsa_driver;

  155. 

  156.     JSList *clock_sync_listeners;

  157.     pthread_mutex_t clock_sync_lock;

  158.     unsigned long next_clock_sync_listener_id;

  159. } alsa_device_t;

  160. 

  161. typedef struct _alsa_driver {

  162. 

  163.     JACK_DRIVER_NT_DECL

  164. 

  165. #ifndef __QNXNTO__

  166.     snd_pcm_hw_params_t          *playback_hw_params;

  167.     snd_pcm_sw_params_t          *playback_sw_params;

  168.     snd_pcm_hw_params_t          *capture_hw_params;

  169.     snd_pcm_sw_params_t          *capture_sw_params;

  170. #endif

  171.     int                           poll_timeout_ms;

  172.     jack_time_t                   poll_last;

  173.     jack_time_t                   poll_next;

  174.     struct pollfd                *pfd;

  175.     unsigned int                  playback_nfds;

  176.     unsigned int                  capture_nfds;

  177.     channel_t                     playback_nchannels;

  178.     channel_t                     capture_nchannels;

  179. 

  180.     jack_nframes_t                frame_rate;

  181.     jack_nframes_t                frames_per_cycle;

  182.     jack_nframes_t                capture_frame_latency;

  183.     jack_nframes_t                playback_frame_latency;

  184. 

  185.     unsigned long                 user_nperiods;

  186.     unsigned int                  playback_nperiods;

  187.     unsigned int                  capture_nperiods;

  188.     jack_client_t                *client;

  189. 

  190.     unsigned long input_monitor_mask;

  191. 

  192.     char soft_mode;

  193.     char hw_monitoring;

  194.     char hw_metering;

  195.     char all_monitor_in;

  196.     char with_monitor_ports;

  197.     char has_clock_sync_reporting;

  198.     char has_hw_monitoring;

  199.     char has_hw_metering;

  200. 

  201.     int preferred_sample_bytes;

  202. 

  203.     int             dither;

  204.     dither_state_t *dither_state;

  205. 

  206.     SampleClockMode clock_mode;

  207. 

  208.     int poll_late;

  209.     int xrun_count;

  210.     int process_count;

  211. 

  212.     alsa_midi_t *midi;

  213.     int xrun_recovery;

  214. 

  215.     alsa_device_t *devices;

  216.     int devices_count;

  217.     int devices_c_count;

  218.     int devices_p_count;

  219. 

  220.     int features;

  221. } alsa_driver_t;

  222. 

  223. typedef struct _alsa_device_info {

  224.     char *capture_name;

  225.     char *playback_name;

  226. 

  227.     int capture_channels;

  228.     int playback_channels;

  229. } alsa_device_info_t;

  230. 

  231. typedef struct _alsa_driver_info {

  232.     alsa_device_info_t *devices;

  233.     uint32_t devices_capture_size;

  234.     uint32_t devices_playback_size;

  235. 

  236.     char *midi_name;

  237.     alsa_midi_t *midi_driver;

  238. 

  239.     jack_nframes_t frame_rate;

  240.     jack_nframes_t frames_per_period;

  241.     int periods_n;

  242. 

  243.     DitherAlgorithm dither;

  244. 

  245.     int shorts_first;

  246. 

  247.     jack_nframes_t capture_latency;

  248.     jack_nframes_t playback_latency;

  249. 

  250.     // these 4 should be reworked as struct.features

  251.     int hw_monitoring;

  252.     int hw_metering;

  253.     int monitor;

  254.     int soft_mode;

  255. 

  256.     int features;

  257. } alsa_driver_info_t;

  258. 

  259. static inline void

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

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

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

  263. }

  264. 

  265. static inline void

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

  267. 				jack_nframes_t nframes) {

  268. 	if (device->playback_interleaved) {

  269. 		memset_interleave

  270. 			(device->playback_addr[chn],

  271. 			 0, nframes * device->playback_sample_bytes,

  272. 			 device->interleave_unit,

  273. 			 device->playback_interleave_skip[chn]);

  274. 	} else {

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

  276. 			nframes * device->playback_sample_bytes);

  277. 	}

  278.     alsa_driver_mark_channel_done (driver, device, chn);

  279. }

  280. 

  281. static inline void

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

  283. 					jack_nframes_t nframes) {

  284. 	if (device->playback_interleaved) {

  285. 		memset_interleave

  286. 			(device->playback_addr[chn],

  287. 			 0, nframes * device->playback_sample_bytes,

  288. 			 device->interleave_unit,

  289. 			 device->playback_interleave_skip[chn]);

  290. 	} else {

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

  292. 			nframes * device->playback_sample_bytes);

  293. 	}

  294. }

  295. 

  296. static inline void

  297. alsa_driver_read_from_channel (alsa_driver_t *driver,

  298.                    alsa_device_t *device,

  299. 			       channel_t channel,

  300. 			       jack_default_audio_sample_t *buf,

  301. 			       jack_nframes_t nsamples)

  302. {

  303. 	device->read_via_copy (buf,

  304. 			       device->capture_addr[channel],

  305. 			       nsamples,

  306. 			       device->capture_interleave_skip[channel]);

  307. }

  308. 

  309. static inline void

  310. alsa_driver_write_to_channel (alsa_driver_t *driver,

  311.                   alsa_device_t *device,

  312. 			      channel_t channel,

  313. 			      jack_default_audio_sample_t *buf,

  314. 			      jack_nframes_t nsamples)

  315. {

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

  317. 				buf,

  318. 				nsamples,

  319. 				device->playback_interleave_skip[channel],

  320. 				driver->dither_state+channel);

  321. 	alsa_driver_mark_channel_done (driver, device, channel);

  322. }

  323. 

  324. int

  325. alsa_driver_reset_parameters (alsa_driver_t *driver,

  326. 			      jack_nframes_t frames_per_cycle,

  327. 			      jack_nframes_t user_nperiods,

  328. 			      jack_nframes_t rate);

  329. 

  330. jack_driver_t *

  331. alsa_driver_new (char *name, alsa_driver_info_t info, jack_client_t *client);

  332. 

  333. void

  334. alsa_driver_delete (alsa_driver_t *driver);

  335. 

  336. int

  337. alsa_driver_open (alsa_driver_t *driver);

  338. 

  339. int

  340. alsa_driver_start (alsa_driver_t *driver);

  341. 

  342. int

  343. alsa_driver_stop (alsa_driver_t *driver);

  344. 

  345. int

  346. alsa_driver_close (alsa_driver_t *driver);

  347. 

  348. typedef enum {

  349. 	ALSA_DRIVER_WAIT_OK = 0,

  350. 	ALSA_DRIVER_WAIT_ERROR = -1,

  351. 	ALSA_DRIVER_WAIT_XRUN = -2,

  352. } alsa_driver_wait_status_t;

  353. 

  354. jack_nframes_t

  355. alsa_driver_wait (alsa_driver_t *driver, int extra_fd, alsa_driver_wait_status_t *status, float

  356. 		  *delayed_usecs);

  357. 

  358. int

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

  360. 

  361. int

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

  363. 

  364. int

  365. alsa_driver_xrun_recovery (alsa_driver_t *driver, float *delayed_usecs);

  366. 

  367. // Code implemented in JackAlsaDriver.cpp

  368. 

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

  370. void MonitorInput();

  371. void ClearOutput();

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

  373. void SetTime(jack_time_t time);

  374. 

  375. int Restart();

  376. 

  377. #ifdef __cplusplus

  378. }

  379. #endif

  380. 

  381. 

  382. #endif /* __jack_alsa_driver_h__ */