Jack2: alsa_driver.h Source File

00001 /*
00002     Copyright (C) 2001 Paul Davis
00003 
00004     This program is free software; you can redistribute it and/or modify
00005     it under the terms of the GNU General Public License as published by
00006     the Free Software Foundation; either version 2 of the License, or
00007     (at your option) any later version.
00008 
00009     This program is distributed in the hope that it will be useful,
00010     but WITHOUT ANY WARRANTY; without even the implied warranty of
00011     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012     GNU General Public License for more details.
00013 
00014     You should have received a copy of the GNU General Public License
00015     along with this program; if not, write to the Free Software
00016     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00017 
00018     $Id: alsa_driver.h 945 2006-05-04 15:14:45Z pbd $
00019 */
00020 
00021 #ifndef __jack_alsa_driver_h__
00022 #define __jack_alsa_driver_h__
00023 
00024 #include <alsa/asoundlib.h>
00025 #include "bitset.h"
00026 
00027 #if __BYTE_ORDER == __LITTLE_ENDIAN
00028 #define IS_LE 0
00029 #define IS_BE 1
00030 #elif __BYTE_ORDER == __BIG_ENDIAN
00031 #define IS_LE 1
00032 #define IS_BE 0
00033 #endif
00034 
00035 #define TRUE 1
00036 #define FALSE 0
00037 
00038 #include "types.h"
00039 #include "hardware.h"
00040 #include "driver.h"
00041 #include "memops.h"
00042 #include "alsa_midi.h"
00043 
00044 #ifdef __cplusplus
00045 extern "C"
00046 {
00047 #endif
00048 
00049 typedef void (*ReadCopyFunction)  (jack_default_audio_sample_t *dst, char *src,
00050                                    unsigned long src_bytes,
00051                                    unsigned long src_skip_bytes);
00052 typedef void (*WriteCopyFunction) (char *dst, jack_default_audio_sample_t *src,
00053                                    unsigned long src_bytes,
00054                                    unsigned long dst_skip_bytes,
00055                                    dither_state_t *state);
00056 
00057 typedef struct _alsa_driver {
00058 
00059     JACK_DRIVER_NT_DECL
00060 
00061     int                           poll_timeout;
00062     jack_time_t                   poll_last;
00063     jack_time_t                   poll_next;
00064     char                        **playback_addr;
00065     char                        **capture_addr;
00066     const snd_pcm_channel_area_t *capture_areas;
00067     const snd_pcm_channel_area_t *playback_areas;
00068     struct pollfd                *pfd;
00069     unsigned int                  playback_nfds;
00070     unsigned int                  capture_nfds;
00071     unsigned long                 interleave_unit;
00072     unsigned long                *capture_interleave_skip;
00073     unsigned long                *playback_interleave_skip;
00074     channel_t                     max_nchannels;
00075     channel_t                     user_nchannels;
00076     channel_t                     playback_nchannels;
00077     channel_t                     capture_nchannels;
00078     unsigned long                 playback_sample_bytes;
00079     unsigned long                 capture_sample_bytes;
00080 
00081     jack_nframes_t                frame_rate;
00082     jack_nframes_t                frames_per_cycle;
00083     jack_nframes_t                capture_frame_latency;
00084     jack_nframes_t                playback_frame_latency;
00085 
00086     unsigned long                *silent;
00087     char                         *alsa_name_playback;
00088     char                         *alsa_name_capture;
00089     char                         *alsa_driver;
00090     bitset_t                      channels_not_done;
00091     bitset_t                      channels_done;
00092     snd_pcm_format_t              playback_sample_format;
00093     snd_pcm_format_t              capture_sample_format;
00094     float                         max_sample_val;
00095     unsigned long                 user_nperiods;
00096     unsigned int                  playback_nperiods;
00097     unsigned int                  capture_nperiods;
00098     unsigned long                 last_mask;
00099     snd_ctl_t                    *ctl_handle;
00100     snd_pcm_t                    *playback_handle;
00101     snd_pcm_t                    *capture_handle;
00102     snd_pcm_hw_params_t          *playback_hw_params;
00103     snd_pcm_sw_params_t          *playback_sw_params;
00104     snd_pcm_hw_params_t          *capture_hw_params;
00105     snd_pcm_sw_params_t          *capture_sw_params;
00106     jack_hardware_t              *hw;
00107     ClockSyncStatus              *clock_sync_data;
00108     jack_client_t                *client;
00109     JSList                       *capture_ports;
00110     JSList                       *playback_ports;
00111     JSList                       *monitor_ports;
00112 
00113     unsigned long input_monitor_mask;
00114 
00115     char soft_mode;
00116     char hw_monitoring;
00117     char hw_metering;
00118     char all_monitor_in;
00119     char capture_and_playback_not_synced;
00120     char playback_interleaved;
00121     char capture_interleaved;
00122     char with_monitor_ports;
00123     char has_clock_sync_reporting;
00124     char has_hw_monitoring;
00125     char has_hw_metering;
00126     char quirk_bswap;
00127 
00128     ReadCopyFunction read_via_copy;
00129     WriteCopyFunction write_via_copy;
00130 
00131     int             dither;
00132     dither_state_t *dither_state;
00133 
00134     SampleClockMode clock_mode;
00135     JSList *clock_sync_listeners;
00136     pthread_mutex_t clock_sync_lock;
00137     unsigned long next_clock_sync_listener_id;
00138 
00139     int running;
00140     int run;
00141 
00142     int poll_late;
00143     int xrun_count;
00144     int process_count;
00145 
00146     alsa_midi_t *midi;
00147     int xrun_recovery;
00148 
00149 } alsa_driver_t;
00150 
00151 static inline void
00152 alsa_driver_mark_channel_done (alsa_driver_t *driver, channel_t chn) {
00153         bitset_remove (driver->channels_not_done, chn);
00154         driver->silent[chn] = 0;
00155 }
00156 
00157 static inline void
00158 alsa_driver_silence_on_channel (alsa_driver_t *driver, channel_t chn,
00159                                 jack_nframes_t nframes) {
00160         if (driver->playback_interleaved) {
00161                 memset_interleave
00162                         (driver->playback_addr[chn],
00163                          0, nframes * driver->playback_sample_bytes,
00164                          driver->interleave_unit,
00165                          driver->playback_interleave_skip[chn]);
00166         } else {
00167                 memset (driver->playback_addr[chn], 0,
00168                         nframes * driver->playback_sample_bytes);
00169         }
00170         alsa_driver_mark_channel_done (driver,chn);
00171 }
00172 
00173 static inline void
00174 alsa_driver_silence_on_channel_no_mark (alsa_driver_t *driver, channel_t chn,
00175                                         jack_nframes_t nframes) {
00176         if (driver->playback_interleaved) {
00177                 memset_interleave
00178                         (driver->playback_addr[chn],
00179                          0, nframes * driver->playback_sample_bytes,
00180                          driver->interleave_unit,
00181                          driver->playback_interleave_skip[chn]);
00182         } else {
00183                 memset (driver->playback_addr[chn], 0,
00184                         nframes * driver->playback_sample_bytes);
00185         }
00186 }
00187 
00188 static inline void
00189 alsa_driver_read_from_channel (alsa_driver_t *driver,
00190                                channel_t channel,
00191                                jack_default_audio_sample_t *buf,
00192                                jack_nframes_t nsamples)
00193 {
00194         driver->read_via_copy (buf,
00195                                driver->capture_addr[channel],
00196                                nsamples,
00197                                driver->capture_interleave_skip[channel]);
00198 }
00199 
00200 static inline void
00201 alsa_driver_write_to_channel (alsa_driver_t *driver,
00202                               channel_t channel,
00203                               jack_default_audio_sample_t *buf,
00204                               jack_nframes_t nsamples)
00205 {
00206         driver->write_via_copy (driver->playback_addr[channel],
00207                                 buf,
00208                                 nsamples,
00209                                 driver->playback_interleave_skip[channel],
00210                                 driver->dither_state+channel);
00211         alsa_driver_mark_channel_done (driver, channel);
00212 }
00213 
00214 void  alsa_driver_silence_untouched_channels (alsa_driver_t *driver,
00215                                               jack_nframes_t nframes);
00216 void  alsa_driver_set_clock_sync_status (alsa_driver_t *driver, channel_t chn,
00217                                          ClockSyncStatus status);
00218 int   alsa_driver_listen_for_clock_sync_status (alsa_driver_t *,
00219                                                 ClockSyncListenerFunction,
00220                                                 void *arg);
00221 int   alsa_driver_stop_listen_for_clock_sync_status (alsa_driver_t *,
00222                                                      unsigned int);
00223 void  alsa_driver_clock_sync_notify (alsa_driver_t *, channel_t chn,
00224                                      ClockSyncStatus);
00225 
00226 int
00227 alsa_driver_reset_parameters (alsa_driver_t *driver,
00228                               jack_nframes_t frames_per_cycle,
00229                               jack_nframes_t user_nperiods,
00230                               jack_nframes_t rate);
00231 
00232 jack_driver_t *
00233 alsa_driver_new (char *name, char *playback_alsa_device,
00234                  char *capture_alsa_device,
00235                  jack_client_t *client,
00236                  jack_nframes_t frames_per_cycle,
00237                  jack_nframes_t user_nperiods,
00238                  jack_nframes_t rate,
00239                  int hw_monitoring,
00240                  int hw_metering,
00241                  int capturing,
00242                  int playing,
00243                  DitherAlgorithm dither,
00244                  int soft_mode,
00245                  int monitor,
00246                  int user_capture_nchnls,
00247                  int user_playback_nchnls,
00248                  int shorts_first,
00249                  jack_nframes_t capture_latency,
00250                  jack_nframes_t playback_latency,
00251                  alsa_midi_t *midi_driver
00252                  );
00253 void
00254 alsa_driver_delete (alsa_driver_t *driver);
00255 
00256 int
00257 alsa_driver_start (alsa_driver_t *driver);
00258 
00259 int
00260 alsa_driver_stop (alsa_driver_t *driver);
00261 
00262 jack_nframes_t
00263 alsa_driver_wait (alsa_driver_t *driver, int extra_fd, int *status, float
00264                   *delayed_usecs);
00265 
00266 int
00267 alsa_driver_read (alsa_driver_t *driver, jack_nframes_t nframes);
00268 
00269 int
00270 alsa_driver_write (alsa_driver_t* driver, jack_nframes_t nframes);
00271 
00272 jack_time_t jack_get_microseconds(void);
00273 
00274 // Code implemented in JackAlsaDriver.cpp
00275 
00276 void ReadInput(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nread);
00277 void MonitorInput();
00278 void ClearOutput();
00279 void WriteOutput(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nwritten);
00280 void SetTime(jack_time_t time);
00281 int Restart();
00282 
00283 #ifdef __cplusplus
00284 }
00285 #endif
00286 
00287 
00288 #endif /* __jack_alsa_driver_h__ */