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

307 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_driver {

  81. 

  82.     JACK_DRIVER_NT_DECL

  83. 

  84. #ifdef __QNXNTO__

  85.     unsigned int                  playback_sample_format;

  86.     unsigned int                  capture_sample_format;

  87.     void                          *capture_areas;

  88.     void                          *playback_areas;

  89.     void                          *capture_areas_ptr;

  90.     void                          *playback_areas_ptr;

  91. #else

  92.     snd_pcm_format_t              playback_sample_format;

  93.     snd_pcm_format_t              capture_sample_format;

  94.     const snd_pcm_channel_area_t *capture_areas;

  95.     const snd_pcm_channel_area_t *playback_areas;

  96.     snd_pcm_hw_params_t          *playback_hw_params;

  97.     snd_pcm_sw_params_t          *playback_sw_params;

  98.     snd_pcm_hw_params_t          *capture_hw_params;

  99.     snd_pcm_sw_params_t          *capture_sw_params;

  100. #endif

  101.     int                           poll_timeout_ms;

  102.     jack_time_t                   poll_last;

  103.     jack_time_t                   poll_next;

  104.     char                        **playback_addr;

  105.     char                        **capture_addr;

  106.     struct pollfd                *pfd;

  107.     unsigned int                  playback_nfds;

  108.     unsigned int                  capture_nfds;

  109.     unsigned long                 interleave_unit;

  110.     unsigned long                *capture_interleave_skip;

  111.     unsigned long                *playback_interleave_skip;

  112.     channel_t                     max_nchannels;

  113.     channel_t                     user_nchannels;

  114.     channel_t                     playback_nchannels;

  115.     channel_t                     capture_nchannels;

  116.     unsigned long                 playback_sample_bytes;

  117.     unsigned long                 capture_sample_bytes;

  118. 

  119.     jack_nframes_t                frame_rate;

  120.     jack_nframes_t                frames_per_cycle;

  121.     jack_nframes_t                capture_frame_latency;

  122.     jack_nframes_t                playback_frame_latency;

  123. 

  124.     unsigned long                *silent;

  125.     char                         *alsa_name_playback;

  126.     char                         *alsa_name_capture;

  127.     char                         *alsa_driver;

  128.     bitset_t			  channels_not_done;

  129.     bitset_t			  channels_done;

  130.     float                         max_sample_val;

  131.     unsigned long                 user_nperiods;

  132.     unsigned int                  playback_nperiods;

  133.     unsigned int                  capture_nperiods;

  134.     unsigned long                 last_mask;

  135.     snd_ctl_t                    *ctl_handle;

  136.     snd_pcm_t                    *playback_handle;

  137.     snd_pcm_t                    *capture_handle;

  138.     jack_hardware_t              *hw;

  139.     ClockSyncStatus              *clock_sync_data;

  140.     jack_client_t                *client;

  141.     JSList                       *capture_ports;

  142.     JSList                       *playback_ports;

  143.     JSList                       *monitor_ports;

  144. 

  145.     unsigned long input_monitor_mask;

  146. 

  147.     char soft_mode;

  148.     char hw_monitoring;

  149.     char hw_metering;

  150.     char all_monitor_in;

  151.     char capture_and_playback_not_synced;

  152.     char playback_interleaved;

  153.     char capture_interleaved;

  154.     char with_monitor_ports;

  155.     char has_clock_sync_reporting;

  156.     char has_hw_monitoring;

  157.     char has_hw_metering;

  158.     char quirk_bswap;

  159. 

  160.     ReadCopyFunction read_via_copy;

  161.     WriteCopyFunction write_via_copy;

  162. 

  163.     int             dither;

  164.     dither_state_t *dither_state;

  165. 

  166.     SampleClockMode clock_mode;

  167.     JSList *clock_sync_listeners;

  168.     pthread_mutex_t clock_sync_lock;

  169.     unsigned long next_clock_sync_listener_id;

  170. 

  171.     int running;

  172.     int run;

  173. 

  174.     int poll_late;

  175.     int xrun_count;

  176.     int process_count;

  177. 

  178.     alsa_midi_t *midi;

  179.     int xrun_recovery;

  180. 

  181. } alsa_driver_t;

  182. 

  183. static inline void

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

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

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

  187. }

  188. 

  189. static inline void

  190. alsa_driver_silence_on_channel (alsa_driver_t *driver, channel_t chn,

  191. 				jack_nframes_t nframes) {

  192. 	if (driver->playback_interleaved) {

  193. 		memset_interleave

  194. 			(driver->playback_addr[chn],

  195. 			 0, nframes * driver->playback_sample_bytes,

  196. 			 driver->interleave_unit,

  197. 			 driver->playback_interleave_skip[chn]);

  198. 	} else {

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

  200. 			nframes * driver->playback_sample_bytes);

  201. 	}

  202. 	alsa_driver_mark_channel_done (driver,chn);

  203. }

  204. 

  205. static inline void

  206. alsa_driver_silence_on_channel_no_mark (alsa_driver_t *driver, channel_t chn,

  207. 					jack_nframes_t nframes) {

  208. 	if (driver->playback_interleaved) {

  209. 		memset_interleave

  210. 			(driver->playback_addr[chn],

  211. 			 0, nframes * driver->playback_sample_bytes,

  212. 			 driver->interleave_unit,

  213. 			 driver->playback_interleave_skip[chn]);

  214. 	} else {

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

  216. 			nframes * driver->playback_sample_bytes);

  217. 	}

  218. }

  219. 

  220. static inline void

  221. alsa_driver_read_from_channel (alsa_driver_t *driver,

  222. 			       channel_t channel,

  223. 			       jack_default_audio_sample_t *buf,

  224. 			       jack_nframes_t nsamples)

  225. {

  226. 	driver->read_via_copy (buf,

  227. 			       driver->capture_addr[channel],

  228. 			       nsamples,

  229. 			       driver->capture_interleave_skip[channel]);

  230. }

  231. 

  232. static inline void

  233. alsa_driver_write_to_channel (alsa_driver_t *driver,

  234. 			      channel_t channel,

  235. 			      jack_default_audio_sample_t *buf,

  236. 			      jack_nframes_t nsamples)

  237. {

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

  239. 				buf,

  240. 				nsamples,

  241. 				driver->playback_interleave_skip[channel],

  242. 				driver->dither_state+channel);

  243. 	alsa_driver_mark_channel_done (driver, channel);

  244. }

  245. 

  246. int

  247. alsa_driver_reset_parameters (alsa_driver_t *driver,

  248. 			      jack_nframes_t frames_per_cycle,

  249. 			      jack_nframes_t user_nperiods,

  250. 			      jack_nframes_t rate);

  251. 

  252. jack_driver_t *

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

  254. 		 char *capture_alsa_device,

  255. 		 jack_client_t *client,

  256. 		 jack_nframes_t frames_per_cycle,

  257. 		 jack_nframes_t user_nperiods,

  258. 		 jack_nframes_t rate,

  259. 		 int hw_monitoring,

  260. 		 int hw_metering,

  261. 		 int capturing,

  262. 		 int playing,

  263. 		 DitherAlgorithm dither,

  264. 		 int soft_mode,

  265. 		 int monitor,

  266. 		 int user_capture_nchnls,

  267. 		 int user_playback_nchnls,

  268. 		 int shorts_first,

  269. 		 jack_nframes_t capture_latency,

  270. 		 jack_nframes_t playback_latency,

  271. 		 alsa_midi_t *midi_driver

  272. 		 );

  273. void

  274. alsa_driver_delete (alsa_driver_t *driver);

  275. 

  276. int

  277. alsa_driver_start (alsa_driver_t *driver);

  278. 

  279. int

  280. alsa_driver_stop (alsa_driver_t *driver);

  281. 

  282. jack_nframes_t

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

  284. 		  *delayed_usecs);

  285. 

  286. int

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

  288. 

  289. int

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

  291. 

  292. // Code implemented in JackAlsaDriver.cpp

  293. 

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

  295. void MonitorInput();

  296. void ClearOutput();

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

  298. void SetTime(jack_time_t time);

  299. int Restart();

  300. 

  301. #ifdef __cplusplus

  302. }

  303. #endif

  304. 

  305. 

  306. #endif /* __jack_alsa_driver_h__ */