This commit was generated by cvs2svn to compensate for changes in r58,

which included commits to RCS files with non-trunk default branches.

svn path=/trunk/; revision=59

1 files changed, 3072 insertions, 0 deletions

diff --git a/pd/src/s_freebsd.c b/pd/src/s_freebsd.c
new file mode 100644
index 00000000..4ed4241b
--- /dev/null
+++ b/pd/src/s_freebsd.c
@@ -0,0 +1,3072 @@
+/* Copyright (c) 1997-1999 Guenter Geiger, Miller Puckette, Larry Troxler,
+* Winfried Ritsch, Karl MacMillan, and others.
+* For information on usage and redistribution, and for a DISCLAIMER OF ALL
+* WARRANTIES, see the file, "LICENSE.txt," in this distribution.  */
+
+/* this file implements the sys_ functions profiled in m_imp.h for
+ audio and MIDI I/O.  In Linux there might be several APIs for doing the
+ audio part; right now there are three (OSS, ALSA, RME); the third is
+ for the RME 9652 driver by Ritsch (but not for the OSS compatible
+ one by Geiger; for that one, OSS should work.)
+
+ FUNCTION PREFIXES.
+    sys_ -- functions which must be exported to Pd on all platforms
+    linux_ -- linux-specific objects which don't depend on API,
+    	mostly static but some exported.
+    oss_, alsa_, rme_ -- API-specific functions, all of which are
+    	static.
+
+ ALSA SUPPORT.  If ALSA99 is defined we support ALSA 0.5x; if ALSA01,
+    ALSA 0.9x.  (the naming scheme reflects the possibility of further API
+    changes in the future...) We define "ALSA" for code relevant to both
+    APIs.
+
+ For MIDI, we only offer the OSS API; ALSA has to emulate OSS for us.
+*/
+
+/* OSS include (whether we're doing OSS audio or not we need this for MIDI) */
+
+
+/* IOhannes:::
+ * hacked this to add advanced multidevice-support
+ * 1311:forum::für::umläute:2001
+ */
+
+#include <sys/soundcard.h>
+
+#if (defined(ALSA01) || defined(ALSA99))
+#define ALSA
+#endif
+
+#ifdef ALSA99
+#include <sys/asoundlib.h>
+#endif
+#ifdef ALSA01
+#include <alsa/asoundlib.h>
+#endif
+
+#include "m_imp.h"
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <sched.h>
+#include <sys/mman.h>
+
+/* local function prototypes */
+
+static void linux_close_midi( void);
+
+static int oss_open_audio(int naudioindev, int *audioindev, int nchindev,
+    int *chindev, int naudiooutdev, int *audiooutdev, int nchoutdev,
+    int *choutdev, int rate); /* IOhannes */
+
+static void oss_close_audio(void);
+static int oss_send_dacs(void);
+static void oss_reportidle(void);
+
+#ifdef ALSA
+typedef int16_t t_alsa_sample16;
+typedef int32_t t_alsa_sample32;
+#define ALSA_SAMPLEWIDTH_16 sizeof(t_alsa_sample16)
+#define ALSA_SAMPLEWIDTH_32 sizeof(t_alsa_sample32)
+#define ALSA_XFERSIZE16  (signed int)(sizeof(t_alsa_sample16) * DACBLKSIZE)
+#define ALSA_XFERSIZE32  (signed int)(sizeof(t_alsa_sample32) * DACBLKSIZE)
+#define ALSA_MAXDEV 1
+#define ALSA_JITTER 1024
+#define ALSA_EXTRABUFFER 2048
+#define ALSA_DEFFRAGSIZE 64
+#define ALSA_DEFNFRAG 12
+
+#ifdef ALSA99
+typedef struct _alsa_dev
+{
+    snd_pcm_t *handle;
+    snd_pcm_channel_info_t info;
+    snd_pcm_channel_setup_t setup;
+} t_alsa_dev;
+
+t_alsa_dev alsa_device[ALSA_MAXDEV];
+static int n_alsa_dev;
+static char *alsa_buf;
+static int alsa_samplewidth;
+#endif /* ALSA99 */
+
+#ifdef ALSA01
+typedef struct _alsa_dev
+{
+    snd_pcm_t *inhandle;
+    snd_pcm_t *outhandle;
+} t_alsa_dev;
+
+t_alsa_dev alsa_device;
+static short *alsa_buf;
+static int alsa_samplewidth;
+static snd_pcm_status_t* in_status;
+static snd_pcm_status_t* out_status;
+#endif /* ALSA01 */
+
+#if 0    /* early alsa 0.9 beta dists had different names for these: */
+#define SND_PCM_ACCESS_RW_INTERLEAVED SNDRV_PCM_ACCESS_RW_INTERLEAVED
+#define SND_PCM_FORMAT_S32            SNDRV_PCM_FORMAT_S32
+#define SND_PCM_FORMAT_S16            SNDRV_PCM_FORMAT_S16
+#define SND_PCM_SUBFORMAT_STD         SNDRV_PCM_SUBFORMAT_STD
+#endif
+
+static int alsa_mode;
+static int alsa_open_audio(int inchans, int outchans, int rate);
+static void alsa_close_audio(void);
+static int alsa_send_dacs(void);
+static void alsa_set_params(t_alsa_dev *dev, int dir, int rate, int voices);
+static void alsa_reportidle(void);
+#endif /* ALSA */
+
+#ifdef RME_HAMMERFALL
+static int rme9652_open_audio(int inchans, int outchans, int rate);
+static void rme9652_close_audio(void);
+static int rme9652_send_dacs(void);
+static void rme9652_reportidle(void);
+#endif /* RME_HAMMERFALL */
+
+/* Defines */
+#define DEBUG(x) x
+#define DEBUG2(x) {x;}
+
+#define OSS_MAXCHPERDEV 32	/* max channels per OSS device */
+#define OSS_MAXDEV 4    	/* maximum number of input or output devices */
+#define OSS_DEFFRAGSIZE 256 	/* default log fragment size (frames) */
+#define OSS_DEFAUDIOBUF 40000   /* default audiobuffer, microseconds */
+#define OSS_DEFAULTCH 2
+#define RME_DEFAULTCH 8     /* need this even if RME undefined */
+typedef int16_t t_oss_int16;
+typedef int32_t t_oss_int32;
+#define OSS_MAXSAMPLEWIDTH sizeof(t_oss_int32)
+#define OSS_BYTESPERCHAN(width) (DACBLKSIZE * (width)) 
+#define OSS_XFERSAMPS(chans) (DACBLKSIZE* (chans))
+#define OSS_XFERSIZE(chans, width) (DACBLKSIZE * (chans) * (width))
+
+#ifdef RME_HAMMERFALL
+typedef int32_t t_rme_sample;
+#define RME_SAMPLEWIDTH sizeof(t_rme_sample)
+#define RME_BYTESPERCHAN (DACBLKSIZE * RME_SAMPLEWIDTH)
+#endif /* RME_HAMMERFALL */
+
+/* GLOBALS */
+static int linux_whichapi = API_OSS;
+static int linux_inchannels;
+static int linux_outchannels;
+static int linux_advance_samples; /* scheduler advance in samples */
+static int linux_meters;    	/* true if we're metering */
+static float linux_inmax;    	/* max input amplitude */
+static float linux_outmax;    	/* max output amplitude */
+static int linux_fragsize = 0;	/* for block mode; block size (sample frames) */
+static int linux_nfragment = 0; /* ... and number of blocks. */
+
+#ifdef ALSA99
+static int alsa_devno = 1;
+#endif
+#ifdef ALSA01
+static char alsa_devname[512] = "hw:0,0";
+static int alsa_use_plugin = 0;
+#endif
+
+/* our device handles */
+
+typedef struct _oss_dev
+{
+    int d_fd;
+    unsigned int d_space;   /* bytes available for writing/reading  */
+    int d_bufsize;  	    /* total buffer size in blocks for this device */
+    int d_dropcount;  	    /* # of buffers to drop for resync (output only) */
+    unsigned int d_nchannels;	/* number of channels for this device */
+    unsigned int d_bytespersamp; /* bytes per sample (2 for 16 bit, 4 for 32) */
+} t_oss_dev;
+
+static t_oss_dev linux_dacs[OSS_MAXDEV];
+static t_oss_dev linux_adcs[OSS_MAXDEV];
+static int linux_noutdevs = 0;
+static int linux_nindevs = 0;
+
+    /* exported variables */
+int sys_schedadvance = OSS_DEFAUDIOBUF;   /* scheduler advance in microsecs */
+float sys_dacsr;
+int sys_hipriority = 0;
+t_sample *sys_soundout;
+t_sample *sys_soundin;
+
+    /* OSS-specific private variables */
+static int oss_blockmode = 1;	/* flag to use "blockmode"  */
+static char ossdsp[] = "/dev/dsp%d"; 
+
+#ifndef INT32_MAX
+#define INT32_MAX 0x7fffffff
+#endif
+#define CLIP32(x) (((x)>INT32_MAX)?INT32_MAX:((x) < -INT32_MAX)?-INT32_MAX:(x))
+
+
+/* ------------- private routines for all APIS ------------------- */
+
+static void linux_flush_all_underflows_to_zero(void)
+{
+/*
+    TODO: Implement similar thing for linux (GGeiger) 
+
+    One day we will figure this out, I hope, because it 
+    costs CPU time dearly on Intel  - LT
+  */
+     /*    union fpc_csr f;
+	   f.fc_word = get_fpc_csr();
+	   f.fc_struct.flush = 1;
+	   set_fpc_csr(f.fc_word);
+     */
+}
+
+    /* set sample rate and channels.  Must set sample rate before "configuring"
+    any devices so we know scheduler advance in samples.  */
+
+static void linux_setsr(int sr)
+{
+    sys_dacsr = sr;
+    linux_advance_samples = (sys_schedadvance * sys_dacsr) / (1000000.);
+    if (linux_advance_samples < 3 * DACBLKSIZE)
+    	linux_advance_samples = 3 * DACBLKSIZE;
+}
+
+static void linux_setch(int chin, int chout)
+{
+    int nblk;
+    int inbytes = chin * (DACBLKSIZE*sizeof(float));
+    int outbytes = chout * (DACBLKSIZE*sizeof(float));
+
+    linux_inchannels = chin;
+    linux_outchannels = chout;
+    if (sys_soundin)
+    	free(sys_soundin);
+    sys_soundin = (t_float *)malloc(inbytes);
+    memset(sys_soundin, 0, inbytes);
+
+    if (sys_soundout)
+    	free(sys_soundout);
+    sys_soundout = (t_float *)malloc(outbytes);
+    memset(sys_soundout, 0, outbytes);
+
+    if (sys_verbose)
+    	post("input channels = %d, output channels = %d",
+    	    linux_inchannels, linux_outchannels);
+}
+
+/* ---------------- MIDI routines -------------------------- */
+
+static int oss_nmidiin;
+static int oss_midiinfd[MAXMIDIINDEV];
+static int oss_nmidiout;
+static int oss_midioutfd[MAXMIDIOUTDEV];
+
+static void oss_midiout(int fd, int n)
+{
+    char b = n;
+    if ((write(fd, (char *) &b, 1)) != 1)
+    	perror("midi write");
+}
+
+#define O_MIDIFLAG O_NDELAY
+
+void linux_open_midi(int nmidiin, int *midiinvec, int nmidiout, int *midioutvec)
+{
+    int i;
+    for (i = 0; i < nmidiout; i++)
+    	oss_midioutfd[i] = -1;
+    for (i = 0, oss_nmidiin = 0; i < nmidiin; i++)
+    {
+    	int fd = -1, j, outdevindex = -1;
+	char namebuf[80];
+	int devno = midiinvec[i];
+	
+	for (j = 0; j < nmidiout; j++)
+	    if (midioutvec[j] == midiinvec[i])
+	    	outdevindex = j;
+	
+	    /* try to open the device for read/write. */
+	if (devno == 1 && fd < 0 && outdevindex >= 0)
+	{
+    	    sys_setalarm(1000000);
+	    fd = open("/dev/midi", O_RDWR | O_MIDIFLAG);
+	    if (sys_verbose)
+	    	fprintf(stderr,
+		    "device 1: tried /dev/midi READ/WRITE; returned %d\n", fd);
+	    if (outdevindex >= 0 && fd >= 0)
+	    	oss_midioutfd[outdevindex] = fd;
+	}
+    	if (fd < 0 && outdevindex >= 0)
+	{
+    	    sys_setalarm(1000000);
+	    sprintf(namebuf, "/dev/midi%2.2d", devno-1);
+	    fd = open(namebuf, O_RDWR | O_MIDIFLAG);
+	    if (sys_verbose)
+	    	fprintf(stderr,
+		    "device %d: tried %s READ/WRITE; returned %d\n",
+		    	devno, namebuf, fd);
+	    if (outdevindex >= 0 && fd >= 0)
+	    	oss_midioutfd[outdevindex] = fd;
+	}
+    	if (fd < 0 && outdevindex >= 0)
+	{
+    	    sys_setalarm(1000000);
+	    sprintf(namebuf, "/dev/midi%d", devno-1);
+	    fd = open(namebuf, O_RDWR | O_MIDIFLAG);
+	    if (sys_verbose)
+	    	fprintf(stderr, "device %d: tried %s READ/WRITE; returned %d\n",
+		    devno, namebuf, fd);
+	    if (outdevindex >= 0 && fd >= 0)
+	    	oss_midioutfd[outdevindex] = fd;
+	}
+	if (devno == 1 && fd < 0)
+	{
+    	    sys_setalarm(1000000);
+	    fd = open("/dev/midi", O_RDONLY | O_MIDIFLAG);
+	    if (sys_verbose)
+	    	fprintf(stderr,
+		    "device 1: tried /dev/midi READONLY; returned %d\n", fd);
+	}
+    	if (fd < 0)
+	{
+    	    sys_setalarm(1000000);
+	    sprintf(namebuf, "/dev/midi%2.2d", devno-1);
+	    fd = open(namebuf, O_RDONLY | O_MIDIFLAG);
+	    if (sys_verbose)
+	    	fprintf(stderr, "device %d: tried %s READONLY; returned %d\n",
+		    devno, namebuf, fd);
+	}
+    	if (fd < 0)
+	{
+    	    sys_setalarm(1000000);
+	    sprintf(namebuf, "/dev/midi%d", devno-1);
+	    fd = open(namebuf, O_RDONLY | O_MIDIFLAG);
+	    if (sys_verbose)
+	    	fprintf(stderr, "device %d: tried %s READONLY; returned %d\n",
+		    devno, namebuf, fd);
+	}
+	if (fd >= 0)
+	    oss_midiinfd[oss_nmidiin++] = fd;	    
+	else post("couldn't open MIDI input device %d", devno);
+    }
+    for (i = 0, oss_nmidiout = 0; i < nmidiout; i++)
+    {
+    	int fd = oss_midioutfd[i];
+	char namebuf[80];
+	int devno = midioutvec[i];
+	if (devno == 1 && fd < 0)
+	{
+    	    sys_setalarm(1000000);
+	    fd = open("/dev/midi", O_WRONLY | O_MIDIFLAG);
+	    if (sys_verbose)
+	    	fprintf(stderr,
+		    "device 1: tried /dev/midi WRITEONLY; returned %d\n", fd);
+	}
+    	if (fd < 0)
+	{
+    	    sys_setalarm(1000000);
+	    sprintf(namebuf, "/dev/midi%2.2d", devno-1);
+	    fd = open(namebuf, O_WRONLY | O_MIDIFLAG);
+	    if (sys_verbose)
+	    	fprintf(stderr, "device %d: tried %s WRITEONLY; returned %d\n",
+		    devno, namebuf, fd);
+	}
+    	if (fd < 0)
+	{
+    	    sys_setalarm(1000000);
+	    sprintf(namebuf, "/dev/midi%d", devno-1);
+	    fd = open(namebuf, O_WRONLY | O_MIDIFLAG);
+	    if (sys_verbose)
+	    	fprintf(stderr, "device %d: tried %s WRITEONLY; returned %d\n",
+		    devno, namebuf, fd);
+	}
+	if (fd >= 0)
+	    oss_midioutfd[oss_nmidiout++] = fd;	    
+	else post("couldn't open MIDI output device %d", devno);
+    }
+
+    if (oss_nmidiin < nmidiin || oss_nmidiout < nmidiout || sys_verbose)
+    	post("opened %d MIDI input device(s) and %d MIDI output device(s).",
+	    oss_nmidiin, oss_nmidiout);
+}
+
+#define md_msglen(x) (((x)<0xC0)?2:((x)<0xE0)?1:((x)<0xF0)?2:\
+    ((x)==0xF2)?2:((x)<0xF4)?1:0)
+
+void sys_putmidimess(int portno, int a, int b, int c)
+{
+    if (portno >= 0 && portno < oss_nmidiout)
+    {
+       switch (md_msglen(a))
+       {
+       case 2:
+	    oss_midiout(oss_midioutfd[portno],a);	 
+	    oss_midiout(oss_midioutfd[portno],b);	 
+	    oss_midiout(oss_midioutfd[portno],c);
+	    return;
+       case 1:
+	    oss_midiout(oss_midioutfd[portno],a);	 
+	    oss_midiout(oss_midioutfd[portno],b);	 
+	    return;
+       case 0:
+	    oss_midiout(oss_midioutfd[portno],a);	 
+	    return;
+       };
+    }
+}
+
+void sys_putmidibyte(int portno, int byte)
+{
+    if (portno >= 0 && portno < oss_nmidiout)
+    	oss_midiout(oss_midioutfd[portno], byte);	
+}
+
+#if 0	/* this is the "select" version which doesn't work with OSS
+    	driver for emu10k1 (it doesn't implement select.) */
+void sys_poll_midi(void)
+{
+    int i, throttle = 100;
+    struct timeval timout;
+    int did = 1, maxfd = 0;
+    while (did)
+    {
+	fd_set readset, writeset, exceptset;
+    	did = 0;
+	if (throttle-- < 0)
+	    break;
+	timout.tv_sec = 0;
+	timout.tv_usec = 0;
+
+	FD_ZERO(&writeset);
+	FD_ZERO(&readset);
+	FD_ZERO(&exceptset);
+	for (i = 0; i < oss_nmidiin; i++)
+	{
+	    if (oss_midiinfd[i] > maxfd)
+	    	maxfd = oss_midiinfd[i];
+    	    FD_SET(oss_midiinfd[i], &readset);
+	}
+	select(maxfd+1, &readset, &writeset, &exceptset, &timout);
+	for (i = 0; i < oss_nmidiin; i++)
+    	    if (FD_ISSET(oss_midiinfd[i], &readset))
+	{
+	    char c;
+	    int ret = read(oss_midiinfd[i], &c, 1);
+    	    if (ret <= 0)
+	    	fprintf(stderr, "Midi read error\n");
+    	    else sys_midibytein(i, (c & 0xff));
+	    did = 1;
+	}
+    }
+}
+#else 
+
+    /* this version uses the asynchronous "read()" ... */
+void sys_poll_midi(void)
+{
+    int i, throttle = 100;
+    struct timeval timout;
+    int did = 1, maxfd = 0;
+    while (did)
+    {
+	fd_set readset, writeset, exceptset;
+    	did = 0;
+	if (throttle-- < 0)
+	    break;
+	for (i = 0; i < oss_nmidiin; i++)
+	{
+	    char c;
+	    int ret = read(oss_midiinfd[i], &c, 1);
+    	    if (ret < 0)
+	    {
+	    	if (errno != EAGAIN)
+		    perror("MIDI");
+	    }
+	    else if (ret != 0)
+	    {
+    	    	sys_midibytein(i, (c & 0xff));
+	    	did = 1;
+	    }
+	}
+    }
+}
+#endif
+
+void linux_close_midi()
+{
+    int i;
+    for (i = 0; i < oss_nmidiin; i++)
+    	close(oss_midiinfd[i]);
+    for (i = 0; i < oss_nmidiout; i++)
+    	close(oss_midioutfd[i]);
+    oss_nmidiin = oss_nmidiout = 0;
+}
+
+#define MAXAUDIODEV 4
+#define DEFAULTINDEV 1
+#define DEFAULTOUTDEV 1
+
+/* ----------------------- public routines ----------------------- */
+void sys_listdevs( void)
+{
+    post("device listing not implemented in Linux yet\n");
+}
+
+void sys_open_audio(int naudioindev, int *audioindev, int nchindev,
+    int *chindev, int naudiooutdev, int *audiooutdev, int nchoutdev,
+    int *choutdev, int rate)
+{ /* IOhannes */
+    int i, *ip;
+    int defaultchannels =
+    	(linux_whichapi == API_RME ? RME_DEFAULTCH : OSS_DEFAULTCH);
+    if (rate < 1)
+    	rate=44100;
+
+    if (naudioindev == -1)
+    { 	    	/* not set */
+	if (nchindev==-1)
+	{
+	    nchindev=1;
+	    chindev[0]=defaultchannels;
+	    naudioindev=1;
+	    audioindev[0] = DEFAULTINDEV;
+	}
+	else
+	{
+	    for (i = 0; i < MAXAUDIODEV; i++)
+      	        audioindev[i]=i+1;
+	    naudioindev = nchindev;
+	}
+    }
+    else
+    {
+	if (nchindev == -1)
+	{
+	    nchindev = naudioindev;
+	    for (i = 0; i < naudioindev; i++)
+	    	chindev[i] = defaultchannels;
+	}
+	else if (nchindev > naudioindev)
+	{
+	    for (i = naudioindev; i < nchindev; i++)
+	    {
+	    	if (i == 0)
+		    audioindev[0] = DEFAULTINDEV;
+		else audioindev[i] = audioindev[i-1] + 1;
+    	    }
+	    naudioindev = nchindev;
+	}
+	else if (nchindev < naudioindev)
+	{
+	    for (i = nchindev; i < naudioindev; i++)
+	    {
+	    	if (i == 0)
+		    chindev[0] = defaultchannels;
+		else chindev[i] = chindev[i-1];
+    	    }
+	    naudioindev = nchindev;
+	}
+    }
+
+    if (naudiooutdev == -1)
+    { 	    	/* not set */
+	if (nchoutdev==-1)
+	{
+	    nchoutdev=1;
+	    choutdev[0]=defaultchannels;
+	    naudiooutdev=1;
+	    audiooutdev[0] = DEFAULTOUTDEV;
+	}
+	else
+	{
+	    for (i = 0; i < MAXAUDIODEV; i++)
+      	        audiooutdev[i] = i+1;
+	    naudiooutdev = nchoutdev;
+	}
+    }
+    else
+    {
+	if (nchoutdev == -1)
+	{
+	    nchoutdev = naudiooutdev;
+	    for (i = 0; i < naudiooutdev; i++)
+	    	choutdev[i] = defaultchannels;
+	}
+	else if (nchoutdev > naudiooutdev)
+	{
+	    for (i = naudiooutdev; i < nchoutdev; i++)
+	    {
+	    	if (i == 0)
+		    audiooutdev[0] = DEFAULTOUTDEV;
+		else audiooutdev[i] = audiooutdev[i-1] + 1;
+    	    }
+	    naudiooutdev = nchoutdev;
+	}
+	else if (nchoutdev < naudiooutdev)
+	{
+	    for (i = nchoutdev; i < naudiooutdev; i++)
+	    {
+	    	if (i == 0)
+		    choutdev[0] = defaultchannels;
+		else choutdev[i] = choutdev[i-1];
+    	    }
+	    naudiooutdev = nchoutdev;
+	}
+    }
+
+    linux_flush_all_underflows_to_zero();
+#ifdef ALSA
+  if (linux_whichapi == API_ALSA)
+    alsa_open_audio((naudioindev > 0 ? chindev[0] : 0),
+      	(naudiooutdev > 0 ? choutdev[0] : 0), rate);
+  else 
+#endif
+#ifdef RME_HAMMERFALL
+    if (linux_whichapi == API_RME)
+      rme9652_open_audio((naudioindev > 0 ? chindev[0] : 0),
+      	(naudiooutdev > 0 ? choutdev[0] : 0), rate);
+    else 
+#endif
+    	oss_open_audio(naudioindev, audioindev, nchindev, chindev,
+    	    naudiooutdev, audiooutdev, nchoutdev, choutdev, rate);
+}
+
+void sys_close_audio(void)
+{
+    /* set timeout to avoid hanging close() call */
+
+    sys_setalarm(1000000);
+
+#ifdef ALSA 
+    if (linux_whichapi == API_ALSA)
+     	alsa_close_audio();
+    else
+#endif
+#ifdef RME_HAMMERFALL 
+    if (linux_whichapi == API_RME)
+     	rme9652_close_audio();
+    else
+#endif
+    	oss_close_audio();
+
+    sys_setalarm(0);
+}
+
+void sys_open_midi(int nmidiin, int *midiinvec,
+    int nmidiout, int *midioutvec)
+{
+    linux_open_midi(nmidiin, midiinvec, nmidiout, midioutvec);
+}
+
+void sys_close_midi( void)
+{
+    sys_setalarm(1000000);
+    linux_close_midi();
+    sys_setalarm(0);
+}
+
+int sys_send_dacs(void)
+{
+    if (linux_meters)
+    {
+    	int i, n;
+	float maxsamp;
+	for (i = 0, n = linux_inchannels * DACBLKSIZE, maxsamp = linux_inmax;
+	    i < n; i++)
+	{
+	    float f = sys_soundin[i];
+	    if (f > maxsamp) maxsamp = f;
+	    else if (-f > maxsamp) maxsamp = -f;
+	}
+	linux_inmax = maxsamp;
+	for (i = 0, n = linux_outchannels * DACBLKSIZE, maxsamp = linux_outmax;
+	    i < n; i++)
+	{
+	    float f = sys_soundout[i];
+	    if (f > maxsamp) maxsamp = f;
+	    else if (-f > maxsamp) maxsamp = -f;
+	}
+	linux_outmax = maxsamp;
+    }
+#ifdef ALSA 
+    if (linux_whichapi == API_ALSA)
+    	return alsa_send_dacs();
+#endif
+#ifdef RME_HAMMERFALL
+    if (linux_whichapi == API_RME)
+    	return rme9652_send_dacs();
+#endif
+    return oss_send_dacs();
+}
+
+float sys_getsr(void)
+{
+     return (sys_dacsr);
+}
+
+int sys_get_outchannels(void)
+{
+     return (linux_outchannels); 
+}
+
+int sys_get_inchannels(void) 
+{
+     return (linux_inchannels);
+}
+
+void sys_audiobuf(int n)
+{
+     /* set the size, in milliseconds, of the audio FIFO */
+     if (n < 5) n = 5;
+     else if (n > 5000) n = 5000;
+     sys_schedadvance = n * 1000;
+}
+
+void sys_getmeters(float *inmax, float *outmax)
+{
+    if (inmax)
+    {
+    	linux_meters = 1;
+	*inmax = linux_inmax;
+	*outmax = linux_outmax;
+    }
+    else
+    	linux_meters = 0;
+    linux_inmax = linux_outmax = 0;
+}
+
+void sys_reportidle(void)
+{
+}
+
+void sys_set_priority(int higher) 
+{
+    struct sched_param par;
+    int p1 ,p2, p3;
+#ifdef _POSIX_PRIORITY_SCHEDULING
+
+    p1 = sched_get_priority_min(SCHED_FIFO);
+    p2 = sched_get_priority_max(SCHED_FIFO);
+    p3 = (higher ? p2 - 1 : p2 - 3);
+    par.sched_priority = p3;
+
+    if (sched_setscheduler(0,SCHED_FIFO,&par) != -1)
+       fprintf(stderr, "priority %d scheduling enabled.\n", p3);
+#endif
+
+#ifdef _POSIX_MEMLOCK
+    if (mlockall(MCL_FUTURE) != -1) 
+    	fprintf(stderr, "memory locking enabled.\n");
+#endif
+}
+
+/* ------------ linux-specific command-line flags -------------- */
+
+void linux_setfrags(int n)
+{
+    linux_nfragment = n;
+    oss_blockmode = 1;
+}
+
+void linux_setfragsize(int n)
+{
+    if (n < 1)
+    	n = 1;
+    linux_fragsize = n;
+    oss_blockmode = 1;
+}
+
+void linux_streammode( void)
+{
+    oss_blockmode = 0;
+}
+
+void linux_set_sound_api(int which)
+{
+     linux_whichapi = which;
+     if (sys_verbose)
+     	post("linux_whichapi %d", linux_whichapi);
+}
+
+#ifdef ALSA99
+void linux_alsa_devno(int devno)
+{
+    alsa_devno = devno;
+}
+
+#endif
+
+#ifdef ALSA01
+void linux_alsa_devname(char *devname)
+{
+    strncpy(alsa_devname, devname, 511);
+}
+
+void linux_alsa_use_plugin(int t)
+{
+  if (t == 1)
+    alsa_use_plugin = 1;
+  else
+    alsa_use_plugin = 0;
+}
+
+#endif
+
+/* -------------- Audio I/O using the OSS API ------------------ */ 
+
+typedef struct _multidev {
+     int fd;
+     int channels;
+     int format;
+} t_multidev;
+
+int oss_reset(int fd) {
+     int err;
+     if ((err = ioctl(fd,SNDCTL_DSP_RESET)) < 0)
+	  error("OSS: Could not reset");
+     return err;
+}
+
+    /* The AFMT_S32_BLOCKED format is not defined in standard linux kernels
+    but is proposed by Guenter Geiger to support extending OSS to handle
+    32 bit sample.  This is user in Geiger's OSS driver for RME Hammerfall.
+    I'm not clear why this isn't called AFMT_S32_[SLN]E... */
+
+#ifndef AFMT_S32_BLOCKED
+#define AFMT_S32_BLOCKED 0x0000400
+#endif
+
+void oss_configure(t_oss_dev *dev, int srate, int dac, int skipblocksize)
+{ /* IOhannes */
+    int orig, param, nblk, fd = dev->d_fd, wantformat;
+    int nchannels = dev->d_nchannels;
+    int advwas = sys_schedadvance;
+
+    audio_buf_info ainfo;
+
+    /* IOhannes : 
+     * pd is very likely to crash if different formats are used on
+     multiple soundcards
+     */
+
+    	/* set resolution - first try 4 byte samples */
+    if ((ioctl(fd,SNDCTL_DSP_GETFMTS,&param) >= 0) &&
+    	(param & AFMT_S32_BLOCKED))
+    {
+    	wantformat = AFMT_S32_BLOCKED;
+	dev->d_bytespersamp = 4;
+    }
+    else
+    {
+/* FreeBSD's soundcard.h does not define AFMT_S16_NE */
+    	wantformat = AFMT_S16_BE;
+	dev->d_bytespersamp = 2;
+    }
+    param = wantformat;
+
+    if (sys_verbose)
+    	post("bytes per sample = %d", dev->d_bytespersamp);
+    if (ioctl(fd, SNDCTL_DSP_SETFMT, &param) == -1)
+    	fprintf(stderr,"OSS: Could not set DSP format\n");
+    else if (wantformat != param)
+    	fprintf(stderr,"OSS: DSP format: wanted %d, got %d\n",
+	    wantformat, param);
+
+    /* sample rate */
+    orig = param = srate; 
+    if (ioctl(fd, SNDCTL_DSP_SPEED, &param) == -1)
+    	fprintf(stderr,"OSS: Could not set sampling rate for device\n");
+    else if( orig != param )
+    	fprintf(stderr,"OSS: sampling rate: wanted %d, got %d\n",
+	    orig, param );				
+
+    if (oss_blockmode && !skipblocksize)
+    {
+    	int fragbytes, logfragsize, nfragment;
+    	    /* setting fragment count and size.  */
+	if (linux_nfragment)   /* if nfrags specified, take literally */
+	{
+	    nfragment = linux_nfragment;
+	    if (!linux_fragsize)
+	    	linux_fragsize = OSS_DEFFRAGSIZE;
+	    sys_schedadvance = ((nfragment * linux_fragsize) * 1.e6)
+	    	/ (float)srate;
+	    linux_setsr(srate);
+	}
+	else
+	{
+	    if (!linux_fragsize)
+	    {
+	    	linux_fragsize = OSS_DEFFRAGSIZE;
+		while (linux_fragsize > DACBLKSIZE
+		    && linux_fragsize * 4 > linux_advance_samples)
+		    	linux_fragsize = linux_fragsize/2;
+	    }
+	    /* post("adv_samples %d", linux_advance_samples); */
+	    nfragment = (sys_schedadvance * (44100. * 1.e-6)) / linux_fragsize;
+	}
+    	fragbytes = linux_fragsize * (dev->d_bytespersamp * nchannels);
+	logfragsize = ilog2(fragbytes);
+
+    	if (fragbytes != (1 << logfragsize))
+	    post("warning: OSS takes only power of 2 blocksize; using %d",
+	    	(1 << logfragsize)/(dev->d_bytespersamp * nchannels));
+    	if (sys_verbose)
+	    post("setting nfrags = %d, fragsize %d\n", nfragment, fragbytes);
+
+    	param = orig = (nfragment<<16) + logfragsize;
+    	if (ioctl(fd,SNDCTL_DSP_SETFRAGMENT, &param) == -1)
+    	    error("OSS: Could not set or read fragment size\n");
+	if (param != orig)
+	{
+	    nfragment = ((param >> 16) & 0xffff);
+	    logfragsize = (param & 0xffff);
+	    post("warning: actual fragments %d, blocksize %d",
+	    	nfragment, (1 << logfragsize));
+	}
+	if (sys_verbose)
+	    post("audiobuffer set to %d msec", (int)(0.001 * sys_schedadvance));
+    }
+
+    if (dac)
+    {
+	/* use "free space" to learn the buffer size.  Normally you
+	should set this to your own desired value; but this seems not
+	to be implemented uniformly across different sound cards.  LATER
+	we should figure out what to do if the requested scheduler advance
+	is greater than this buffer size; for now, we just print something
+	out.  */
+
+    	int defect;
+	if (ioctl(fd, SOUND_PCM_GETOSPACE,&ainfo) < 0)
+	   fprintf(stderr,"OSS: ioctl on output device failed");
+	dev->d_bufsize = ainfo.bytes;
+
+    	defect = linux_advance_samples * (dev->d_bytespersamp * nchannels)
+	    - dev->d_bufsize - OSS_XFERSIZE(nchannels, dev->d_bytespersamp);
+	if (defect > 0)
+	{
+	    if (sys_verbose || defect > (dev->d_bufsize >> 2))
+	    	fprintf(stderr,
+	    	    "OSS: requested audio buffer size %d limited to %d\n",
+		    	linux_advance_samples * (dev->d_bytespersamp * nchannels),
+		    	dev->d_bufsize);
+    	    linux_advance_samples =
+	    	(dev->d_bufsize - OSS_XFERSAMPS(nchannels)) /
+		    (dev->d_bytespersamp *nchannels);
+	}
+    }
+}
+
+static int oss_setchannels(int fd, int wantchannels, char *devname)
+{ /* IOhannes */
+    int param = wantchannels;
+
+    while (param>1) {
+      int save = param;
+      if (ioctl(fd, SNDCTL_DSP_CHANNELS, &param) == -1) {
+	error("OSS: SNDCTL_DSP_CHANNELS failed %s",devname);
+      } else {
+	if (param == save) return (param);
+      }
+      param=save-1;
+    }
+
+    return (0);
+}
+
+int oss_open_audio(int nindev,  int *indev,  int nchin,  int *chin,
+    int noutdev, int *outdev, int nchout, int *chout, int rate)
+{ /* IOhannes */
+    int capabilities = 0;
+    int inchannels = 0, outchannels = 0;
+    char devname[20];
+    int n, i, fd;
+    char buf[OSS_MAXSAMPLEWIDTH * DACBLKSIZE * OSS_MAXCHPERDEV];
+    int num_devs = 0;
+    int wantmore=0;
+    int spread = 0;
+    audio_buf_info ainfo;
+
+    linux_nindevs = linux_noutdevs = 0;
+
+    /* set logical sample rate amd calculate linux_advance_samples.  */
+    linux_setsr(rate);
+
+    	/* mark input devices unopened */
+    for (i = 0; i < OSS_MAXDEV; i++)
+    	linux_adcs[i].d_fd = -1;
+
+    /* open output devices */
+    wantmore=0;
+    if (noutdev < 0 || nindev < 0)
+    	bug("linux_open_audio");
+
+    for (n = 0; n < noutdev; n++)
+    {
+	int gotchans, j, inindex = -1;
+	int thisdevice=outdev[n];
+	int wantchannels = (nchout>n) ? chout[n] : wantmore;
+    	fd = -1;
+	if (!wantchannels)
+	    goto end_out_loop;
+
+	if (thisdevice > 1)
+	    sprintf(devname, "/dev/dsp%d", thisdevice-1);
+	else sprintf(devname, "/dev/dsp");
+    	
+	    /* search for input request for same device.  Succeed only
+	    if the number of channels matches. */
+	for (j = 0; j < nindev; j++)
+	    if (indev[j] == thisdevice && chin[j] == wantchannels)
+	    	inindex = j;
+	
+    	    /* if the same device is requested for input and output,
+	    try to open it read/write */
+	if (inindex >= 0)
+	{
+	    sys_setalarm(1000000);
+	    if ((fd = open(devname, O_RDWR)) == -1)
+	    {
+	    	post("%s (read/write): %s", devname, strerror(errno));
+		post("(now will try write-only...)");
+	    }
+	    else
+	    {
+	    	if (sys_verbose)
+	    	    post("opened %s for reading and writing\n", devname);
+	    	linux_adcs[inindex].d_fd = fd;
+	    }
+	}
+	    /* if that didn't happen or if it failed, try write-only */
+	if (fd == -1)
+	{
+	    sys_setalarm(1000000);
+	    if ((fd = open(devname, O_WRONLY)) == -1)
+	    {
+		post("%s (writeonly): %s",
+		     devname, strerror(errno));
+		break;
+	    }
+	    if (sys_verbose)
+	    	post("opened %s for writing only\n", devname);
+    	}
+	if (ioctl(fd, SNDCTL_DSP_GETCAPS, &capabilities) == -1)
+	    error("OSS: SNDCTL_DSP_GETCAPS failed %s", devname);
+
+	gotchans = oss_setchannels(fd,
+	    (wantchannels>OSS_MAXCHPERDEV)?OSS_MAXCHPERDEV:wantchannels,
+		    devname);
+
+	if (sys_verbose)
+	    post("opened audio output on %s; got %d channels",
+	    	 devname, gotchans);
+
+	if (gotchans < 2)
+	{
+	    	/* can't even do stereo? just give up. */
+	    close(fd);
+	}
+	else
+	{
+	    linux_dacs[linux_noutdevs].d_nchannels = gotchans;
+	    linux_dacs[linux_noutdevs].d_fd = fd;
+	    oss_configure(linux_dacs+linux_noutdevs, rate, 1, 0);
+
+	    linux_noutdevs++;
+	    outchannels += gotchans;
+	    if (inindex >= 0)
+	    {
+	    	linux_adcs[inindex].d_nchannels = gotchans;
+	    	chin[inindex] = gotchans;
+	    }
+	}
+	/* LATER think about spreading large numbers of channels over
+	    various dsp's and vice-versa */
+	wantmore = wantchannels - gotchans;
+    end_out_loop: ;
+    }
+
+    /* open input devices */
+    wantmore = 0;
+    if (nindev==-1)
+    	nindev=4; /* spread channels over default-devices */
+    for (n = 0; n < nindev; n++)
+    {
+	int gotchans=0;
+	int thisdevice=indev[n];
+	int wantchannels = (nchin>n)?chin[n]:wantmore;
+	int alreadyopened = 0;
+	if (!wantchannels)
+	    goto end_in_loop;
+
+	if (thisdevice > 1)
+	    sprintf(devname, "/dev/dsp%d", thisdevice - 1);
+	else sprintf(devname, "/dev/dsp");
+
+	sys_setalarm(1000000);
+
+    	    /* perhaps it's already open from the above? */
+    	if (linux_dacs[n].d_fd >= 0)
+	{
+	    fd = linux_dacs[n].d_fd;
+	    alreadyopened = 1;
+	}
+	else
+	{
+	    	/* otherwise try to open it here. */
+	    if ((fd = open(devname, O_RDONLY)) == -1)
+	    {
+		post("%s (readonly): %s", devname, strerror(errno));
+		goto end_in_loop;
+	    }
+	    if (sys_verbose)
+	    	post("opened %s for reading only\n", devname);
+    	}
+	linux_adcs[linux_nindevs].d_fd = fd;
+	gotchans = oss_setchannels(fd,
+	    (wantchannels>OSS_MAXCHPERDEV)?OSS_MAXCHPERDEV:wantchannels,
+	    	devname);
+	if (sys_verbose)
+	post("opened audio input device %s; got %d channels",
+	     devname, gotchans);
+
+	if (gotchans < 1)
+	{
+	    close(fd);
+	    goto end_in_loop;
+	}
+
+	linux_adcs[linux_nindevs].d_nchannels = gotchans;
+	
+	oss_configure(linux_adcs+linux_nindevs, rate, 0, alreadyopened);
+
+	inchannels += gotchans;
+	linux_nindevs++;
+
+	wantmore = wantchannels-gotchans;
+	/* LATER think about spreading large numbers of channels over
+	    various dsp's and vice-versa */
+    end_in_loop: ;
+    }
+
+    linux_setch(inchannels, outchannels);
+
+    /* We have to do a read to start the engine. This is 
+       necessary because sys_send_dacs waits until the input
+       buffer is filled and only reads on a filled buffer.
+       This is good, because it's a way to make sure that we
+       will not block.  But I wonder why we only have to read
+       from one of the devices and not all of them??? */
+
+    if (linux_nindevs)
+    {
+    	if (sys_verbose)
+	    fprintf(stderr,("OSS: issuing first ADC 'read' ... "));
+	read(linux_adcs[0].d_fd, buf,
+	    linux_adcs[0].d_bytespersamp *
+	    	linux_adcs[0].d_nchannels * DACBLKSIZE);
+    	if (sys_verbose)
+	    fprintf(stderr, "...done.\n");
+    }
+    sys_setalarm(0);
+    return (0);
+}
+
+void oss_close_audio( void)
+{
+     int i;
+     for (i=0;i<linux_nindevs;i++)
+	  close(linux_adcs[i].d_fd);
+
+     for (i=0;i<linux_noutdevs;i++)
+          close(linux_dacs[i].d_fd);
+
+    linux_nindevs = linux_noutdevs = 0;
+}
+
+static int linux_dacs_write(int fd,void* buf,long bytes)
+{
+    return write(fd, buf, bytes);
+}
+
+static int linux_adcs_read(int fd,void*  buf,long bytes)
+{
+     return read(fd, buf, bytes);
+}
+
+    /* query audio devices for "available" data size. */
+static void oss_calcspace(void)
+{
+    int dev;
+    audio_buf_info ainfo;
+    for (dev=0; dev < linux_noutdevs; dev++)
+    {
+	if (ioctl(linux_dacs[dev].d_fd, SOUND_PCM_GETOSPACE, &ainfo) < 0)
+	   fprintf(stderr,"OSS: ioctl on output device %d failed",dev);
+	linux_dacs[dev].d_space = ainfo.bytes;
+    }
+
+    for (dev = 0; dev < linux_nindevs; dev++)
+    {
+	if (ioctl(linux_adcs[dev].d_fd, SOUND_PCM_GETISPACE,&ainfo) < 0)
+	    fprintf(stderr, "OSS: ioctl on input device %d, fd %d failed",
+    	    	dev, linux_adcs[dev].d_fd);
+	linux_adcs[dev].d_space = ainfo.bytes;
+    }
+}
+
+void linux_audiostatus(void)
+{
+    int dev;
+    if (!oss_blockmode)
+    {
+	oss_calcspace();
+	for (dev=0; dev < linux_noutdevs; dev++)
+	    fprintf(stderr, "dac %d space %d\n", dev, linux_dacs[dev].d_space);
+
+	for (dev = 0; dev < linux_nindevs; dev++)
+	    fprintf(stderr, "adc %d space %d\n", dev, linux_adcs[dev].d_space);
+
+    }
+}
+
+/* this call resyncs audio output and input which will cause discontinuities
+in audio output and/or input. */ 
+
+static void oss_doresync( void)
+{
+    int dev, zeroed = 0, wantsize;
+    char buf[OSS_MAXSAMPLEWIDTH * DACBLKSIZE * OSS_MAXCHPERDEV];
+    audio_buf_info ainfo;
+
+    	/* 1. if any input devices are ahead (have more than 1 buffer stored),
+	    drop one or more buffers worth */
+    for (dev = 0; dev < linux_nindevs; dev++)
+    {
+    	if (linux_adcs[dev].d_space == 0)
+	{
+	    linux_adcs_read(linux_adcs[dev].d_fd, buf,
+	    	OSS_XFERSIZE(linux_adcs[dev].d_nchannels,
+		    linux_adcs[dev].d_bytespersamp));
+	}
+	else while (linux_adcs[dev].d_space >
+	    OSS_XFERSIZE(linux_adcs[dev].d_nchannels,
+	    	linux_adcs[dev].d_bytespersamp))
+	{
+    	    linux_adcs_read(linux_adcs[dev].d_fd, buf, 
+	    	OSS_XFERSIZE(linux_adcs[dev].d_nchannels,
+		    linux_adcs[dev].d_bytespersamp));
+	    if (ioctl(linux_adcs[dev].d_fd, SOUND_PCM_GETISPACE, &ainfo) < 0)
+	    {
+	    	fprintf(stderr, "OSS: ioctl on input device %d, fd %d failed",
+    	    	    dev, linux_adcs[dev].d_fd);
+	    	break;
+	    }
+	    linux_adcs[dev].d_space = ainfo.bytes;
+	}
+    }
+
+    	/* 2. if any output devices are behind, feed them zeros to catch them
+	    up */
+    for (dev = 0; dev < linux_noutdevs; dev++)
+    {
+    	while (linux_dacs[dev].d_space > linux_dacs[dev].d_bufsize - 
+	    linux_advance_samples * (linux_dacs[dev].d_nchannels *
+	    	linux_dacs[dev].d_bytespersamp))
+	{
+    	    if (!zeroed)
+	    {
+	    	unsigned int i;
+		for (i = 0; i < OSS_XFERSAMPS(linux_dacs[dev].d_nchannels);
+		    i++)    
+		    	buf[i] = 0;
+		zeroed = 1;
+	    }
+    	    linux_dacs_write(linux_dacs[dev].d_fd, buf,
+	    	OSS_XFERSIZE(linux_dacs[dev].d_nchannels,
+		    linux_dacs[dev].d_bytespersamp));
+	    if (ioctl(linux_dacs[dev].d_fd, SOUND_PCM_GETOSPACE, &ainfo) < 0)
+	    {
+	    	fprintf(stderr, "OSS: ioctl on output device %d, fd %d failed",
+    	    	    dev, linux_dacs[dev].d_fd);
+	    	break;
+	    }
+	    linux_dacs[dev].d_space = ainfo.bytes;
+	}
+    }
+    	/* 3. if any DAC devices are too far ahead, plan to drop the
+	    number of frames which will let the others catch up. */
+    for (dev = 0; dev < linux_noutdevs; dev++)
+    {
+    	if (linux_dacs[dev].d_space > linux_dacs[dev].d_bufsize - 
+	    (linux_advance_samples - 1) * linux_dacs[dev].d_nchannels *
+	    	linux_dacs[dev].d_bytespersamp)
+	{
+    	    linux_dacs[dev].d_dropcount = linux_advance_samples - 1 - 
+	    	(linux_dacs[dev].d_space - linux_dacs[dev].d_bufsize) /
+		     (linux_dacs[dev].d_nchannels *
+		     	linux_dacs[dev].d_bytespersamp) ;
+	}
+	else linux_dacs[dev].d_dropcount = 0;
+    }
+}
+
+int oss_send_dacs(void)
+{
+    float *fp1, *fp2;
+    long fill;
+    int i, j, dev, rtnval = SENDDACS_YES;
+    char buf[OSS_MAXSAMPLEWIDTH * DACBLKSIZE * OSS_MAXCHPERDEV];
+    t_oss_int16 *sp;
+    t_oss_int32 *lp;
+    	/* the maximum number of samples we should have in the ADC buffer */
+    int idle = 0;
+    int thischan;
+    double timeref, timenow;
+
+    if (!linux_nindevs && !linux_noutdevs)
+    	return (SENDDACS_NO);
+
+    if (!oss_blockmode)
+    {
+    	/* determine whether we're idle.  This is true if either (1)
+    	some input device has less than one buffer to read or (2) some
+	output device has fewer than (linux_advance_samples) blocks buffered
+	already. */
+    	oss_calcspace();
+    
+	for (dev=0; dev < linux_noutdevs; dev++)
+	    if (linux_dacs[dev].d_dropcount ||
+		(linux_dacs[dev].d_bufsize - linux_dacs[dev].d_space >
+	    	    linux_advance_samples * linux_dacs[dev].d_bytespersamp * 
+			linux_dacs[dev].d_nchannels))
+    	    	    	    idle = 1;
+	for (dev=0; dev < linux_nindevs; dev++)
+	    if (linux_adcs[dev].d_space <
+	    	OSS_XFERSIZE(linux_adcs[dev].d_nchannels,
+		    linux_adcs[dev].d_bytespersamp))
+		    	idle = 1;
+    }
+    
+    if (idle && !oss_blockmode)
+    {
+    	    /* sometimes---rarely---when the ADC available-byte-count is
+	    zero, it's genuine, but usually it's because we're so
+	    late that the ADC has overrun its entire kernel buffer.  We
+	    distinguish between the two by waiting 2 msec and asking again.
+	    There should be an error flag we could check instead; look for this
+    	    someday... */
+    	for (dev = 0;dev < linux_nindevs; dev++) 
+	    if (linux_adcs[dev].d_space == 0)
+	{
+    	    audio_buf_info ainfo;
+	    sys_microsleep(2000);
+	    oss_calcspace();
+	    if (linux_adcs[dev].d_space != 0) continue;
+
+    	    	/* here's the bad case.  Give up and resync. */
+	    sys_log_error(ERR_DATALATE);
+	    oss_doresync();
+	    return (SENDDACS_NO);
+	}
+    	    /* check for slippage between devices, either because
+	    data got lost in the driver from a previous late condition, or
+	    because the devices aren't synced.  When we're idle, no
+	    input device should have more than one buffer readable and
+	    no output device should have less than linux_advance_samples-1
+	    */
+	    
+	for (dev=0; dev < linux_noutdevs; dev++)
+	    if (!linux_dacs[dev].d_dropcount &&
+		(linux_dacs[dev].d_bufsize - linux_dacs[dev].d_space <
+	    	    (linux_advance_samples - 2) *
+		    	(linux_dacs[dev].d_bytespersamp *
+			    linux_dacs[dev].d_nchannels)))
+    	    		goto badsync;
+	for (dev=0; dev < linux_nindevs; dev++)
+	    if (linux_adcs[dev].d_space > 3 *
+	    	OSS_XFERSIZE(linux_adcs[dev].d_nchannels,
+		    linux_adcs[dev].d_bytespersamp))
+		    	goto badsync;
+
+	    /* return zero to tell the scheduler we're idle. */
+    	return (SENDDACS_NO);
+    badsync:
+	sys_log_error(ERR_RESYNC);
+	oss_doresync();
+	return (SENDDACS_NO);
+    	
+    }
+
+	/* do output */
+
+    timeref = sys_getrealtime();
+    for (dev=0, thischan = 0; dev < linux_noutdevs; dev++)
+    {
+    	int nchannels = linux_dacs[dev].d_nchannels;
+    	if (linux_dacs[dev].d_dropcount)
+	    linux_dacs[dev].d_dropcount--;
+	else
+	{
+	    if (linux_dacs[dev].d_bytespersamp == 4)
+	    {
+		for (i = DACBLKSIZE * nchannels,  fp1 = sys_soundout +	
+	    	    DACBLKSIZE*thischan,
+	    	    lp = (t_oss_int32 *)buf; i--; fp1++, lp++)
+		{
+		    float f = *fp1 * 2147483648.;
+		    *lp = (f >= 2147483647. ? 2147483647. : 
+			(f < -2147483648. ? -2147483648. : f));
+		}
+	    }
+	    else
+	    {
+		for (i = DACBLKSIZE,  fp1 = sys_soundout +	
+	    	    DACBLKSIZE*thischan,
+	    	    sp = (t_oss_int16 *)buf; i--; fp1++, sp += nchannels)
+		{
+		    for (j=0, fp2 = fp1; j<nchannels; j++, fp2 += DACBLKSIZE)
+		    {
+	    		int s = *fp2 * 32767.;
+			if (s > 32767) s = 32767;
+			else if (s < -32767) s = -32767;
+	    		sp[j] = s;
+		    }
+		}
+	    }
+	    linux_dacs_write(linux_dacs[dev].d_fd, buf,
+	    	OSS_XFERSIZE(nchannels, linux_dacs[dev].d_bytespersamp));
+	    if ((timenow = sys_getrealtime()) - timeref > 0.002)
+	    {
+	    	if (!oss_blockmode)
+		    sys_log_error(ERR_DACSLEPT);
+		else rtnval = SENDDACS_SLEPT;
+    	    }
+	    timeref = timenow;
+    	}
+	thischan += nchannels;
+    }
+    memset(sys_soundout, 0,
+    	linux_outchannels * (sizeof(float) * DACBLKSIZE));
+
+    	/* do input */
+
+    for (dev = 0, thischan = 0; dev < linux_nindevs; dev++)
+    {
+    	int nchannels = linux_adcs[dev].d_nchannels;
+    	linux_adcs_read(linux_adcs[dev].d_fd, buf,
+	    OSS_XFERSIZE(nchannels, linux_adcs[dev].d_bytespersamp));
+
+	if ((timenow = sys_getrealtime()) - timeref > 0.002)
+	{
+	    if (!oss_blockmode)
+	    	sys_log_error(ERR_ADCSLEPT);
+	    else
+	    	rtnval = SENDDACS_SLEPT;
+    	}
+	timeref = timenow;
+
+	if (linux_adcs[dev].d_bytespersamp == 4)
+	{
+	    for (i = DACBLKSIZE*nchannels,
+	    	fp1 = sys_soundin + thischan*DACBLKSIZE,
+		    lp = (t_oss_int32 *)buf; i--; fp1++, lp++)
+	    {
+    	    	*fp1 = ((float)(*lp))*(float)(1./2147483648.);
+	    }
+    	}
+	else
+	{
+	    for (i = DACBLKSIZE,fp1 = sys_soundin + thischan*DACBLKSIZE,
+		sp = (t_oss_int16 *)buf; i--; fp1++, sp += nchannels)
+	    {
+    		for (j=0;j<linux_inchannels;j++)
+    	    	    fp1[j*DACBLKSIZE] = (float)sp[j]*(float)3.051850e-05;
+	    }
+	}
+	thischan += nchannels; 	  
+     }
+     if (thischan != linux_inchannels)
+     	bug("inchannels");
+     return (rtnval);
+}
+
+/* ----------------- audio I/O using the ALSA native API ---------------- */
+
+#ifdef ALSA
+static void alsa_checkversion( void)
+{
+    char snox[512];
+    int fd, nbytes;
+    if ((fd = open("/proc/asound/version", 0)) < 0 ||
+    	(nbytes = read(fd, snox, 511)) < 1)
+    {
+    	perror("cannot check Alsa version -- /proc/asound/version");
+	return;
+    }
+    snox[nbytes] = 0;
+#ifdef ALSA99
+    if (!strstr(snox, "Version 0.5"))
+    {
+    	fprintf(stderr,
+"warning: Pd compiled for Alsa version 0.5 appears to be incompatible with\n\
+the installed version of ALSA.  Here is what I found in /proc/asound/version:\n"
+    	    	);
+    	fprintf(stderr, "%s", snox);
+    }
+#else
+    if (!strstr(snox, "Version 0.9"))
+    {
+    	fprintf(stderr,
+"warning: Pd compiled for Alsa version 0.9 appears to be incompatible with\n\
+the installed version of ALSA.  Here is what I found in /proc/asound/version:\n"
+    	    	);
+    	fprintf(stderr, "%s", snox);
+    }
+#endif
+}
+#endif
+
+#ifdef ALSA99
+static int alsa_open_audio(int wantinchans, int wantoutchans,
+    int srate)
+{
+    int dir, voices, bsize;
+    int err, id, rate, i;
+    char *cardname;
+    snd_ctl_hw_info_t hwinfo;
+    snd_pcm_info_t pcminfo;
+    snd_pcm_channel_info_t channelinfo;
+    snd_ctl_t *handle;
+    snd_pcm_sync_t sync;
+
+    linux_inchannels = 0;
+    linux_outchannels = 0;
+    
+    rate = 44100;
+    alsa_samplewidth = 4;   	/* first try 4 byte samples */
+
+    if (!wantinchans && !wantoutchans)
+    	return (1);
+
+    alsa_checkversion();
+    if (sys_verbose)
+    {
+	if ((err = snd_card_get_longname(alsa_devno-1, &cardname)) < 0)
+	{
+	    fprintf(stderr, "PD-ALSA: unable to get name of card number %d\n",
+	    	alsa_devno);
+	    return 1;
+	}
+	fprintf(stderr, "PD-ALSA: using card %s\n", cardname);
+	free(cardname);
+    }
+
+    if ((err = snd_ctl_open(&handle, alsa_devno-1)) < 0)
+    {
+	fprintf(stderr, "PD-ALSA: unable to open control: %s\n",
+    	    snd_strerror(err));
+	return 1;
+    }
+
+    if ((err = snd_ctl_hw_info(handle, &hwinfo)) < 0)
+    {
+	fprintf(stderr, "PD-ALSA: unable to open get info: %s\n",
+    	    snd_strerror(err));
+	return 1;
+    }
+    if (hwinfo.pcmdevs < 1)
+    {
+	fprintf(stderr, "PD-ALSA: device %d doesn't support PCM\n",
+	    alsa_devno);
+    	snd_ctl_close(handle);
+	return 1;
+    }
+
+    if ((err = snd_ctl_pcm_info(handle, 0, &pcminfo)) < 0)
+    {
+	fprintf(stderr, "PD-ALSA: unable to open get pcm info: %s\n",
+	    snd_strerror(err));
+    	snd_ctl_close(handle);
+	return (1);
+    }
+    snd_ctl_close(handle);
+
+    	/* find out if opening for input, output, or both and check that the
+	device can handle it. */
+    if (wantinchans && wantoutchans)
+    {
+	if (!(pcminfo.flags & SND_PCM_INFO_DUPLEX))
+	{
+	    fprintf(stderr, "PD-ALSA: device is not full duplex\n");
+	    return (1);
+	}
+	dir = SND_PCM_OPEN_DUPLEX;
+    }
+    else if (wantoutchans)
+    {
+	if (!(pcminfo.flags & SND_PCM_INFO_PLAYBACK))
+	{
+	    fprintf(stderr, "PD-ALSA: device is not full duplex\n");
+	    return (1);
+	}
+    	dir = SND_PCM_OPEN_PLAYBACK;
+    }
+    else
+    {
+	if (!(pcminfo.flags & SND_PCM_INFO_CAPTURE))
+	{
+	    fprintf(stderr, "PD-ALSA: device is not full duplex\n");
+	    return (1);
+	}
+    	dir = SND_PCM_OPEN_CAPTURE;
+    }
+
+    	/* try to open the device */
+    if ((err = snd_pcm_open(&alsa_device[0].handle, alsa_devno-1, 0, dir)) < 0)
+    {
+	fprintf(stderr, "PD-ALSA: error opening device: %s\n",
+	    snd_strerror(err));
+	return (1);
+    }
+    	/* get information from the handle */
+    if (wantinchans)
+    {
+	channelinfo.channel = SND_PCM_CHANNEL_CAPTURE;
+	channelinfo.subdevice = 0;
+	if ((err = snd_pcm_channel_info(alsa_device[0].handle, &channelinfo))
+	    < 0)
+	{
+	    fprintf(stderr, "PD-ALSA: snd_pcm_channel_info (input): %s\n",
+		snd_strerror(err));
+	    return (1);
+	}
+	if (sys_verbose)
+	    post("input channels supported: %d-%d\n",
+	    	channelinfo.min_voices, channelinfo.max_voices);
+
+	if (wantinchans < channelinfo.min_voices)
+	    post("increasing input channels to minimum of %d\n",
+		wantinchans = channelinfo.min_voices);
+	if (wantinchans > channelinfo.max_voices)
+	    post("decreasing input channels to maximum of %d\n",
+		wantinchans = channelinfo.max_voices);
+	if (alsa_samplewidth == 4 &&
+	    !(channelinfo.formats & (1<<SND_PCM_SFMT_S32_LE)))
+	{
+	    fprintf(stderr,
+	    	"PD_ALSA: input doesn't support 32-bit samples; using 16\n");
+	    alsa_samplewidth = 2;
+	}
+	if (alsa_samplewidth == 2 &&
+	    !(channelinfo.formats & (1<<SND_PCM_SFMT_S16_LE)))
+	{
+	    fprintf(stderr,
+	    	"PD_ALSA: can't find 4 or 2 byte format; giving up\n");
+	    return (1);
+	}
+    }
+
+    if (wantoutchans)
+    {
+	channelinfo.channel = SND_PCM_CHANNEL_PLAYBACK;
+	channelinfo.subdevice = 0;
+	if ((err = snd_pcm_channel_info(alsa_device[0].handle, &channelinfo))
+	    < 0)
+	{
+	    fprintf(stderr, "PD-ALSA: snd_pcm_channel_info (output): %s\n",
+		snd_strerror(err));
+	    return (1);
+	}
+	if (sys_verbose)
+	    post("output channels supported: %d-%d\n",
+	    	channelinfo.min_voices, channelinfo.max_voices);
+	if (wantoutchans < channelinfo.min_voices)
+	    post("increasing output channels to minimum of %d\n",
+		wantoutchans = channelinfo.min_voices);
+	if (wantoutchans > channelinfo.max_voices)
+	    post("decreasing output channels to maximum of %d\n",
+		wantoutchans = channelinfo.max_voices);
+	if (alsa_samplewidth == 4 &&
+	    !(channelinfo.formats & (1<<SND_PCM_SFMT_S32_LE)))
+	{
+	    fprintf(stderr,
+	    	"PD_ALSA: output doesn't support 32-bit samples; using 16\n");
+	    alsa_samplewidth = 2;
+	}
+	if (alsa_samplewidth == 2 &&
+	    !(channelinfo.formats & (1<<SND_PCM_SFMT_S16_LE)))
+	{
+	    fprintf(stderr,
+	    	"PD_ALSA: can't find 4 or 2 byte format; giving up\n");
+	    return (1);
+	}
+    }
+
+    linux_setsr(rate);
+    linux_setch(wantinchans, wantoutchans);
+
+    if (wantinchans)
+    	alsa_set_params(&alsa_device[0], SND_PCM_CHANNEL_CAPTURE,
+    	    srate, wantinchans);
+    if (wantoutchans)
+    	alsa_set_params(&alsa_device[0], SND_PCM_CHANNEL_PLAYBACK,
+    	    srate, wantoutchans);
+
+    n_alsa_dev = 1;
+
+    /* check that all is as we think it should be */
+    for (i = 0; i < n_alsa_dev; i++)
+    {
+	/* We need to handle if the rate is not the same for all
+	* devices.  For now just hope. */
+	rate = alsa_device[i].setup.format.rate;
+
+    /* It turns out that this checking does not work on all of my cards
+    * - in full duplex on my trident 4dwave the setup on the capture channel
+    * shows a sampling rate of 0.  This is not true on my ess solo1.  Checking
+    * the dac last helps the problem.  All of this needs to be much smarter
+    * anyway (last minute hack).  A warning above is all I have time for.
+    */
+	if (rate != srate)
+	{
+	    post("PD-ALSA: unable to obtain rate %i using %i", srate, rate);
+	    post("PD-ALSA: (despite this warning Pd might still work.)");
+	}
+    }
+    bsize = alsa_samplewidth *
+    	(linux_inchannels > linux_outchannels ? linux_inchannels :
+	    linux_outchannels) * DACBLKSIZE;
+    alsa_buf = malloc(bsize);
+    if (!alsa_buf)
+    	return (1);
+    memset(alsa_buf, 0, bsize);
+    return 0;
+}
+
+void alsa_set_params(t_alsa_dev *dev, int dir, int rate, int voices)
+{
+    int err;
+    struct snd_pcm_channel_params params;
+
+    memset(&dev->info, 0, sizeof(dev->info));
+    dev->info.channel = dir;
+    if ((err = snd_pcm_channel_info(dev->handle, &dev->info) < 0))
+    {
+	fprintf(stderr, "PD-ALSA: error getting channel info: %s\n",
+	    snd_strerror(err));
+    }
+    memset(&params, 0, sizeof(params));
+    params.format.interleave = 1;   /* may do non-interleaved later */
+    	/* format is 2 or 4 bytes per sample depending on what was possible */
+    params.format.format = 
+    	(alsa_samplewidth == 4 ? SND_PCM_SFMT_S32_LE : SND_PCM_SFMT_S16_LE);
+
+    	/*will check this further down -just try for now*/
+    params.format.rate = rate; 
+    params.format.voices = voices;
+    params.start_mode = SND_PCM_START_GO;   /* seems most reliable */
+    	                                    /*do not stop at overrun/underrun*/
+    params.stop_mode = SND_PCM_STOP_ROLLOVER;
+
+    params.channel = dir;                   /* playback|capture */
+    params.buf.stream.queue_size =
+	(ALSA_EXTRABUFFER + linux_advance_samples)
+	    * alsa_samplewidth * voices;
+    params.buf.stream.fill = SND_PCM_FILL_SILENCE_WHOLE;
+    params.mode = SND_PCM_MODE_STREAM;
+
+    if ((err = snd_pcm_channel_params(dev->handle, &params)) < 0)
+    {
+	printf("PD-ALSA: error setting parameters %s", snd_strerror(err));
+    }
+
+	/* This should clear the buffers but does not. There is often noise at
+	startup that sounds like crap left in the buffers - maybe in the lib
+	instead of the driver?  Some solution needs to be found.
+	*/
+
+    if ((err = snd_pcm_channel_prepare(dev->handle, dir)) < 0)
+    {
+	printf("PD-ALSA: error preparing channel %s", snd_strerror(err));
+    }
+    dev->setup.channel = dir;
+
+    if ((err = snd_pcm_channel_setup(dev->handle, &dev->setup)) < 0)
+    {
+	printf("PD-ALSA: error getting setup %s", snd_strerror(err));
+    }
+    	/* for some reason, if you don't writesomething before starting the
+	converters we get trash on startup */
+    if (dir == SND_PCM_CHANNEL_PLAYBACK)
+    {
+    	char foo[1024];
+	int xxx = 1024 - (1024 % (linux_outchannels * alsa_samplewidth));
+	int i, r;
+	for (i = 0; i < xxx; i++)
+	    foo[i] = 0;
+	if ((r = snd_pcm_write(dev->handle, foo, xxx)) < xxx)
+	    fprintf(stderr, "alsa_write: %s\n", snd_strerror(errno));
+    }
+    snd_pcm_channel_go(dev->handle, dir);
+}
+
+void alsa_close_audio(void)
+{
+    int i;
+    for(i = 0; i < n_alsa_dev; i++)
+    	snd_pcm_close(alsa_device[i].handle);
+}
+
+/* #define DEBUG_ALSA_XFER */
+
+int alsa_send_dacs(void)
+{
+    static int16_t *sp;
+    t_sample *fp, *fp1, *fp2;
+    int i, j, k, err, devno = 0;
+    int inputcount = 0, outputcount = 0, inputlate = 0, outputlate = 0;
+    int result; 
+    snd_pcm_channel_status_t stat;
+    static int callno = 0;
+    static int xferno = 0;
+    int countwas = 0;
+    double timelast;
+    static double timenow;
+    int inchannels = linux_inchannels;
+    int outchannels = linux_outchannels;
+    int inbytesperframe = inchannels * alsa_samplewidth;
+    int outbytesperframe = outchannels * alsa_samplewidth;
+    int intransfersize = DACBLKSIZE * inbytesperframe;
+    int outtransfersize = DACBLKSIZE * outbytesperframe;
+    int alsaerror;
+    int loggederror = 0;
+
+    if (!inchannels && !outchannels)
+    	return (SENDDACS_NO);
+    timelast = timenow;
+    timenow = sys_getrealtime();
+
+#ifdef DEBUG_ALSA_XFER
+    if (timenow - timelast > 0.050)
+    	fprintf(stderr, "(%d)",
+	    (int)(1000 * (timenow - timelast))), fflush(stderr);
+#endif
+
+    callno++;
+    	    /* get input and output channel status */
+    if (inchannels > 0)
+    {
+    	devno = 0;
+    	stat.channel = SND_PCM_CHANNEL_CAPTURE;
+	if (alsaerror = snd_pcm_channel_status(alsa_device[devno].handle,
+	    &stat))
+	{
+	    fprintf(stderr, "snd_pcm_channel_status (input): %s\n",
+	    	snd_strerror(alsaerror));
+	    return (SENDDACS_NO);
+	}
+	inputcount = stat.count;
+	inputlate = (stat.underrun > 0 || stat.overrun > 0);
+    }
+    if (outchannels > 0)
+    {
+	devno = 0;
+    	stat.channel = SND_PCM_CHANNEL_PLAYBACK;
+	if (alsaerror = snd_pcm_channel_status(alsa_device[devno].handle,
+	    &stat))
+	{
+	    fprintf(stderr, "snd_pcm_channel_status (output): %s\n",
+	    	snd_strerror(alsaerror));
+	    return (SENDDACS_NO);
+	}
+	outputcount = stat.count;
+    	outputlate = (stat.underrun > 0 || stat.overrun > 0);
+    }
+
+	/* check if input not ready */
+    if (inputcount < intransfersize)
+    {
+	/* fprintf(stderr, "no adc; count %d, free %d, call %d, xfer %d\n",
+	    stat.count, 
+	    stat.free,
+	    callno, xferno); */
+	if (outchannels > 0)
+	{
+	    /* if there's no input but output is hungry, feed output. */
+	    while (outputcount < (linux_advance_samples + ALSA_JITTER)
+		* outbytesperframe)
+	    {
+	    	if (!loggederror)
+		    sys_log_error(ERR_RESYNC), loggederror = 1;
+		memset(alsa_buf, 0, outtransfersize);
+		result = snd_pcm_write(alsa_device[devno].handle,
+	    	    alsa_buf, outtransfersize);
+		if (result < outtransfersize)
+		{
+#ifdef DEBUG_ALSA_XFER
+		    if (result >= 0 || errno == EAGAIN)
+			fprintf(stderr, "ALSA: write returned %d of %d\n",
+			    result, outtransfersize);
+		    else fprintf(stderr, "ALSA: write: %s\n",
+	    		snd_strerror(errno));
+		    fprintf(stderr,
+		    	"inputcount %d, outputcount %d, outbufsize %d\n",
+		    	inputcount, outputcount, 
+	    	    	    (ALSA_EXTRABUFFER + linux_advance_samples)
+	    	    	    	* alsa_samplewidth * outchannels);
+#endif
+		    return (SENDDACS_NO);
+		}
+    		stat.channel = SND_PCM_CHANNEL_PLAYBACK;
+		if (alsaerror =
+		    snd_pcm_channel_status(alsa_device[devno].handle,
+		    	&stat))
+		{
+		    fprintf(stderr, "snd_pcm_channel_status (output): %s\n",
+	    		snd_strerror(alsaerror));
+		    return (SENDDACS_NO);
+		}
+		outputcount = stat.count;
+	    }
+	}
+
+	return SENDDACS_NO;
+    }
+
+    	/* if output buffer has at least linux_advance_samples in it, we're
+	not ready for this batch. */
+    if (outputcount > linux_advance_samples * outbytesperframe)
+    {
+    	if (inchannels > 0)
+	{
+    	    while (inputcount > (DACBLKSIZE + ALSA_JITTER) * outbytesperframe)
+	    {
+	    	if (!loggederror)
+		    sys_log_error(ERR_RESYNC), loggederror = 1;
+	    	devno = 0;
+		result = snd_pcm_read(alsa_device[devno].handle, alsa_buf,
+		    intransfersize);
+		if (result < intransfersize)
+		{
+#ifdef DEBUG_ALSA_XFER
+		    if (result < 0)
+    	    	    	fprintf(stderr,
+	    		"snd_pcm_read %d %d: %s\n", 
+	    		callno, xferno, snd_strerror(errno));
+		    else fprintf(stderr,
+	    		"snd_pcm_read %d %d returned only %d\n", 
+	    		callno, xferno, result);
+		    fprintf(stderr,
+		    	"inputcount %d, outputcount %d, inbufsize %d\n",
+		    	inputcount, outputcount, 
+	    	    	    (ALSA_EXTRABUFFER + linux_advance_samples)
+	    	    	    	* alsa_samplewidth * inchannels);
+#endif
+		    return (SENDDACS_NO);
+		}
+    		devno = 0;
+    		stat.channel = SND_PCM_CHANNEL_CAPTURE;
+		if (alsaerror =
+		    snd_pcm_channel_status(alsa_device[devno].handle,
+		    	&stat))
+		{
+		    fprintf(stderr, "snd_pcm_channel_status (input): %s\n",
+	    		snd_strerror(alsaerror));
+		    return (SENDDACS_NO);
+		}
+		inputcount = stat.count;
+		inputlate = (stat.underrun > 0 || stat.overrun > 0);
+	    }
+	    return (SENDDACS_NO);
+    	}
+    }
+    if (sys_getrealtime() - timenow > 0.002)
+    {
+#ifdef DEBUG_ALSA_XFER
+    	fprintf(stderr, "check %d took %d msec\n",
+	    callno, (int)(1000 * (timenow - timelast))), fflush(stderr);
+#endif
+    	sys_log_error(ERR_DACSLEPT);
+    	timenow = sys_getrealtime();
+    }
+    if (inputlate || outputlate)
+    	sys_log_error(ERR_DATALATE);    
+
+    /* do output */
+    	    /* this "for" loop won't work for more than one device. */
+    for (devno = 0, fp = sys_soundout; devno < (outchannels > 0); devno++, 
+       fp += 128)
+    {
+    	if (alsa_samplewidth == 4)
+	{
+	    for (i = 0, fp1 = fp; i < outchannels; i++, fp1 += DACBLKSIZE)
+	    {
+		for (j = i, k = DACBLKSIZE, fp2 = fp1; k--;
+		    j += outchannels, fp2++)
+	        {
+		    float s1 = *fp2 * INT32_MAX;
+		    ((t_alsa_sample32 *)alsa_buf)[j] = CLIP32(s1);
+    	    	} 
+	    }
+	}
+	else
+	{
+	    for (i = 0, fp1 = fp; i < outchannels; i++, fp1 += DACBLKSIZE)
+	    {
+		for (j = i, k = DACBLKSIZE, fp2 = fp1; k--;
+		    j += outchannels, fp2++)
+		{
+		    int s = *fp2 * 32767.;
+		    if (s > 32767)
+			s = 32767;
+		    else if (s < -32767)
+			s = -32767;
+		    ((t_alsa_sample16 *)alsa_buf)[j] = s;
+		}
+	    }
+	}
+	
+	result = snd_pcm_write(alsa_device[devno].handle, alsa_buf,
+	    outtransfersize);
+	if (result < outtransfersize)
+	{
+#ifdef DEBUG_ALSA_XFER
+	    if (result >= 0 || errno == EAGAIN)
+		fprintf(stderr, "ALSA: write returned %d of %d\n",
+		    result, outtransfersize);
+	    else fprintf(stderr, "ALSA: write: %s\n",
+	    	snd_strerror(errno));
+	    fprintf(stderr,
+		"inputcount %d, outputcount %d, outbufsize %d\n",
+		inputcount, outputcount, 
+	    	    (ALSA_EXTRABUFFER + linux_advance_samples)
+	    	    	* alsa_samplewidth * outchannels);
+#endif
+    	    sys_log_error(ERR_DACSLEPT);
+	    return (SENDDACS_NO);
+	}
+    }
+    	/* zero out the output buffer */
+    memset(sys_soundout, 0, DACBLKSIZE * sizeof(*sys_soundout) *
+    	linux_outchannels);
+    if (sys_getrealtime() - timenow > 0.002)
+    {
+#if DEBUG_ALSA_XFER
+    	fprintf(stderr, "output %d took %d msec\n",
+	    callno, (int)(1000 * (timenow - timelast))), fflush(stderr);
+#endif
+    	timenow = sys_getrealtime();
+    	sys_log_error(ERR_DACSLEPT);
+    }
+
+    /* do input */
+    for (devno = 0, fp = sys_soundin; devno < (linux_inchannels > 0); devno++, 
+        fp += 128)
+    {
+	result = snd_pcm_read(alsa_device[devno].handle, alsa_buf,
+	    intransfersize);
+	if (result < intransfersize)
+	{
+#ifdef DEBUG_ALSA_XFER
+	    if (result < 0)
+    	    	fprintf(stderr,
+	    	"snd_pcm_read %d %d: %s\n", 
+	    	callno, xferno, snd_strerror(errno));
+	    else fprintf(stderr,
+	    	"snd_pcm_read %d %d returned only %d\n", 
+	    	callno, xferno, result);
+	    fprintf(stderr,
+		"inputcount %d, outputcount %d, inbufsize %d\n",
+		inputcount, outputcount, 
+	    	    (ALSA_EXTRABUFFER + linux_advance_samples)
+	    	    	* alsa_samplewidth * inchannels);
+#endif
+    	    sys_log_error(ERR_ADCSLEPT);
+	    return (SENDDACS_NO);
+	}
+	if (alsa_samplewidth == 4)
+	{
+	    for (i = 0, fp1 = fp; i < inchannels; i++, fp1 += DACBLKSIZE)
+	    {
+		for (j = i, k = DACBLKSIZE, fp2 = fp1; k--;
+		    j += inchannels, fp2++)
+	    	    *fp2 = (float) ((t_alsa_sample32 *)alsa_buf)[j]
+		    	* (1./ INT32_MAX);
+	    }
+	}
+	else
+	{
+	    for (i = 0, fp1 = fp; i < inchannels; i++, fp1 += DACBLKSIZE)
+	    {
+		for (j = i, k = DACBLKSIZE, fp2 = fp1; k--; j += inchannels, fp2++)
+	    	    *fp2 = (float) ((t_alsa_sample16 *)alsa_buf)[j]
+		    	* 3.051850e-05;
+	    }
+    	}
+    }
+    xferno++;
+    if (sys_getrealtime() - timenow > 0.002)
+    {
+#ifdef DEBUG_ALSA_XFER
+    	fprintf(stderr, "routine took %d msec\n",
+	    (int)(1000 * (sys_getrealtime() - timenow)));
+#endif
+    	sys_log_error(ERR_ADCSLEPT);
+    }
+    return SENDDACS_YES;
+}
+
+#endif				/* ALSA99 */
+
+/* support for ALSA pcmv2 api by Karl MacMillan<karlmac@peabody.jhu.edu> */ 
+
+#ifdef ALSA01
+
+static void check_error(int err, const char *why)
+{
+    if (err < 0)
+	fprintf(stderr, "%s: %s\n", why, snd_strerror(err));
+}
+
+static int alsa_open_audio(int wantinchans, int wantoutchans, int srate)
+{
+    int err, inchans = 0, outchans = 0, subunitdir;
+    char devname[512];
+    snd_pcm_hw_params_t* hw_params;
+    snd_pcm_sw_params_t* sw_params;
+    snd_output_t* out;
+    int frag_size = (linux_fragsize ? linux_fragsize : ALSA_DEFFRAGSIZE);
+    int nfrags, i;
+    short* tmp_buf;
+    unsigned int tmp_uint;
+    int advwas = sys_schedadvance;
+
+    if (linux_nfragment)
+    {
+    	nfrags = linux_nfragment;
+    	sys_schedadvance = (frag_size * linux_nfragment * 1.0e6) / srate;
+    }
+    else nfrags = sys_schedadvance * (float)srate / (1e6 * frag_size);
+
+    if (sys_verbose || (sys_schedadvance != advwas))
+    	post("audio buffer set to %d", (int)(0.001 * sys_schedadvance));
+    if (wantinchans || wantoutchans)
+    	alsa_checkversion();
+    if (wantinchans)
+    {
+	err = snd_pcm_open(&alsa_device.inhandle, alsa_devname,
+			   SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
+
+	check_error(err, "snd_pcm_open (input)");
+	if (err < 0)
+	    inchans = 0;
+	else
+	{
+	    inchans = wantinchans;
+	    snd_pcm_nonblock(alsa_device.inhandle, 1);
+	}
+    }
+    if (wantoutchans)
+    {
+	err = snd_pcm_open(&alsa_device.outhandle, alsa_devname,
+			   SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
+
+	check_error(err, "snd_pcm_open (output)");
+	if (err < 0)
+	    outchans = 0;
+	else
+	{
+	    outchans = wantoutchans;
+	    snd_pcm_nonblock(alsa_device.outhandle, 1);
+	}
+    }
+    if (inchans)
+    {
+    	if (sys_verbose)
+	    post("opening sound input...");
+	err = snd_pcm_hw_params_malloc(&hw_params);
+	check_error(err, "snd_pcm_hw_params_malloc (input)");
+    
+	// get the default params
+	err = snd_pcm_hw_params_any(alsa_device.inhandle, hw_params);
+	check_error(err, "snd_pcm_hw_params_any (input)");
+	// set interleaved access - FIXME deal with other access types
+	err = snd_pcm_hw_params_set_access(alsa_device.inhandle, hw_params,
+					   SND_PCM_ACCESS_RW_INTERLEAVED);
+	check_error(err, "snd_pcm_hw_params_set_access (input)");
+	// Try to set 32 bit format first
+	err = snd_pcm_hw_params_set_format(alsa_device.inhandle, hw_params,
+					   SND_PCM_FORMAT_S32);
+	if (err < 0)
+	{
+	    /* fprintf(stderr,
+	    	"PD-ALSA: 32 bit format not available - using 16\n"); */
+	    err = snd_pcm_hw_params_set_format(alsa_device.inhandle, hw_params,
+					       SND_PCM_FORMAT_S16);
+	    check_error(err, "snd_pcm_hw_params_set_format (input)");
+	    alsa_samplewidth = 2;
+	}
+	else
+	{
+	    alsa_samplewidth = 4;
+	}
+	post("Sample width set to %d bytes", alsa_samplewidth);
+	// set the subformat
+	err = snd_pcm_hw_params_set_subformat(alsa_device.inhandle, hw_params,
+					      SND_PCM_SUBFORMAT_STD);
+	check_error(err, "snd_pcm_hw_params_set_subformat (input)");
+	// set the number of channels
+	tmp_uint = inchans;
+	err = snd_pcm_hw_params_set_channels_min(alsa_device.inhandle,
+						 hw_params, &tmp_uint);
+	check_error(err, "snd_pcm_hw_params_set_channels (input)");
+	if (tmp_uint != (unsigned)inchans)
+	    post("ALSA: set input channels to %d", tmp_uint);
+	inchans = tmp_uint;
+	// set the sampling rate
+	err = snd_pcm_hw_params_set_rate_min(alsa_device.inhandle, hw_params,
+					     &srate, 0);
+	check_error(err, "snd_pcm_hw_params_set_rate_min (input)");
+#if 0
+    	err = snd_pcm_hw_params_get_rate(hw_params, &subunitdir);
+	post("input sample rate %d", err);
+#endif
+	// set the period - ie frag size
+	// post("fragsize a %d", frag_size);
+
+    	    /* LATER try this to get a recommended period size...
+	     right now, it trips an assertion failure in ALSA lib */
+#if 0
+    	post("input period was %d, min %d, max %d\n",
+	    snd_pcm_hw_params_get_period_size(hw_params, 0),
+	    snd_pcm_hw_params_get_period_size_min(hw_params, 0),
+	    snd_pcm_hw_params_get_period_size_max(hw_params, 0));
+#endif	    
+	err = snd_pcm_hw_params_set_period_size_near(alsa_device.inhandle,
+						    hw_params, 
+						    (snd_pcm_uframes_t)
+						    frag_size, 0);
+	check_error(err, "snd_pcm_hw_params_set_period_size_near (input)");
+	// post("fragsize b %d", frag_size);
+	// set the number of periods - ie numfrags
+	// post("nfrags a %d", nfrags);
+	err = snd_pcm_hw_params_set_periods_near(alsa_device.inhandle,
+						hw_params, nfrags, 0);
+	check_error(err, "snd_pcm_hw_params_set_periods_near (input)");
+	// set the buffer size
+	err = snd_pcm_hw_params_set_buffer_size_near(alsa_device.inhandle,
+						hw_params, nfrags * frag_size);
+	check_error(err, "snd_pcm_hw_params_set_buffer_size_near (input)");
+
+	err = snd_pcm_hw_params(alsa_device.inhandle, hw_params);
+	check_error(err, "snd_pcm_hw_params (input)");
+	
+	snd_pcm_hw_params_free(hw_params);
+	
+	err = snd_pcm_sw_params_malloc(&sw_params);
+	check_error(err, "snd_pcm_sw_params_malloc (input)");
+	err = snd_pcm_sw_params_current(alsa_device.inhandle, sw_params);
+	check_error(err, "snd_pcm_sw_params_current (input)");
+#if 1
+	err = snd_pcm_sw_params_set_start_mode(alsa_device.inhandle, sw_params,
+					       SND_PCM_START_EXPLICIT);
+	check_error(err, "snd_pcm_sw_params_set_start_mode (input)");
+	err = snd_pcm_sw_params_set_xrun_mode(alsa_device.inhandle, sw_params,
+					      SND_PCM_XRUN_NONE);
+	check_error(err, "snd_pcm_sw_params_set_xrun_mode (input)");
+#else
+	err = snd_pcm_sw_params_set_start_threshold(alsa_device.inhandle,
+	    sw_params, nfrags * frag_size);
+	check_error(err, "snd_pcm_sw_params_set_start_threshold (input)");
+	err = snd_pcm_sw_params_set_stop_threshold(alsa_device.inhandle,
+	    sw_params, 1);
+	check_error(err, "snd_pcm_sw_params_set_stop_threshold (input)");
+#endif
+
+	err = snd_pcm_sw_params_set_avail_min(alsa_device.inhandle, sw_params,
+					      frag_size);
+	check_error(err, "snd_pcm_sw_params_set_avail_min (input)");
+	err = snd_pcm_sw_params(alsa_device.inhandle, sw_params);
+	check_error(err, "snd_pcm_sw_params (input)");
+	
+	snd_pcm_sw_params_free(sw_params);
+	
+	snd_output_stdio_attach(&out, stderr, 0);
+#if 0
+	if (sys_verbose)
+	{
+	    snd_pcm_dump_hw_setup(alsa_device.inhandle, out);
+	    snd_pcm_dump_sw_setup(alsa_device.inhandle, out);
+    	}
+#endif
+    }
+
+    if (outchans)
+    {
+    	int foo;
+    	if (sys_verbose)
+	    post("opening sound output...");
+	err = snd_pcm_hw_params_malloc(&hw_params);
+	check_error(err, "snd_pcm_sw_params (output)");
+
+	// get the default params
+	err = snd_pcm_hw_params_any(alsa_device.outhandle, hw_params);
+	check_error(err, "snd_pcm_hw_params_any (output)");
+	// set interleaved access - FIXME deal with other access types
+	err = snd_pcm_hw_params_set_access(alsa_device.outhandle, hw_params,
+					   SND_PCM_ACCESS_RW_INTERLEAVED);
+	check_error(err, "snd_pcm_hw_params_set_access (output)");
+	// Try to set 32 bit format first
+	err = snd_pcm_hw_params_set_format(alsa_device.outhandle, hw_params,
+					     SND_PCM_FORMAT_S32);
+	if (err < 0)
+	{
+	    err = snd_pcm_hw_params_set_format(alsa_device.outhandle,
+					       hw_params,SND_PCM_FORMAT_S16);
+	    check_error(err, "snd_pcm_hw_params_set_format (output)");
+	    /* fprintf(stderr,
+	    	"PD-ALSA: 32 bit format not available - using 16\n"); */
+	    alsa_samplewidth = 2;
+	}
+	else
+	{
+	    alsa_samplewidth = 4;
+	}
+	// set the subformat
+	err = snd_pcm_hw_params_set_subformat(alsa_device.outhandle, hw_params,
+					      SND_PCM_SUBFORMAT_STD);
+	check_error(err, "snd_pcm_hw_params_set_subformat (output)");
+	// set the number of channels
+	tmp_uint = outchans;
+	err = snd_pcm_hw_params_set_channels_min(alsa_device.outhandle,
+						 hw_params, &tmp_uint);
+	check_error(err, "snd_pcm_hw_params_set_channels (output)");
+	if (tmp_uint != (unsigned)outchans)
+    	    post("alsa: set output channels to %d", tmp_uint);
+    	outchans = tmp_uint;
+	// set the sampling rate
+	err = snd_pcm_hw_params_set_rate_min(alsa_device.outhandle, hw_params,
+					     &srate, 0);
+	check_error(err, "snd_pcm_hw_params_set_rate_min (output)");
+#if 0
+    	err = snd_pcm_hw_params_get_rate(hw_params, &subunitdir);
+	post("output sample rate %d", err);
+#endif
+	// set the period - ie frag size
+#if 0
+    	post("output period was %d, min %d, max %d\n",
+	    snd_pcm_hw_params_get_period_size(hw_params, 0),
+	    snd_pcm_hw_params_get_period_size_min(hw_params, 0),
+	    snd_pcm_hw_params_get_period_size_max(hw_params, 0));
+#endif
+	// post("fragsize c %d", frag_size);
+	err = snd_pcm_hw_params_set_period_size_near(alsa_device.outhandle,
+						    hw_params,
+						    (snd_pcm_uframes_t)
+						    frag_size, 0);
+	// post("fragsize d %d", frag_size);
+	check_error(err, "snd_pcm_hw_params_set_period_size_near (output)");
+	// set the number of periods - ie numfrags
+	err = snd_pcm_hw_params_set_periods_near(alsa_device.outhandle,
+						hw_params, nfrags, 0);
+	check_error(err, "snd_pcm_hw_params_set_periods_near (output)");
+	// set the buffer size
+	err = snd_pcm_hw_params_set_buffer_size_near(alsa_device.outhandle,
+	    hw_params, nfrags * frag_size);
+
+	check_error(err, "snd_pcm_hw_params_set_buffer_size_near (output)");
+	
+	err = snd_pcm_hw_params(alsa_device.outhandle, hw_params);
+	check_error(err, "snd_pcm_hw_params (output)");
+	
+	snd_pcm_hw_params_free(hw_params);
+
+	err = snd_pcm_sw_params_malloc(&sw_params);
+	check_error(err, "snd_pcm_sw_params_malloc (output)");
+	err = snd_pcm_sw_params_current(alsa_device.outhandle, sw_params);
+	check_error(err, "snd_pcm_sw_params_current (output)");
+#if 1
+	err = snd_pcm_sw_params_set_start_mode(alsa_device.outhandle,
+					       sw_params,
+					       SND_PCM_START_EXPLICIT);
+	check_error(err, "snd_pcm_sw_params_set_start_mode (output)");
+	err = snd_pcm_sw_params_set_xrun_mode(alsa_device.outhandle, sw_params,
+					      SND_PCM_XRUN_NONE);
+	check_error(err, "snd_pcm_sw_params_set_xrun_mode (output)");
+#else
+	err = snd_pcm_sw_params_set_start_threshold(alsa_device.inhandle,
+	    sw_params, nfrags * frag_size);
+	check_error(err, "snd_pcm_sw_params_set_start_threshold (output)");
+	err = snd_pcm_sw_params_set_stop_threshold(alsa_device.inhandle,
+	    sw_params, 1);
+	check_error(err, "snd_pcm_sw_params_set_stop_threshold (output)");
+#endif
+
+	err = snd_pcm_sw_params_set_avail_min(alsa_device.outhandle, sw_params,
+					      frag_size);
+	check_error(err, "snd_pcm_sw_params_set_avail_min (output)");
+	err = snd_pcm_sw_params(alsa_device.outhandle, sw_params);
+	check_error(err, "snd_pcm_sw_params (output)");
+	
+	snd_pcm_sw_params_free(sw_params);
+	
+	snd_output_stdio_attach(&out, stderr, 0);
+#if 0
+	if (sys_verbose)
+	{
+	    snd_pcm_dump_hw_setup(alsa_device.outhandle, out);
+	    snd_pcm_dump_sw_setup(alsa_device.outhandle, out);
+    	}
+#endif
+    }
+
+    linux_setsr(srate);
+    linux_setch(inchans, outchans);
+
+    if (inchans)
+      snd_pcm_prepare(alsa_device.inhandle);
+    if (outchans)
+      snd_pcm_prepare(alsa_device.outhandle);
+
+    // if duplex we can link the channels so they start together
+    if (inchans && outchans)
+      snd_pcm_link(alsa_device.inhandle, alsa_device.outhandle);
+
+    // set up the buffer
+    if (outchans > inchans) 
+	alsa_buf = (short *)calloc(sizeof(char) * alsa_samplewidth, DACBLKSIZE
+				  * outchans);
+    else
+	alsa_buf = (short *)calloc(sizeof(char) * alsa_samplewidth, DACBLKSIZE
+				* inchans);
+    // fill the buffer with silence
+    if (outchans)
+    {
+	i = nfrags + 1;
+	while (i--)
+	    snd_pcm_writei(alsa_device.outhandle, alsa_buf, frag_size);
+    }
+
+    // set up the status variables
+    err = snd_pcm_status_malloc(&in_status);
+    check_error(err, "snd_pcm_status_malloc");
+    err = snd_pcm_status_malloc(&out_status);
+    check_error(err, "snd_pcm_status_malloc");
+
+    // start the device
+#if 1
+    if (outchans)
+    {
+	err = snd_pcm_start(alsa_device.outhandle);
+	check_error(err, "snd_pcm_start");
+    }
+    else if (inchans)
+    {
+	err = snd_pcm_start(alsa_device.inhandle);
+	check_error(err, "snd_pcm_start");
+    }
+#endif
+	    
+    return 0;
+}
+
+void alsa_close_audio(void)
+{
+    int err;
+    if (linux_inchannels)
+    {
+	err = snd_pcm_close(alsa_device.inhandle);
+	check_error(err, "snd_pcm_close (input)");
+    }
+    if (linux_outchannels)
+    {
+	err = snd_pcm_close(alsa_device.outhandle);
+	check_error(err, "snd_pcm_close (output)");
+    }
+}
+
+// #define DEBUG_ALSA_XFER
+
+int alsa_send_dacs(void)
+{
+    static int16_t *sp;
+    static int xferno = 0;
+    static int callno = 0;
+    static double timenow;
+    double timelast;
+    t_sample *fp, *fp1, *fp2;
+    int i, j, k, err, devno = 0;
+    int inputcount = 0, outputcount = 0, inputlate = 0, outputlate = 0;
+    int result; 
+    int inchannels = linux_inchannels;
+    int outchannels = linux_outchannels;
+    unsigned int intransfersize = DACBLKSIZE;
+    unsigned int outtransfersize = DACBLKSIZE;
+
+    // get the status
+    if (!inchannels && !outchannels)
+    {
+	return SENDDACS_NO;
+    }
+    
+    timelast = timenow;
+    timenow = sys_getrealtime();
+
+#ifdef DEBUG_ALSA_XFER
+    if (timenow - timelast > 0.050)
+    	fprintf(stderr, "(%d)",
+	    (int)(1000 * (timenow - timelast))), fflush(stderr);
+#endif
+
+    callno++;
+
+    if (inchannels)
+    {
+	snd_pcm_status(alsa_device.inhandle, in_status);
+	if (snd_pcm_status_get_avail(in_status) < intransfersize)
+	    return SENDDACS_NO;
+    }
+    if (outchannels)
+    {
+	snd_pcm_status(alsa_device.outhandle, out_status);
+	if (snd_pcm_status_get_avail(out_status) < outtransfersize)
+	    return SENDDACS_NO;
+    }
+
+    /* do output */
+    if (outchannels)
+    {
+	fp = sys_soundout;
+	if (alsa_samplewidth == 4)
+	{
+	    for (i = 0, fp1 = fp; i < outchannels; i++, fp1 += DACBLKSIZE)
+	    {
+		for (j = i, k = DACBLKSIZE, fp2 = fp1; k--;
+		     j += outchannels, fp2++)
+		{
+		    float s1 = *fp2 * INT32_MAX;
+		    ((t_alsa_sample32 *)alsa_buf)[j] = CLIP32(s1);
+		} 
+	    }
+	}
+	else
+	{
+	    for (i = 0, fp1 = fp; i < outchannels; i++, fp1 += DACBLKSIZE)
+	    {
+		for (j = i, k = DACBLKSIZE, fp2 = fp1; k--;
+		     j += outchannels, fp2++)
+		{
+		    int s = *fp2 * 32767.;
+		    if (s > 32767)
+			s = 32767;
+		    else if (s < -32767)
+			s = -32767;
+		    ((t_alsa_sample16 *)alsa_buf)[j] = s;
+		}
+	    }
+	}
+
+	result = snd_pcm_writei(alsa_device.outhandle, alsa_buf,
+				outtransfersize);
+	if (result != (int)outtransfersize)
+	{
+    #ifdef DEBUG_ALSA_XFER
+	    if (result >= 0 || errno == EAGAIN)
+		fprintf(stderr, "ALSA: write returned %d of %d\n",
+			result, outtransfersize);
+	    else fprintf(stderr, "ALSA: write: %s\n",
+			 snd_strerror(errno));
+	    fprintf(stderr,
+		    "inputcount %d, outputcount %d, outbufsize %d\n",
+		    inputcount, outputcount, 
+		    (ALSA_EXTRABUFFER + linux_advance_samples)
+		    * alsa_samplewidth * outchannels);
+    #endif
+	    sys_log_error(ERR_DACSLEPT);
+	    return (SENDDACS_NO);
+	}
+
+	/* zero out the output buffer */
+	memset(sys_soundout, 0, DACBLKSIZE * sizeof(*sys_soundout) *
+	       linux_outchannels);
+	if (sys_getrealtime() - timenow > 0.002)
+	{
+    #ifdef DEBUG_ALSA_XFER
+    	    fprintf(stderr, "output %d took %d msec\n",
+		    callno, (int)(1000 * (timenow - timelast))), fflush(stderr);
+    #endif
+    	    timenow = sys_getrealtime();
+    	    sys_log_error(ERR_DACSLEPT);
+	}
+    }
+    /* do input */
+    if (linux_inchannels)
+    {
+	result = snd_pcm_readi(alsa_device.inhandle, alsa_buf, intransfersize);
+	if (result < (int)intransfersize)
+	{
+#ifdef DEBUG_ALSA_XFER
+	    if (result < 0)
+    	    	fprintf(stderr,
+			"snd_pcm_read %d %d: %s\n", 
+			callno, xferno, snd_strerror(errno));
+	    else fprintf(stderr,
+			 "snd_pcm_read %d %d returned only %d\n", 
+			 callno, xferno, result);
+	    fprintf(stderr,
+		    "inputcount %d, outputcount %d, inbufsize %d\n",
+		    inputcount, outputcount, 
+	    	    (ALSA_EXTRABUFFER + linux_advance_samples)
+		    * alsa_samplewidth * inchannels);
+#endif
+    	    sys_log_error(ERR_ADCSLEPT);
+	    return (SENDDACS_NO);
+	}
+	fp = sys_soundin;
+	if (alsa_samplewidth == 4)
+	{
+	    for (i = 0, fp1 = fp; i < inchannels; i++, fp1 += DACBLKSIZE)
+	    {
+		for (j = i, k = DACBLKSIZE, fp2 = fp1; k--;
+		     j += inchannels, fp2++)
+	    	    *fp2 = (float) ((t_alsa_sample32 *)alsa_buf)[j]
+		    	* (1./ INT32_MAX);
+	    }
+	}
+	else
+	{
+	    for (i = 0, fp1 = fp; i < inchannels; i++, fp1 += DACBLKSIZE)
+	    {
+		for (j = i, k = DACBLKSIZE, fp2 = fp1; k--; j += inchannels,
+		    fp2++)
+	    	    	*fp2 = (float) ((t_alsa_sample16 *)alsa_buf)[j]
+		    	    * 3.051850e-05;
+	    }
+    	}
+    }
+    xferno++;
+    if (sys_getrealtime() - timenow > 0.002)
+    {
+#ifdef DEBUG_ALSA_XFER
+    	fprintf(stderr, "routine took %d msec\n",
+	    (int)(1000 * (sys_getrealtime() - timenow)));
+#endif
+    	sys_log_error(ERR_ADCSLEPT);
+    }
+    return SENDDACS_YES;
+}
+
+void alsa_resync( void)
+{
+    int i, result;
+    memset(alsa_buf, 0,
+    	sizeof(char) * alsa_samplewidth * DACBLKSIZE * linux_outchannels);
+    for (i = 0; i < 100; i++)
+    {
+	result = snd_pcm_writei(alsa_device.outhandle, alsa_buf,
+	    DACBLKSIZE);
+	if (result != (int)DACBLKSIZE)
+	    break;
+    }
+    post("%d written", i);
+}
+
+
+#endif				/* ALSA01 */
+
+/***************************************************
+ *  Code using the RME_9652 API
+ */ 
+
+    /*
+    trying native device for future use of native memory map:
+    because of busmaster if you dont use the dac, you dont need 
+    CPU Power und also no nearly no CPU-Power is used in device
+
+    since always all DAs and ADs are synced (else they wouldnt work)
+    we use linux_dacs[0], linux_adcs[0]
+    */
+
+#ifdef RME_HAMMERFALL
+
+#define RME9652_MAX_CHANNELS 26
+
+#define RME9652_CH_PER_NATIVE_DEVICE 1
+
+static int rme9652_dac_devices[RME9652_MAX_CHANNELS];
+static int rme9652_adc_devices[RME9652_MAX_CHANNELS];
+
+static char rme9652_dsp_dac[] = "/dev/rme9652/C0da%d"; 
+static char rme9652_dsp_adc[] = "/dev/rme9652/C0ad%d"; 
+
+static int num_of_rme9652_dac = 0;
+static int num_of_rme9652_adc = 0;
+
+static int rme_soundindevonset = 1;
+static int rme_soundoutdevonset = 1;
+
+void rme_soundindev(int which)
+{
+    rme_soundindevonset = which;
+}
+
+void rme_soundoutdev(int which)
+{
+    rme_soundoutdevonset = which;
+}
+
+void rme9652_configure(int dev, int fd,int srate, int dac) {
+  int orig, param, nblk;
+  audio_buf_info ainfo;
+  orig = param = srate; 
+
+  /* samplerate */
+
+  fprintf(stderr,"RME9652: configuring %d, fd=%d, sr=%d\n, dac=%d\n",
+			 dev,fd,srate,dac);
+
+  if (ioctl(fd,SNDCTL_DSP_SPEED,&param) == -1)
+	 fprintf(stderr,"RME9652: Could not set sampling rate for device\n");
+  else if( orig != param )
+	 fprintf(stderr,"RME9652: sampling rate: wanted %d, got %d\n",
+				orig, param );				
+  
+  // setting the correct samplerate (could be different than expected)     
+  srate = param;
+
+
+  /* setting resolution */
+
+  /* use ctrlpanel to change, experiment, channels 1 */
+
+  orig = param = AFMT_S16_BE;
+  if (ioctl(fd,SNDCTL_DSP_SETFMT,&param) == -1)
+	 fprintf(stderr,"RME9652: Could not set DSP format\n");
+  else if( orig != param )
+    fprintf(stderr,"RME9652: DSP format: wanted %d, got %d\n",orig, param );
+
+  /* setting channels */
+  orig = param = RME9652_CH_PER_NATIVE_DEVICE;
+
+  if (ioctl(fd,SNDCTL_DSP_CHANNELS,&param) == -1)
+	 fprintf(stderr,"RME9652: Could not set channels\n");
+  else if( orig != param )
+    fprintf(stderr,"RME9652: num channels: wanted %d, got %d\n",orig, param );
+
+  if (dac)
+    {
+
+ /* use "free space" to learn the buffer size.  Normally you
+	 should set this to your own desired value; but this seems not
+	 to be implemented uniformly across different sound cards.  LATER
+	 we should figure out what to do if the requested scheduler advance
+	 is greater than this buffer size; for now, we just print something
+	 out.  */
+
+	if( ioctl(linux_dacs[0].d_fd, SOUND_PCM_GETOSPACE,&ainfo) < 0 )
+	  fprintf(stderr,"RME: ioctl on output device %d failed",dev);
+
+	linux_dacs[0].d_bufsize = ainfo.bytes;
+
+	fprintf(stderr,"RME: ioctl SOUND_PCM_GETOSPACE says %d buffsize\n",
+			  linux_dacs[0].d_bufsize);
+
+
+	if (linux_advance_samples * (RME_SAMPLEWIDTH *
+	    RME9652_CH_PER_NATIVE_DEVICE) 
+		 > linux_dacs[0].d_bufsize - RME_BYTESPERCHAN)
+	  {
+		 fprintf(stderr,
+		    "RME: requested audio buffer size %d limited to %d\n",
+		    linux_advance_samples 
+		    * (RME_SAMPLEWIDTH * RME9652_CH_PER_NATIVE_DEVICE),
+		    linux_dacs[0].d_bufsize);
+    	    	linux_advance_samples =
+		    (linux_dacs[0].d_bufsize - RME_BYTESPERCHAN) 
+		    / (RME_SAMPLEWIDTH *RME9652_CH_PER_NATIVE_DEVICE);
+	  }
+    }
+}
+
+ 
+int rme9652_open_audio(int inchans, int outchans,int srate)
+{  
+    int orig;
+    int tmp;
+    int inchannels = 0,outchannels = 0;
+    char devname[20];
+    int i;
+    char buf[RME_SAMPLEWIDTH*RME9652_CH_PER_NATIVE_DEVICE*DACBLKSIZE];
+    int num_devs = 0;
+    audio_buf_info ainfo;
+
+    linux_nindevs = linux_noutdevs = 0;
+
+    if (sys_verbose)
+    	post("RME open");
+    /* First check if we can  */
+    /* open the write ports	*/
+
+    for (num_devs=0; outchannels < outchans; num_devs++)
+    {
+	int channels = RME9652_CH_PER_NATIVE_DEVICE;
+
+	sprintf(devname, rme9652_dsp_dac, num_devs + rme_soundoutdevonset);
+	if ((tmp = open(devname,O_WRONLY)) == -1) 
+	{
+	    DEBUG(fprintf(stderr,"RME9652: failed to open %s writeonly\n",
+    	    	devname);)
+	    break;
+	}
+	DEBUG(fprintf(stderr,"RME9652: out device Nr. %d (%d) on %s\n",
+    	    linux_noutdevs+1,tmp,devname);)
+
+	if (outchans > outchannels)
+	{
+	    rme9652_dac_devices[linux_noutdevs] = tmp;
+	    linux_noutdevs++;
+	    outchannels += channels;
+	}
+	else close(tmp);
+    }
+    if( linux_noutdevs > 0)
+	linux_dacs[0].d_fd =  rme9652_dac_devices[0];
+
+    /* Second check if we can  */
+    /* open the read ports	*/
+
+    for (num_devs=0; inchannels < inchans; num_devs++)
+    {
+	int channels = RME9652_CH_PER_NATIVE_DEVICE;
+
+	sprintf(devname, rme9652_dsp_adc, num_devs+rme_soundindevonset);
+
+	if ((tmp = open(devname,O_RDONLY)) == -1) 
+	{
+	    DEBUG(fprintf(stderr,"RME9652: failed to open %s readonly\n",
+	    	devname);)
+	    break;
+	}
+	DEBUG(fprintf(stderr,"RME9652: in device Nr. %d (%d) on %s\n",
+	    linux_nindevs+1,tmp,devname);)
+
+	if (inchans > inchannels)
+	{
+	    rme9652_adc_devices[linux_nindevs] = tmp;
+	    linux_nindevs++;
+	    inchannels += channels;
+	}
+	else
+	     close(tmp);
+    }
+    if(linux_nindevs > 0)
+	linux_adcs[0].d_fd = rme9652_adc_devices[0];
+
+    /* configure soundcards */
+
+	 rme9652_configure(0, linux_adcs[0].d_fd,srate, 0);
+	 rme9652_configure(0, linux_dacs[0].d_fd,srate, 1);
+    
+	 /* We have to do a read to start the engine. This is 
+		 necessary because sys_send_dacs waits until the input
+		 buffer is filled and only reads on a filled buffer.
+		 This is good, because it's a way to make sure that we
+		 will not block */
+	 
+    if (linux_nindevs)
+    {
+	fprintf(stderr,("RME9652: starting read engine ... "));
+
+
+	for (num_devs=0; num_devs < linux_nindevs; num_devs++) 
+	  read(rme9652_adc_devices[num_devs],
+	    buf, RME_SAMPLEWIDTH* RME9652_CH_PER_NATIVE_DEVICE*
+		DACBLKSIZE);
+
+
+	for (num_devs=0; num_devs < linux_noutdevs; num_devs++) 
+	  write(rme9652_dac_devices[num_devs],
+	    buf, RME_SAMPLEWIDTH* RME9652_CH_PER_NATIVE_DEVICE*
+		DACBLKSIZE);
+
+	if(linux_noutdevs)
+	  ioctl(rme9652_dac_devices[0],SNDCTL_DSP_SYNC);
+
+	fprintf(stderr,"done\n");
+    }
+
+    linux_setsr(srate);
+    linux_setch(linux_nindevs, linux_noutdevs);
+
+    num_of_rme9652_dac = linux_noutdevs;
+    num_of_rme9652_adc = linux_nindevs;
+
+    if(linux_noutdevs)linux_noutdevs=1;
+    if(linux_nindevs)linux_nindevs=1;
+
+    /* trick RME9652 behaves as one device fromread write pointers */
+    return (0);
+}
+
+void rme9652_close_audio( void)
+{
+     int i;
+     for (i=0;i<num_of_rme9652_dac;i++)
+		 close(rme9652_dac_devices[i]);
+
+     for (i=0;i<num_of_rme9652_adc;i++)
+          close(rme9652_adc_devices[i]);
+}
+
+
+/* query audio devices for "available" data size. */
+/* not needed because oss_calcspace does the same */
+static int rme9652_calcspace(void)
+{
+    audio_buf_info ainfo;
+
+
+    /* one for all */
+
+    if (ioctl(linux_dacs[0].d_fd, SOUND_PCM_GETOSPACE,&ainfo) < 0)
+	fprintf(stderr,
+   "RME9652: calc ioctl SOUND_PCM_GETOSPACE on output device fd %d failed\n",
+    	linux_dacs[0].d_fd);
+    linux_dacs[0].d_space = ainfo.bytes;
+
+    if (ioctl(linux_adcs[0].d_fd, SOUND_PCM_GETISPACE,&ainfo) < 0)
+	fprintf(stderr, 
+ "RME9652: calc ioctl SOUND_PCM_GETISPACE on input device fd %d failed\n", 
+    	rme9652_adc_devices[0]);
+
+    linux_adcs[0].d_space = ainfo.bytes;
+
+    return 1;
+}
+
+/* this call resyncs audio output and input which will cause discontinuities
+in audio output and/or input. */ 
+
+static void rme9652_doresync( void)
+{	
+  if(linux_noutdevs)
+	 ioctl(rme9652_dac_devices[0],SNDCTL_DSP_SYNC);
+}
+
+static int mycount =0;
+
+int rme9652_send_dacs(void)
+{
+    float *fp;
+    long fill;
+    int i, j, dev;
+	 /* the maximum number of samples we should have in the ADC buffer */
+    t_rme_sample buf[RME9652_CH_PER_NATIVE_DEVICE*DACBLKSIZE], *sp;
+
+    double timeref, timenow;
+
+    mycount++;
+
+    if (!linux_nindevs && !linux_noutdevs) return (0);
+
+    rme9652_calcspace();
+    	 
+	/* do output */
+	
+   timeref = sys_getrealtime();
+
+    if(linux_noutdevs){
+
+    	if (linux_dacs[0].d_dropcount)
+    	    linux_dacs[0].d_dropcount--;
+    	else{
+	    /* fprintf(stderr,"output %d\n", linux_outchannels);*/
+
+	    for(j=0;j<linux_outchannels;j++){
+
+	      t_rme_sample *a,*b,*c,*d;
+	      float *fp1,*fp2,*fp3,*fp4;
+
+	      fp1 = sys_soundout + j*DACBLKSIZE-4;
+	      fp2 = fp1 + 1;
+	      fp3 = fp1 + 2;
+	      fp4 = fp1 + 3;
+	      a = buf-4;
+	      b=a+1;
+	      c=a+2;
+	      d=a+3; 
+
+	      for (i = DACBLKSIZE>>2;i--;)
+		 { 
+		    float s1 =  *(fp1+=4) * INT32_MAX;
+		    float s2 =  *(fp2+=4) * INT32_MAX;
+		    float s3 =  *(fp3+=4) * INT32_MAX;
+		    float s4 =  *(fp4+=4) * INT32_MAX;
+
+		    *(a+=4) = CLIP32(s1);
+		    *(b+=4) = CLIP32(s2);
+		    *(c+=4) = CLIP32(s3);
+		    *(d+=4) = CLIP32(s4);
+    	    	} 
+
+		linux_dacs_write(rme9652_dac_devices[j],buf,RME_BYTESPERCHAN);
+	    }
+    	}
+
+	  if ((timenow = sys_getrealtime()) - timeref > 0.02)
+		 sys_log_error(ERR_DACSLEPT);
+	  timeref = timenow;
+    }
+
+    memset(sys_soundout, 0,
+    	linux_outchannels * (sizeof(float) * DACBLKSIZE));
+
+	 /* do input */
+
+    if(linux_nindevs) {
+
+    	for(j=0;j<linux_inchannels;j++){
+
+    	    linux_adcs_read(rme9652_adc_devices[j], buf, RME_BYTESPERCHAN);
+		  
+	    if ((timenow = sys_getrealtime()) - timeref > 0.02)
+		 sys_log_error(ERR_ADCSLEPT);
+	    timeref = timenow;
+	    {
+		t_rme_sample *a,*b,*c,*d;
+		float *fp1,*fp2,*fp3,*fp4;
+
+		fp1 = sys_soundin + j*DACBLKSIZE-4;
+		fp2 = fp1 + 1;
+		fp3 = fp1 + 2;
+		fp4 = fp1 + 3;
+		a = buf-4;
+		b=a+1;
+		c=a+2;
+		d=a+3; 
+
+		for (i = (DACBLKSIZE>>2);i--;)
+		{ 
+		    *(fp1+=4) = *(a+=4) * (float)(1./INT32_MAX);
+		    *(fp2+=4) = *(b+=4) * (float)(1./INT32_MAX);
+		    *(fp3+=4) = *(c+=4) * (float)(1./INT32_MAX);
+		    *(fp4+=4) = *(d+=4) * (float)(1./INT32_MAX);
+		}
+	    }  
+    	}	
+    }
+    /*	fprintf(stderr,"ready \n");*/
+
+    return (1);
+}
+
+#endif /* RME_HAMMERFALL */