linux/alsa/alsa_driver.h

   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 #define TRUE 1
  36 #define FALSE 0
  37
  38 #include "types.h"
  39 #include "hardware.h"
  40 #include "driver.h"
  41 #include "memops.h"
  42 #include "alsa_midi.h"
  43
  44 #ifdef __cplusplus
  45 extern "C"
  46 {
  47 #endif
  48
  49 typedef void (*ReadCopyFunction)  (jack_default_audio_sample_t *dst, char *src,
  50                                    unsigned long src_bytes,
  51                                    unsigned long src_skip_bytes);
  52 typedef void (*WriteCopyFunction) (char *dst, jack_default_audio_sample_t *src,
  53                                    unsigned long src_bytes,
  54                                    unsigned long dst_skip_bytes,
  55                                    dither_state_t *state);
  56
  57 typedef struct _alsa_driver {
  58
  59     JACK_DRIVER_NT_DECL
  60
  61     int                           poll_timeout;
  62     jack_time_t                   poll_last;
  63     jack_time_t                   poll_next;
  64     char                        **playback_addr;
  65     char                        **capture_addr;
  66     const snd_pcm_channel_area_t *capture_areas;
  67     const snd_pcm_channel_area_t *playback_areas;
  68     struct pollfd                *pfd;
  69     unsigned int                  playback_nfds;
  70     unsigned int                  capture_nfds;
  71     unsigned long                 interleave_unit;
  72     unsigned long                *capture_interleave_skip;
  73     unsigned long                *playback_interleave_skip;
  74     channel_t                     max_nchannels;
  75     channel_t                     playback_nchannels;
  76     channel_t                     capture_nchannels;
  77     unsigned long                 playback_sample_bytes;
  78     unsigned long                 capture_sample_bytes;
  79
  80     jack_nframes_t                frame_rate;
  81     jack_nframes_t                frames_per_cycle;
  82     jack_nframes_t                capture_frame_latency;
  83     jack_nframes_t                playback_frame_latency;
  84
  85     unsigned long                *silent;
  86     char                         *alsa_name_playback;
  87     char                         *alsa_name_capture;
  88     char                         *alsa_driver;
  89     bitset_t                      channels_not_done;
  90     bitset_t                      channels_done;
  91     snd_pcm_format_t              playback_sample_format;
  92     snd_pcm_format_t              capture_sample_format;
  93     float                         max_sample_val;
  94     unsigned long                 user_nperiods;
  95     unsigned int                  playback_nperiods;
  96     unsigned int                  capture_nperiods;
  97     unsigned long                 last_mask;
  98     snd_ctl_t                    *ctl_handle;
  99     snd_pcm_t                    *playback_handle;
 100     snd_pcm_t                    *capture_handle;
 101     snd_pcm_hw_params_t          *playback_hw_params;
 102     snd_pcm_sw_params_t          *playback_sw_params;
 103     snd_pcm_hw_params_t          *capture_hw_params;
 104     snd_pcm_sw_params_t          *capture_sw_params;
 105     jack_hardware_t              *hw;
 106     ClockSyncStatus              *clock_sync_data;
 107     jack_client_t                *client;
 108     JSList                       *capture_ports;
 109     JSList                       *playback_ports;
 110     JSList                       *monitor_ports;
 111
 112     unsigned long input_monitor_mask;
 113
 114     char soft_mode;
 115     char hw_monitoring;
 116     char hw_metering;
 117     char all_monitor_in;
 118     char capture_and_playback_not_synced;
 119     char playback_interleaved;
 120     char capture_interleaved;
 121     char with_monitor_ports;
 122     char has_clock_sync_reporting;
 123     char has_hw_monitoring;
 124     char has_hw_metering;
 125     char quirk_bswap;
 126
 127     ReadCopyFunction read_via_copy;
 128     WriteCopyFunction write_via_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 } alsa_driver_t;
 149
 150 static inline void
 151 alsa_driver_mark_channel_done (alsa_driver_t *driver, channel_t chn) {
 152         bitset_remove (driver->channels_not_done, chn);
 153         driver->silent[chn] = 0;
 154 }
 155
 156 static inline void
 157 alsa_driver_silence_on_channel (alsa_driver_t *driver, channel_t chn,
 158                                 jack_nframes_t nframes) {
 159         if (driver->playback_interleaved) {
 160                 memset_interleave
 161                         (driver->playback_addr[chn],
 162                          0, nframes * driver->playback_sample_bytes,
 163                          driver->interleave_unit,
 164                          driver->playback_interleave_skip[chn]);
 165         } else {
 166                 memset (driver->playback_addr[chn], 0,
 167                         nframes * driver->playback_sample_bytes);
 168         }
 169         alsa_driver_mark_channel_done (driver,chn);
 170 }
 171
 172 static inline void
 173 alsa_driver_silence_on_channel_no_mark (alsa_driver_t *driver, channel_t chn,
 174                                         jack_nframes_t nframes) {
 175         if (driver->playback_interleaved) {
 176                 memset_interleave
 177                         (driver->playback_addr[chn],
 178                          0, nframes * driver->playback_sample_bytes,
 179                          driver->interleave_unit,
 180                          driver->playback_interleave_skip[chn]);
 181         } else {
 182                 memset (driver->playback_addr[chn], 0,
 183                         nframes * driver->playback_sample_bytes);
 184         }
 185 }
 186
 187 static inline void
 188 alsa_driver_read_from_channel (alsa_driver_t *driver,
 189                                channel_t channel,
 190                                jack_default_audio_sample_t *buf,
 191                                jack_nframes_t nsamples)
 192 {
 193         driver->read_via_copy (buf,
 194                                driver->capture_addr[channel],
 195                                nsamples,
 196                                driver->capture_interleave_skip[channel]);
 197 }
 198
 199 static inline void
 200 alsa_driver_write_to_channel (alsa_driver_t *driver,
 201                               channel_t channel,
 202                               jack_default_audio_sample_t *buf,
 203                               jack_nframes_t nsamples)
 204 {
 205         driver->write_via_copy (driver->playback_addr[channel],
 206                                 buf,
 207                                 nsamples,
 208                                 driver->playback_interleave_skip[channel],
 209                                 driver->dither_state+channel);
 210         alsa_driver_mark_channel_done (driver, channel);
 211 }
 212
 213 void  alsa_driver_silence_untouched_channels (alsa_driver_t *driver,
 214                                               jack_nframes_t nframes);
 215 void  alsa_driver_set_clock_sync_status (alsa_driver_t *driver, channel_t chn,
 216                                          ClockSyncStatus status);
 217 int   alsa_driver_listen_for_clock_sync_status (alsa_driver_t *,
 218                                                 ClockSyncListenerFunction,
 219                                                 void *arg);
 220 int   alsa_driver_stop_listen_for_clock_sync_status (alsa_driver_t *,
 221                                                      unsigned int);
 222 void  alsa_driver_clock_sync_notify (alsa_driver_t *, channel_t chn,
 223                                      ClockSyncStatus);
 224
 225 int
 226 alsa_driver_reset_parameters (alsa_driver_t *driver,
 227                               jack_nframes_t frames_per_cycle,
 228                               jack_nframes_t user_nperiods,
 229                               jack_nframes_t rate);
 230
 231 jack_driver_t *
 232 alsa_driver_new (char *name, char *playback_alsa_device,
 233                  char *capture_alsa_device,
 234                  jack_client_t *client,
 235                  jack_nframes_t frames_per_cycle,
 236                  jack_nframes_t user_nperiods,
 237                  jack_nframes_t rate,
 238                  int hw_monitoring,
 239                  int hw_metering,
 240                  int capturing,
 241                  int playing,
 242                  DitherAlgorithm dither,
 243                  int soft_mode,
 244                  int monitor,
 245                  int user_capture_nchnls,
 246                  int user_playback_nchnls,
 247                  int shorts_first,
 248                  jack_nframes_t capture_latency,
 249                  jack_nframes_t playback_latency,
 250                  alsa_midi_t *midi_driver
 251                  );
 252 void
 253 alsa_driver_delete (alsa_driver_t *driver);
 254
 255 int
 256 alsa_driver_start (alsa_driver_t *driver);
 257
 258 int
 259 alsa_driver_stop (alsa_driver_t *driver);
 260
 261 jack_nframes_t
 262 alsa_driver_wait (alsa_driver_t *driver, int extra_fd, int *status, float
 263                   *delayed_usecs);
 264
 265 int
 266 alsa_driver_read (alsa_driver_t *driver, jack_nframes_t nframes);
 267
 268 int
 269 alsa_driver_write (alsa_driver_t* driver, jack_nframes_t nframes);
 270
 271 jack_time_t jack_get_microseconds(void);
 272
 273 // Code implemented in JackAlsaDriver.cpp
 274
 275 void ReadInput(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nread);
 276 void MonitorInput();
 277 void ClearOutput();
 278 void WriteOutput(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nwritten);
 279 void SetTime(jack_time_t time);
 280 int Restart();
 281
 282 #ifdef __cplusplus
 283 }
 284 #endif
 285
 286
 287 #endif /* __jack_alsa_driver_h__ */