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.
689 Commits
4 Branches
7.6MB
Tree: e064f466bc
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e064f466bc'
${ noResults }
jack1/drivers/alsa/alsa_driver.h

234 lines
7.7KB
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$

  19. */

  20. 

  21. #ifndef __jack_alsa_driver_h__

  22. #define __jack_alsa_driver_h__

  23. 

  24. #include <alsa/asoundlib.h>

  25. #include <jack/bitset.h>

  26. 

  27. #if __BYTE_ORDER == __LITTLE_ENDIAN

  28. 	#define	SND_PCM_FORMAT_S24_3 SND_PCM_FORMAT_S24_3LE

  29. #elif __BYTE_ORDER == __BIG_ENDIAN

  30. 	#define	SND_PCM_FORMAT_S24_3 SND_PCM_FORMAT_S24_3BE

  31. #endif

  32. 

  33. 

  34. 

  35. #include <jack/types.h>

  36. #include <jack/hardware.h>

  37. #include <jack/driver.h>

  38. #include <jack/memops.h>

  39. #include <jack/jack.h>

  40. 

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

  42. 				   unsigned long src_bytes,

  43. 				   unsigned long src_skip_bytes);

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

  45. 				   unsigned long src_bytes,

  46. 				   unsigned long dst_skip_bytes,

  47. 				   dither_state_t *state);

  48. typedef void (*CopyCopyFunction)  (char *dst, char *src,

  49. 				   unsigned long src_bytes,

  50. 				   unsigned long dst_skip_bytes,

  51. 				   unsigned long src_skip_byte);

  52. 

  53. typedef struct _alsa_driver {

  54. 

  55.     JACK_DRIVER_NT_DECL

  56. 

  57.     int                           poll_timeout;

  58.     jack_time_t                   poll_last;

  59.     jack_time_t                   poll_next;

  60.     char                        **playback_addr;

  61.     char                        **capture_addr;

  62.     const snd_pcm_channel_area_t *capture_areas;

  63.     const snd_pcm_channel_area_t *playback_areas;

  64.     struct pollfd                *pfd;

  65.     unsigned int                  playback_nfds;

  66.     unsigned int                  capture_nfds;

  67.     unsigned long                 interleave_unit;

  68.     unsigned long                 capture_interleave_skip;

  69.     unsigned long                 playback_interleave_skip;

  70.     channel_t                     max_nchannels;

  71.     channel_t                     user_nchannels;

  72.     channel_t                     playback_nchannels;

  73.     channel_t                     capture_nchannels;

  74.     unsigned long                 playback_sample_bytes;

  75.     unsigned long                 capture_sample_bytes;

  76. 

  77.     jack_nframes_t                frame_rate;

  78.     jack_nframes_t                frames_per_cycle;

  79.     jack_nframes_t                capture_frame_latency;

  80.     jack_nframes_t                playback_frame_latency;

  81. 

  82.     unsigned long                *silent;

  83.     char                         *alsa_name_playback;

  84.     char                         *alsa_name_capture;

  85.     char                         *alsa_driver;

  86.     bitset_t			  channels_not_done;

  87.     bitset_t			  channels_done;

  88.     snd_pcm_format_t              playback_sample_format;

  89.     snd_pcm_format_t              capture_sample_format;

  90.     float                         max_sample_val;

  91.     unsigned long                 user_nperiods;

  92.     unsigned int                  playback_nperiods;

  93.     unsigned int                  capture_nperiods;

  94.     unsigned long                 last_mask;

  95.     snd_ctl_t                    *ctl_handle;

  96.     snd_pcm_t                    *playback_handle;

  97.     snd_pcm_t                    *capture_handle;

  98.     snd_pcm_hw_params_t          *playback_hw_params;

  99.     snd_pcm_sw_params_t          *playback_sw_params;

  100.     snd_pcm_hw_params_t          *capture_hw_params;

  101.     snd_pcm_sw_params_t          *capture_sw_params;

  102.     jack_hardware_t              *hw;  

  103.     ClockSyncStatus              *clock_sync_data;

  104.     jack_client_t                *client;

  105.     JSList                       *capture_ports;

  106.     JSList                       *playback_ports;

  107.     JSList                       *monitor_ports;

  108. 

  109.     unsigned long input_monitor_mask;

  110. 

  111.     char   soft_mode : 1;

  112.     char   hw_monitoring : 1;

  113.     char   hw_metering : 1;

  114.     char   all_monitor_in : 1;

  115.     char   capture_and_playback_not_synced : 1;

  116.     char   playback_interleaved : 1;

  117.     char   capture_interleaved : 1;

  118.     char   with_monitor_ports : 1;

  119. 

  120.     ReadCopyFunction read_via_copy;

  121.     WriteCopyFunction write_via_copy;

  122.     CopyCopyFunction channel_copy;

  123. 

  124.     int             dither;

  125.     dither_state_t *dither_state;

  126. 

  127.     SampleClockMode clock_mode;

  128.     JSList *clock_sync_listeners;

  129.     pthread_mutex_t clock_sync_lock;

  130.     unsigned long next_clock_sync_listener_id;

  131.     char has_clock_sync_reporting : 1;

  132.     char has_hw_monitoring : 1;

  133.     char has_hw_metering : 1;

  134. 

  135.     int running;

  136.     int run;

  137. 

  138.     int poll_late;

  139.     int xrun_count;

  140.     int process_count;

  141. 

  142. } alsa_driver_t;

  143. 

  144. static inline void 

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

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

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

  148. }

  149. 

  150. static inline void 

  151. alsa_driver_silence_on_channel (alsa_driver_t *driver, channel_t chn,

  152. 				jack_nframes_t nframes) {

  153. 	if (driver->playback_interleaved) {

  154. 		memset_interleave 

  155. 			(driver->playback_addr[chn],

  156. 			 0, nframes * driver->playback_sample_bytes,

  157. 			 driver->interleave_unit,

  158. 			 driver->playback_interleave_skip);

  159. 	} else {

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

  161. 			nframes * driver->playback_sample_bytes);

  162. 	}

  163. 	alsa_driver_mark_channel_done (driver,chn);

  164. }

  165. 

  166. static inline void 

  167. alsa_driver_silence_on_channel_no_mark (alsa_driver_t *driver, channel_t chn,

  168. 					jack_nframes_t nframes) {

  169. 	if (driver->playback_interleaved) {

  170. 		memset_interleave 

  171. 			(driver->playback_addr[chn],

  172. 			 0, nframes * driver->playback_sample_bytes,

  173. 			 driver->interleave_unit,

  174. 			 driver->playback_interleave_skip);

  175. 	} else {

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

  177. 			nframes * driver->playback_sample_bytes);

  178. 	}

  179. }

  180. 

  181. static inline void 

  182. alsa_driver_read_from_channel (alsa_driver_t *driver,

  183. 			       channel_t channel,

  184. 			       jack_default_audio_sample_t *buf,

  185. 			       jack_nframes_t nsamples)

  186. {

  187. 	driver->read_via_copy (buf, 

  188. 			       driver->capture_addr[channel],

  189. 			       nsamples, 

  190. 			       driver->capture_interleave_skip);

  191. }

  192. 

  193. static inline void 

  194. alsa_driver_write_to_channel (alsa_driver_t *driver,

  195. 			      channel_t channel, 

  196. 			      jack_default_audio_sample_t *buf, 

  197. 			      jack_nframes_t nsamples)

  198. {

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

  200. 				buf, 

  201. 				nsamples, 

  202. 				driver->playback_interleave_skip,

  203. 				driver->dither_state+channel);

  204. 	alsa_driver_mark_channel_done (driver, channel);

  205. }

  206. 

  207. static inline void 

  208. alsa_driver_copy_channel (alsa_driver_t *driver, 

  209. 			  channel_t input_channel, 

  210. 			  channel_t output_channel,

  211. 			  jack_nframes_t nsamples) {

  212. 

  213. 	driver->channel_copy (driver->playback_addr[output_channel],

  214. 			      driver->capture_addr[input_channel],

  215. 			      nsamples * driver->playback_sample_bytes,

  216. 			      driver->playback_interleave_skip,

  217. 			      driver->capture_interleave_skip);

  218. 	alsa_driver_mark_channel_done (driver, output_channel);

  219. }

  220. 

  221. void  alsa_driver_silence_untouched_channels (alsa_driver_t *driver,

  222. 					      jack_nframes_t nframes);

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

  224. 					 ClockSyncStatus status);

  225. int   alsa_driver_listen_for_clock_sync_status (alsa_driver_t *,

  226. 						ClockSyncListenerFunction,

  227. 						void *arg);

  228. int   alsa_driver_stop_listen_for_clock_sync_status (alsa_driver_t *,

  229. 						     unsigned int);

  230. void  alsa_driver_clock_sync_notify (alsa_driver_t *, channel_t chn,

  231. 				     ClockSyncStatus);

  232. 

  233. #endif /* __jack_alsa_driver_h__ */