alsa_driver.h

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 #include "types.h"
00036 #include "hardware.h"
00037 #include "driver.h"
00038 #include "memops.h"
00039 
00040 #include "alsa_midi.h"
00041 
00042 typedef void (*ReadCopyFunction)  (jack_default_audio_sample_t *dst, char *src,
00043                                    unsigned long src_bytes,
00044                                    unsigned long src_skip_bytes);
00045 typedef void (*WriteCopyFunction) (char *dst, jack_default_audio_sample_t *src,
00046                                    unsigned long src_bytes,
00047                                    unsigned long dst_skip_bytes,
00048                                    dither_state_t *state);
00049 typedef void (*CopyCopyFunction)  (char *dst, char *src,
00050                                    unsigned long src_bytes,
00051                                    unsigned long dst_skip_bytes,
00052                                    unsigned long src_skip_byte);
00053 
00054 typedef struct _alsa_driver {
00055 
00056     JACK_DRIVER_NT_DECL
00057 
00058     int                           poll_timeout;
00059     jack_time_t                   poll_last;
00060     jack_time_t                   poll_next;
00061     char                        **playback_addr;
00062     char                        **capture_addr;
00063     const snd_pcm_channel_area_t *capture_areas;
00064     const snd_pcm_channel_area_t *playback_areas;
00065     struct pollfd                *pfd;
00066     unsigned int                  playback_nfds;
00067     unsigned int                  capture_nfds;
00068     unsigned long                 interleave_unit;
00069     unsigned long                *capture_interleave_skip;
00070     unsigned long                *playback_interleave_skip;
00071     channel_t                     max_nchannels;
00072     channel_t                     user_nchannels;
00073     channel_t                     playback_nchannels;
00074     channel_t                     capture_nchannels;
00075     unsigned long                 playback_sample_bytes;
00076     unsigned long                 capture_sample_bytes;
00077 
00078     jack_nframes_t                frame_rate;
00079     jack_nframes_t                frames_per_cycle;
00080     jack_nframes_t                capture_frame_latency;
00081     jack_nframes_t                playback_frame_latency;
00082 
00083     unsigned long                *silent;
00084     char                         *alsa_name_playback;
00085     char                         *alsa_name_capture;
00086     char                         *alsa_driver;
00087     bitset_t                      channels_not_done;
00088     bitset_t                      channels_done;
00089     snd_pcm_format_t              playback_sample_format;
00090     snd_pcm_format_t              capture_sample_format;
00091     float                         max_sample_val;
00092     unsigned long                 user_nperiods;
00093     unsigned int                  playback_nperiods;
00094     unsigned int                  capture_nperiods;
00095     unsigned long                 last_mask;
00096     snd_ctl_t                    *ctl_handle;
00097     snd_pcm_t                    *playback_handle;
00098     snd_pcm_t                    *capture_handle;
00099     snd_pcm_hw_params_t          *playback_hw_params;
00100     snd_pcm_sw_params_t          *playback_sw_params;
00101     snd_pcm_hw_params_t          *capture_hw_params;
00102     snd_pcm_sw_params_t          *capture_sw_params;
00103     jack_hardware_t              *hw;  
00104     ClockSyncStatus              *clock_sync_data;
00105     jack_client_t                *client;
00106     JSList                       *capture_ports;
00107     JSList                       *playback_ports;
00108     JSList                       *monitor_ports;
00109 
00110     unsigned long input_monitor_mask;
00111 
00112     char soft_mode;
00113     char hw_monitoring;
00114     char hw_metering;
00115     char all_monitor_in;
00116     char capture_and_playback_not_synced;
00117     char playback_interleaved;
00118     char capture_interleaved;
00119     char with_monitor_ports;
00120     char has_clock_sync_reporting;
00121     char has_hw_monitoring;
00122     char has_hw_metering;
00123     char quirk_bswap;
00124 
00125     ReadCopyFunction read_via_copy;
00126     WriteCopyFunction write_via_copy;
00127     CopyCopyFunction channel_copy;
00128 
00129     int             dither;
00130     dither_state_t *dither_state;
00131 
00132     SampleClockMode clock_mode;
00133     JSList *clock_sync_listeners;
00134     pthread_mutex_t clock_sync_lock;
00135     unsigned long next_clock_sync_listener_id;
00136 
00137     int running;
00138     int run;
00139 
00140     int poll_late;
00141     int xrun_count;
00142     int process_count;
00143     
00144     alsa_midi_t *midi;
00145     int xrun_recovery;
00146 
00147 } alsa_driver_t;
00148 
00149 static inline void 
00150 alsa_driver_mark_channel_done (alsa_driver_t *driver, channel_t chn) {
00151         bitset_remove (driver->channels_not_done, chn);
00152         driver->silent[chn] = 0;
00153 }
00154 
00155 static inline void 
00156 alsa_driver_silence_on_channel (alsa_driver_t *driver, channel_t chn,
00157                                 jack_nframes_t nframes) {
00158         if (driver->playback_interleaved) {
00159                 memset_interleave 
00160                         (driver->playback_addr[chn],
00161                          0, nframes * driver->playback_sample_bytes,
00162                          driver->interleave_unit,
00163                          driver->playback_interleave_skip[chn]);
00164         } else {
00165                 memset (driver->playback_addr[chn], 0,
00166                         nframes * driver->playback_sample_bytes);
00167         }
00168         alsa_driver_mark_channel_done (driver,chn);
00169 }
00170 
00171 static inline void 
00172 alsa_driver_silence_on_channel_no_mark (alsa_driver_t *driver, channel_t chn,
00173                                         jack_nframes_t nframes) {
00174         if (driver->playback_interleaved) {
00175                 memset_interleave 
00176                         (driver->playback_addr[chn],
00177                          0, nframes * driver->playback_sample_bytes,
00178                          driver->interleave_unit,
00179                          driver->playback_interleave_skip[chn]);
00180         } else {
00181                 memset (driver->playback_addr[chn], 0,
00182                         nframes * driver->playback_sample_bytes);
00183         }
00184 }
00185 
00186 static inline void 
00187 alsa_driver_read_from_channel (alsa_driver_t *driver,
00188                                channel_t channel,
00189                                jack_default_audio_sample_t *buf,
00190                                jack_nframes_t nsamples)
00191 {
00192         driver->read_via_copy (buf, 
00193                                driver->capture_addr[channel],
00194                                nsamples, 
00195                                driver->capture_interleave_skip[channel]);
00196 }
00197 
00198 static inline void 
00199 alsa_driver_write_to_channel (alsa_driver_t *driver,
00200                               channel_t channel, 
00201                               jack_default_audio_sample_t *buf, 
00202                               jack_nframes_t nsamples)
00203 {
00204         driver->write_via_copy (driver->playback_addr[channel],
00205                                 buf, 
00206                                 nsamples, 
00207                                 driver->playback_interleave_skip[channel],
00208                                 driver->dither_state+channel);
00209         alsa_driver_mark_channel_done (driver, channel);
00210 }
00211 
00212 static inline void 
00213 alsa_driver_copy_channel (alsa_driver_t *driver, 
00214                           channel_t input_channel, 
00215                           channel_t output_channel,
00216                           jack_nframes_t nsamples) {
00217 
00218         driver->channel_copy (driver->playback_addr[output_channel],
00219                               driver->capture_addr[input_channel],
00220                               nsamples * driver->playback_sample_bytes,
00221                               driver->playback_interleave_skip[output_channel],
00222                               driver->capture_interleave_skip[input_channel]);
00223         alsa_driver_mark_channel_done (driver, output_channel);
00224 }
00225 
00226 void  alsa_driver_silence_untouched_channels (alsa_driver_t *driver,
00227                                               jack_nframes_t nframes);
00228 void  alsa_driver_set_clock_sync_status (alsa_driver_t *driver, channel_t chn,
00229                                          ClockSyncStatus status);
00230 int   alsa_driver_listen_for_clock_sync_status (alsa_driver_t *,
00231                                                 ClockSyncListenerFunction,
00232                                                 void *arg);
00233 int   alsa_driver_stop_listen_for_clock_sync_status (alsa_driver_t *,
00234                                                      unsigned int);
00235 void  alsa_driver_clock_sync_notify (alsa_driver_t *, channel_t chn,
00236                                      ClockSyncStatus);
00237 
00238 #endif /* __jack_alsa_driver_h__ */

Generated on Thu Feb 14 11:16:01 2008 for Jackdmp by  doxygen 1.5.1