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.

203 lines
7.3KB

  1. /*
  2. Copyright (C) 2001 Paul Davis
  3. This program is free software; you can redistribute it and/or modify
  4. it under the terms of the GNU General Public License as published by
  5. the Free Software Foundation; either version 2 of the License, or
  6. (at your option) any later version.
  7. This program is distributed in the hope that it will be useful,
  8. but WITHOUT ANY WARRANTY; without even the implied warranty of
  9. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  10. GNU General Public License for more details.
  11. You should have received a copy of the GNU General Public License
  12. along with this program; if not, write to the Free Software
  13. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  14. $Id$
  15. */
  16. #ifndef __jack_alsa_driver_h__
  17. #define __jack_alsa_driver_h__
  18. #include <alsa/asoundlib.h>
  19. #include <jack/types.h>
  20. #include <jack/hardware.h>
  21. #include <jack/driver.h>
  22. #include <jack/memops.h>
  23. #include <jack/jack.h>
  24. typedef void (*ReadCopyFunction) (jack_default_audio_sample_t *dst, char *src,
  25. unsigned long src_bytes,
  26. unsigned long src_skip_bytes);
  27. typedef void (*WriteCopyFunction) (char *dst, jack_default_audio_sample_t *src,
  28. unsigned long src_bytes,
  29. unsigned long dst_skip_bytes,
  30. dither_state_t *state);
  31. typedef void (*CopyCopyFunction) (char *dst, char *src,
  32. unsigned long src_bytes,
  33. unsigned long dst_skip_bytes,
  34. unsigned long src_skip_byte);
  35. typedef struct {
  36. JACK_DRIVER_DECL
  37. int poll_timeout;
  38. jack_time_t poll_last;
  39. jack_time_t poll_next;
  40. char **playback_addr;
  41. char **capture_addr;
  42. const snd_pcm_channel_area_t *capture_areas;
  43. const snd_pcm_channel_area_t *playback_areas;
  44. struct pollfd *pfd;
  45. unsigned int playback_nfds;
  46. unsigned int capture_nfds;
  47. unsigned long interleave_unit;
  48. unsigned long capture_interleave_skip;
  49. unsigned long playback_interleave_skip;
  50. channel_t max_nchannels;
  51. channel_t user_nchannels;
  52. channel_t playback_nchannels;
  53. channel_t capture_nchannels;
  54. unsigned long playback_sample_bytes;
  55. unsigned long capture_sample_bytes;
  56. jack_nframes_t frame_rate;
  57. jack_nframes_t frames_per_cycle;
  58. jack_nframes_t capture_frame_latency;
  59. jack_nframes_t playback_frame_latency;
  60. unsigned long *silent;
  61. char *alsa_name_playback;
  62. char *alsa_name_capture;
  63. char *alsa_driver;
  64. snd_pcm_uframes_t buffer_frames;
  65. unsigned long channels_not_done;
  66. unsigned long channel_done_bits;
  67. snd_pcm_format_t playback_sample_format;
  68. snd_pcm_format_t capture_sample_format;
  69. float max_sample_val;
  70. unsigned long user_nperiods;
  71. unsigned long nfragments;
  72. unsigned long last_mask;
  73. snd_ctl_t *ctl_handle;
  74. snd_pcm_t *playback_handle;
  75. snd_pcm_t *capture_handle;
  76. snd_pcm_hw_params_t *playback_hw_params;
  77. snd_pcm_sw_params_t *playback_sw_params;
  78. snd_pcm_hw_params_t *capture_hw_params;
  79. snd_pcm_sw_params_t *capture_sw_params;
  80. jack_hardware_t *hw;
  81. ClockSyncStatus *clock_sync_data;
  82. struct _jack_engine *engine;
  83. jack_client_t *client;
  84. JSList *capture_ports;
  85. JSList *playback_ports;
  86. unsigned long input_monitor_mask;
  87. char soft_mode : 1;
  88. char hw_monitoring : 1;
  89. char hw_metering : 1;
  90. char all_monitor_in : 1;
  91. char capture_and_playback_not_synced : 1;
  92. char playback_interleaved : 1;
  93. char capture_interleaved : 1;
  94. char with_monitor_ports : 1;
  95. ReadCopyFunction read_via_copy;
  96. WriteCopyFunction write_via_copy;
  97. CopyCopyFunction channel_copy;
  98. int dither;
  99. dither_state_t *dither_state;
  100. SampleClockMode clock_mode;
  101. JSList *clock_sync_listeners;
  102. pthread_mutex_t clock_sync_lock;
  103. unsigned long next_clock_sync_listener_id;
  104. char has_clock_sync_reporting : 1;
  105. char has_hw_monitoring : 1;
  106. char has_hw_metering : 1;
  107. int xrun_count;
  108. int process_count;
  109. } alsa_driver_t;
  110. static __inline__ void alsa_driver_mark_channel_done (alsa_driver_t *driver, channel_t chn) {
  111. driver->channels_not_done &= ~(1<<chn);
  112. driver->silent[chn] = 0;
  113. }
  114. static __inline__ void alsa_driver_silence_on_channel (alsa_driver_t *driver, channel_t chn, jack_nframes_t nframes) {
  115. if (driver->playback_interleaved) {
  116. memset_interleave
  117. (driver->playback_addr[chn],
  118. 0, nframes * driver->playback_sample_bytes,
  119. driver->interleave_unit,
  120. driver->playback_interleave_skip);
  121. } else {
  122. memset (driver->playback_addr[chn], 0, nframes * driver->playback_sample_bytes);
  123. }
  124. alsa_driver_mark_channel_done (driver,chn);
  125. }
  126. static __inline__ void alsa_driver_silence_on_channel_no_mark (alsa_driver_t *driver, channel_t chn, jack_nframes_t nframes) {
  127. if (driver->playback_interleaved) {
  128. memset_interleave
  129. (driver->playback_addr[chn],
  130. 0, nframes * driver->playback_sample_bytes,
  131. driver->interleave_unit,
  132. driver->playback_interleave_skip);
  133. } else {
  134. memset (driver->playback_addr[chn], 0, nframes * driver->playback_sample_bytes);
  135. }
  136. }
  137. static __inline__ void alsa_driver_read_from_channel (alsa_driver_t *driver,
  138. channel_t channel, jack_default_audio_sample_t *buf,
  139. jack_nframes_t nsamples)
  140. {
  141. driver->read_via_copy (buf,
  142. driver->capture_addr[channel],
  143. nsamples,
  144. driver->capture_interleave_skip);
  145. }
  146. static __inline__ void alsa_driver_write_to_channel (alsa_driver_t *driver,
  147. channel_t channel,
  148. jack_default_audio_sample_t *buf,
  149. jack_nframes_t nsamples)
  150. {
  151. driver->write_via_copy (driver->playback_addr[channel],
  152. buf,
  153. nsamples,
  154. driver->playback_interleave_skip,
  155. driver->dither_state+channel);
  156. alsa_driver_mark_channel_done (driver, channel);
  157. }
  158. static __inline__ void alsa_driver_copy_channel (alsa_driver_t *driver,
  159. channel_t input_channel,
  160. channel_t output_channel,
  161. jack_nframes_t nsamples) {
  162. driver->channel_copy (driver->playback_addr[output_channel],
  163. driver->capture_addr[input_channel],
  164. nsamples * driver->playback_sample_bytes,
  165. driver->playback_interleave_skip,
  166. driver->capture_interleave_skip);
  167. alsa_driver_mark_channel_done (driver, output_channel);
  168. }
  169. void alsa_driver_set_clock_sync_status (alsa_driver_t *driver, channel_t chn, ClockSyncStatus status);
  170. int alsa_driver_listen_for_clock_sync_status (alsa_driver_t *, ClockSyncListenerFunction, void *arg);
  171. int alsa_driver_stop_listen_for_clock_sync_status (alsa_driver_t *, unsigned int);
  172. void alsa_driver_clock_sync_notify (alsa_driver_t *, channel_t chn, ClockSyncStatus);
  173. #endif /* __jack_alsa_driver_h__ */