alsa_driver.h
/*
Copyright (C) 2001 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
$Id: alsa_driver.h 945 2006-05-04 15:14:45Z pbd $
*/
#ifndef __jack_alsa_driver_h__
#define __jack_alsa_driver_h__
#include <alsa/asoundlib.h>
#include "bitset.h"
#if __BYTE_ORDER == __LITTLE_ENDIAN
#define IS_LE 0
#define IS_BE 1
#elif __BYTE_ORDER == __BIG_ENDIAN
#define IS_LE 1
#define IS_BE 0
#endif
#define TRUE 1
#define FALSE 0
#include "types.h"
#include "hardware.h"
#include "driver.h"
#include "memops.h"
#include "alsa_midi.h"
#ifdef __cplusplus
extern "C"
{
#endif
typedef void (*ReadCopyFunction) (jack_default_audio_sample_t *dst, char *src,
unsigned long src_bytes,
unsigned long src_skip_bytes);
typedef void (*WriteCopyFunction) (char *dst, jack_default_audio_sample_t *src,
unsigned long src_bytes,
unsigned long dst_skip_bytes,
dither_state_t *state);
typedef struct _alsa_driver {
JACK_DRIVER_NT_DECL
int poll_timeout;
jack_time_t poll_last;
jack_time_t poll_next;
char **playback_addr;
char **capture_addr;
const snd_pcm_channel_area_t *capture_areas;
const snd_pcm_channel_area_t *playback_areas;
struct pollfd *pfd;
unsigned int playback_nfds;
unsigned int capture_nfds;
unsigned long interleave_unit;
unsigned long *capture_interleave_skip;
unsigned long *playback_interleave_skip;
channel_t max_nchannels;
channel_t user_nchannels;
channel_t playback_nchannels;
channel_t capture_nchannels;
unsigned long playback_sample_bytes;
unsigned long capture_sample_bytes;
jack_nframes_t frame_rate;
jack_nframes_t frames_per_cycle;
jack_nframes_t capture_frame_latency;
jack_nframes_t playback_frame_latency;
unsigned long *silent;
char *alsa_name_playback;
char *alsa_name_capture;
char *alsa_driver;
bitset_t channels_not_done;
bitset_t channels_done;
snd_pcm_format_t playback_sample_format;
snd_pcm_format_t capture_sample_format;
float max_sample_val;
unsigned long user_nperiods;
unsigned int playback_nperiods;
unsigned int capture_nperiods;
unsigned long last_mask;
snd_ctl_t *ctl_handle;
snd_pcm_t *playback_handle;
snd_pcm_t *capture_handle;
snd_pcm_hw_params_t *playback_hw_params;
snd_pcm_sw_params_t *playback_sw_params;
snd_pcm_hw_params_t *capture_hw_params;
snd_pcm_sw_params_t *capture_sw_params;
jack_hardware_t *hw;
ClockSyncStatus *clock_sync_data;
jack_client_t *client;
JSList *capture_ports;
JSList *playback_ports;
JSList *monitor_ports;
unsigned long input_monitor_mask;
char soft_mode;
char hw_monitoring;
char hw_metering;
char all_monitor_in;
char capture_and_playback_not_synced;
char playback_interleaved;
char capture_interleaved;
char with_monitor_ports;
char has_clock_sync_reporting;
char has_hw_monitoring;
char has_hw_metering;
char quirk_bswap;
ReadCopyFunction read_via_copy;
WriteCopyFunction write_via_copy;
int dither;
dither_state_t *dither_state;
SampleClockMode clock_mode;
JSList *clock_sync_listeners;
pthread_mutex_t clock_sync_lock;
unsigned long next_clock_sync_listener_id;
int running;
int run;
int poll_late;
int xrun_count;
int process_count;
alsa_midi_t *midi;
int xrun_recovery;
} alsa_driver_t;
static inline void
alsa_driver_mark_channel_done (alsa_driver_t *driver, channel_t chn) {
bitset_remove (driver->channels_not_done, chn);
driver->silent[chn] = 0;
}
static inline void
alsa_driver_silence_on_channel (alsa_driver_t *driver, channel_t chn,
jack_nframes_t nframes) {
if (driver->playback_interleaved) {
memset_interleave
(driver->playback_addr[chn],
0, nframes * driver->playback_sample_bytes,
driver->interleave_unit,
driver->playback_interleave_skip[chn]);
} else {
memset (driver->playback_addr[chn], 0,
nframes * driver->playback_sample_bytes);
}
alsa_driver_mark_channel_done (driver,chn);
}
static inline void
alsa_driver_silence_on_channel_no_mark (alsa_driver_t *driver, channel_t chn,
jack_nframes_t nframes) {
if (driver->playback_interleaved) {
memset_interleave
(driver->playback_addr[chn],
0, nframes * driver->playback_sample_bytes,
driver->interleave_unit,
driver->playback_interleave_skip[chn]);
} else {
memset (driver->playback_addr[chn], 0,
nframes * driver->playback_sample_bytes);
}
}
static inline void
alsa_driver_read_from_channel (alsa_driver_t *driver,
channel_t channel,
jack_default_audio_sample_t *buf,
jack_nframes_t nsamples)
{
driver->read_via_copy (buf,
driver->capture_addr[channel],
nsamples,
driver->capture_interleave_skip[channel]);
}
static inline void
alsa_driver_write_to_channel (alsa_driver_t *driver,
channel_t channel,
jack_default_audio_sample_t *buf,
jack_nframes_t nsamples)
{
driver->write_via_copy (driver->playback_addr[channel],
buf,
nsamples,
driver->playback_interleave_skip[channel],
driver->dither_state+channel);
alsa_driver_mark_channel_done (driver, channel);
}
void alsa_driver_silence_untouched_channels (alsa_driver_t *driver,
jack_nframes_t nframes);
void alsa_driver_set_clock_sync_status (alsa_driver_t *driver, channel_t chn,
ClockSyncStatus status);
int alsa_driver_listen_for_clock_sync_status (alsa_driver_t *,
ClockSyncListenerFunction,
void *arg);
int alsa_driver_stop_listen_for_clock_sync_status (alsa_driver_t *,
unsigned int);
void alsa_driver_clock_sync_notify (alsa_driver_t *, channel_t chn,
ClockSyncStatus);
int
alsa_driver_reset_parameters (alsa_driver_t *driver,
jack_nframes_t frames_per_cycle,
jack_nframes_t user_nperiods,
jack_nframes_t rate);
jack_driver_t *
alsa_driver_new (char *name, char *playback_alsa_device,
char *capture_alsa_device,
jack_client_t *client,
jack_nframes_t frames_per_cycle,
jack_nframes_t user_nperiods,
jack_nframes_t rate,
int hw_monitoring,
int hw_metering,
int capturing,
int playing,
DitherAlgorithm dither,
int soft_mode,
int monitor,
int user_capture_nchnls,
int user_playback_nchnls,
int shorts_first,
jack_nframes_t capture_latency,
jack_nframes_t playback_latency,
alsa_midi_t *midi_driver
);
void
alsa_driver_delete (alsa_driver_t *driver);
int
alsa_driver_start (alsa_driver_t *driver);
int
alsa_driver_stop (alsa_driver_t *driver);
jack_nframes_t
alsa_driver_wait (alsa_driver_t *driver, int extra_fd, int *status, float
*delayed_usecs);
int
alsa_driver_read (alsa_driver_t *driver, jack_nframes_t nframes);
int
alsa_driver_write (alsa_driver_t* driver, jack_nframes_t nframes);
jack_time_t jack_get_microseconds(void);
// Code implemented in JackAlsaDriver.cpp
void ReadInput(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nread);
void MonitorInput();
void ClearOutput();
void WriteOutput(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nwritten);
void SetTime(jack_time_t time);
int Restart();
#ifdef __cplusplus
}
#endif
#endif /* __jack_alsa_driver_h__ */
_jack_hardware
Definition: hardware.h:49
_jack_driver
Definition: driver.h:87
alsa_midi_t
Definition: alsa_midi.h:30
dither_state_t
Definition: memops.h:44
_alsa_driver
Definition: alsa_driver.h:57
_JSList
Definition: linux/alsa/jslist.h:35