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

245 lines
8.5KB
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. #include <alsa/asoundlib.h>

  25. #include "bitset.h"

  26. 

  27. #if __BYTE_ORDER == __LITTLE_ENDIAN

  28. #define IS_LE 0

  29. #define IS_BE 1

  30. #elif __BYTE_ORDER == __BIG_ENDIAN

  31. #define IS_LE 1

  32. #define IS_BE 0

  33. #endif

  34. 

  35. #include "types.h"

  36. #include "hardware.h"

  37. #include "driver.h"

  38. #include "memops.h"

  39. 

  40. #include "alsa_midi.h"

  41. 

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

  43.                                    unsigned long src_bytes,

  44.                                    unsigned long src_skip_bytes);

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

  46.                                    unsigned long src_bytes,

  47.                                    unsigned long dst_skip_bytes,

  48.                                    dither_state_t *state);

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

  50.                                    unsigned long src_bytes,

  51.                                    unsigned long dst_skip_bytes,

  52.                                    unsigned long src_skip_byte);

  53. 

  54. typedef struct _alsa_driver

  55. {

  56. 

  57.     JACK_DRIVER_NT_DECL

  58. 

  59.     int                           poll_timeout;

  60.     jack_time_t                   poll_last;

  61.     jack_time_t                   poll_next;

  62.     char                        **playback_addr;

  63.     char                        **capture_addr;

  64.     const snd_pcm_channel_area_t *capture_areas;

  65.     const snd_pcm_channel_area_t *playback_areas;

  66.     struct pollfd                *pfd;

  67.     unsigned int                  playback_nfds;

  68.     unsigned int                  capture_nfds;

  69.     unsigned long                 interleave_unit;

  70.     unsigned long                *capture_interleave_skip;

  71.     unsigned long                *playback_interleave_skip;

  72.     channel_t                     max_nchannels;

  73.     channel_t                     user_nchannels;

  74.     channel_t                     playback_nchannels;

  75.     channel_t                     capture_nchannels;

  76.     unsigned long                 playback_sample_bytes;

  77.     unsigned long                 capture_sample_bytes;

  78. 

  79.     jack_nframes_t                frame_rate;

  80.     jack_nframes_t                frames_per_cycle;

  81.     jack_nframes_t                capture_frame_latency;

  82.     jack_nframes_t                playback_frame_latency;

  83. 

  84.     unsigned long                *silent;

  85.     char                         *alsa_name_playback;

  86.     char                         *alsa_name_capture;

  87.     char                         *alsa_driver;

  88.     bitset_t			  channels_not_done;

  89.     bitset_t			  channels_done;

  90.     snd_pcm_format_t              playback_sample_format;

  91.     snd_pcm_format_t              capture_sample_format;

  92.     float                         max_sample_val;

  93.     unsigned long                 user_nperiods;

  94.     unsigned int                  playback_nperiods;

  95.     unsigned int                  capture_nperiods;

  96.     unsigned long                 last_mask;

  97.     snd_ctl_t                    *ctl_handle;

  98.     snd_pcm_t                    *playback_handle;

  99.     snd_pcm_t                    *capture_handle;

  100.     snd_pcm_hw_params_t          *playback_hw_params;

  101.     snd_pcm_sw_params_t          *playback_sw_params;

  102.     snd_pcm_hw_params_t          *capture_hw_params;

  103.     snd_pcm_sw_params_t          *capture_sw_params;

  104.     jack_hardware_t              *hw;

  105.     ClockSyncStatus              *clock_sync_data;

  106.     jack_client_t                *client;

  107.     JSList                       *capture_ports;

  108.     JSList                       *playback_ports;

  109.     JSList                       *monitor_ports;

  110. 

  111.     unsigned long input_monitor_mask;

  112. 

  113.     char soft_mode;

  114.     char hw_monitoring;

  115.     char hw_metering;

  116.     char all_monitor_in;

  117.     char capture_and_playback_not_synced;

  118.     char playback_interleaved;

  119.     char capture_interleaved;

  120.     char with_monitor_ports;

  121.     char has_clock_sync_reporting;

  122.     char has_hw_monitoring;

  123.     char has_hw_metering;

  124.     char quirk_bswap;

  125. 

  126.     ReadCopyFunction read_via_copy;

  127.     WriteCopyFunction write_via_copy;

  128.     CopyCopyFunction channel_copy;

  129. 

  130.     int             dither;

  131.     dither_state_t *dither_state;

  132. 

  133.     SampleClockMode clock_mode;

  134.     JSList *clock_sync_listeners;

  135.     pthread_mutex_t clock_sync_lock;

  136.     unsigned long next_clock_sync_listener_id;

  137. 

  138.     int running;

  139.     int run;

  140. 

  141.     int poll_late;

  142.     int xrun_count;

  143.     int process_count;

  144. 

  145.     alsa_midi_t *midi;

  146.     int xrun_recovery;

  147. 

  148. }

  149. alsa_driver_t;

  150. 

  151. static inline void

  152. alsa_driver_mark_channel_done (alsa_driver_t *driver, channel_t chn)

  153. {

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

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

  156. }

  157. 

  158. static inline void

  159. alsa_driver_silence_on_channel (alsa_driver_t *driver, channel_t chn,

  160.                                 jack_nframes_t nframes)

  161. {

  162.     if (driver->playback_interleaved) {

  163.         memset_interleave

  164.         (driver->playback_addr[chn],

  165.          0, nframes * driver->playback_sample_bytes,

  166.          driver->interleave_unit,

  167.          driver->playback_interleave_skip[chn]);

  168.     } else {

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

  170.                 nframes * driver->playback_sample_bytes);

  171.     }

  172.     alsa_driver_mark_channel_done (driver, chn);

  173. }

  174. 

  175. static inline void

  176. alsa_driver_silence_on_channel_no_mark (alsa_driver_t *driver, channel_t chn,

  177.                                         jack_nframes_t nframes)

  178. {

  179.     if (driver->playback_interleaved) {

  180.         memset_interleave

  181.         (driver->playback_addr[chn],

  182.          0, nframes * driver->playback_sample_bytes,

  183.          driver->interleave_unit,

  184.          driver->playback_interleave_skip[chn]);

  185.     } else {

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

  187.                 nframes * driver->playback_sample_bytes);

  188.     }

  189. }

  190. 

  191. static inline void

  192. alsa_driver_read_from_channel (alsa_driver_t *driver,

  193.                                channel_t channel,

  194.                                jack_default_audio_sample_t *buf,

  195.                                jack_nframes_t nsamples)

  196. {

  197.     driver->read_via_copy (buf,

  198.                            driver->capture_addr[channel],

  199.                            nsamples,

  200.                            driver->capture_interleave_skip[channel]);

  201. }

  202. 

  203. static inline void

  204. alsa_driver_write_to_channel (alsa_driver_t *driver,

  205.                               channel_t channel,

  206.                               jack_default_audio_sample_t *buf,

  207.                               jack_nframes_t nsamples)

  208. {

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

  210.                             buf,

  211.                             nsamples,

  212.                             driver->playback_interleave_skip[channel],

  213.                             driver->dither_state + channel);

  214.     alsa_driver_mark_channel_done (driver, channel);

  215. }

  216. 

  217. static inline void

  218. alsa_driver_copy_channel (alsa_driver_t *driver,

  219.                           channel_t input_channel,

  220.                           channel_t output_channel,

  221.                           jack_nframes_t nsamples)

  222. {

  223. 

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

  225.                           driver->capture_addr[input_channel],

  226.                           nsamples * driver->playback_sample_bytes,

  227.                           driver->playback_interleave_skip[output_channel],

  228.                           driver->capture_interleave_skip[input_channel]);

  229.     alsa_driver_mark_channel_done (driver, output_channel);

  230. }

  231. 

  232. void  alsa_driver_silence_untouched_channels (alsa_driver_t *driver,

  233.         jack_nframes_t nframes);

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

  235.         ClockSyncStatus status);

  236. int   alsa_driver_listen_for_clock_sync_status (alsa_driver_t *,

  237.         ClockSyncListenerFunction,

  238.         void *arg);

  239. int   alsa_driver_stop_listen_for_clock_sync_status (alsa_driver_t *,

  240.         unsigned int);

  241. void  alsa_driver_clock_sync_notify (alsa_driver_t *, channel_t chn,

  242.                                      ClockSyncStatus);

  243. 

  244. #endif /* __jack_alsa_driver_h__ */