/* Copyright (c) 1997-2003 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 audiodriverinterface inputs and outputs audio data using
   the ALSA MMAP API available on linux.
   this is optimized for hammerfall cards and does not make an attempt to be general
   now, please adapt to your needs or let me know ...
   constrains now:
    - audio Card with ALSA-Driver > 1.0.3,
    - alsa-device (preferable hw) with MMAP NONINTERLEAVED SIGNED-32Bit features
    - up to 4 cards with has to be hardwaresynced
   (winfried)
*/
#include <alsa/asoundlib.h>
#include "m_pd.h"
#include "s_stuff.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 "s_audio_alsa.h"

/* needed for alsa 0.9 compatibility: */
#if (SND_LIB_MAJOR < 1)
#define ALSAAPI9
#endif
/* sample type magic ...
   Hammerfall/HDSP/DSPMADI cards always 32Bit where lower 8Bit not used (played) in AD/DA,
   but can have some bits set (subchannel coding)
*/
#define ALSAMM_SAMPLEWIDTH_32 sizeof(t_alsa_sample32)

#ifndef INT32_MAX
#define INT32_MAX 0x7fffffff
#endif

/* maybe:
    don't assume we can turn all 31 bits when doing float-to-fix;
    otherwise some audio drivers (e.g. Midiman/ALSA) wrap around.
    but not now on hammerfall (w)
*/

/* 24 Bit are used so MAX Samplevalue not INT32_MAX ??? */
#define F32MAX 0x7fffff00
#define CLIP32(x) (((x)>F32MAX)?F32MAX:((x) < -F32MAX)?-F32MAX:(x))

#define ALSAMM_FORMAT SND_PCM_FORMAT_S32
/*
   maximum of 4 devices
   you can mix rme9632,hdsp9632 (18 chans) rme9652,hdsp9652 (26 chans), dsp-madi (64 chans)
   if synced
*/

/*
   we need same samplerate, buffertime and so on for
   each card soo we use global vars...
   time is in us,   size in frames (i hope so ;-)
*/
static unsigned int alsamm_sr = 0;
static unsigned int alsamm_buffertime = 0;
static unsigned int alsamm_buffersize = 0;

static bool debug=0;

/* bad style: we asume all cards give the same answer at init so we make this vars global
   to have a faster access in writing reading during send_dacs */
static snd_pcm_sframes_t alsamm_period_size;
static unsigned int alsamm_periods;
static snd_pcm_sframes_t alsamm_buffer_size;

/* if more than this sleep detected, should be more than periodsize/samplerate ??? */
static double sleep_time;

/* now we just sum all inputs/outputs of used cards to a global count
   and use them all
   ... later we should just use some channels of each card for pd
   so we reduce the overhead of using alsways all channels,
   and zero the rest once at start,
   because rme9652 and hdsp forces us to use all channels
   in mmap mode...

Note on why:
   normally hdsp and dspmadi can handle channel
   count from one to all since they can switch on/off
   the dma for them to reduce pci load, but this is only
   implemented in alsa low level drivers for dspmadi now and maybe fixed for hdsp in future
*/

static int alsamm_inchannels = 0;
static int alsamm_outchannels = 0;

/* Defines */
 #define WATCH_PERIODS 90
 static int in_avail[WATCH_PERIODS];
 static int out_avail[WATCH_PERIODS];
 static int in_offset[WATCH_PERIODS];
 static int out_offset[WATCH_PERIODS];
 static int out_cm[WATCH_PERIODS];
 static char *outaddr[WATCH_PERIODS];
 static char *inaddr[WATCH_PERIODS];
 static int xruns_watch[WATCH_PERIODS];
 static int broken_opipe;

 static int dac_send = 0;
 static int alsamm_xruns = 0;

static void show_availist() {
  for(int i=1; i<WATCH_PERIODS; i++){
    post("%2d:avail i=%7d %s o=%7d(%5d), offset i=%7d %s o=%7d, ptr i=%12p o=%12p, %d xruns ",
         i,in_avail[i],(out_avail[i] != in_avail[i])? "!=" : "==" , out_avail[i],out_cm[i],
         in_offset[i],(out_offset[i] != in_offset[i])? "!=" : "==" , out_offset[i],
         inaddr[i], outaddr[i], xruns_watch[i]);
  }
}

/* protos */
static int set_hwparams(snd_pcm_t *handle, snd_pcm_hw_params_t *params, int *chs);
static int set_swparams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams, int playback);
static int alsamm_start();
static int alsamm_stop();

/* for debugging attach output of alsa mesages to stdout stream */
snd_output_t* alsa_stdout;

static void check_error(int err, const char *why) {if (err < 0) error("%s: %s", why, snd_strerror(err));}

int alsamm_open_audio(int rate) {
  int err;
  snd_pcm_hw_params_t* hw_params;
  snd_pcm_sw_params_t* sw_params;
  /* fragsize is an old concept now use periods, used to be called fragments. */
  /* Be aware in ALSA periodsize can be in bytes, where buffersize is in frames,
     but sometimes buffersize is in bytes and periods in frames, crazy alsa...
     ...we use periodsize and buffersize in frames */
  int i;
  snd_pcm_hw_params_alloca(&hw_params);
  snd_pcm_sw_params_alloca(&sw_params);
  /* see add_devname */
  /* first have a look which cards we can get and set up device infos for them */
  /* init some structures */
  for(i=0;i < ALSA_MAXDEV;i++){
    alsa_indev[i].a_synced=alsa_outdev[i].a_synced=0;
    alsa_indev[i].a_channels=alsa_outdev[i].a_channels=-1; /* query defaults */
  }
  alsamm_inchannels = 0;
  alsamm_outchannels = 0;
  /* opening alsa debug channel */
  err = snd_output_stdio_attach(&alsa_stdout, stdout, 0);
  if (err < 0) {
    check_error(err,"attaching alsa debug Output to stdout failed");
    /*    return; no so bad ... and never should happe */
  }
  /*
     Weak failure prevention:
     first card found (out then in) is used as a reference for parameter,
     so this  set the globals and other cards hopefully dont change them
  */
  alsamm_sr = rate;
  /* set the asked buffer time (alsa buffertime in us)*/
  alsamm_buffertime = alsamm_buffersize = 0;
  if(sys_blocksize == 0)
    alsamm_buffertime = sys_schedadvance;
  else
    alsamm_buffersize = sys_blocksize;
  if(sys_verbose)
    post("syschedadvance=%d us(%d Samples)so buffertime max should be this=%d"
         "or sys_blocksize=%d (samples) to use buffersize=%d",
         sys_schedadvance,sys_advance_samples,alsamm_buffertime,
         sys_blocksize,alsamm_buffersize);
  alsamm_periods = 0; /* no one wants periods setting from command line ;-) */
  for(i=0;i<alsa_noutdev;i++) {
        /*   post("open audio out %d, of %lx, %d",i,&alsa_device[i],
                   alsa_outdev[i].a_handle); */
      err = set_hwparams(alsa_outdev[i].a_handle, hw_params, &(alsa_outdev[i].a_channels));
      if (err<0) {check_error(err,"playback device hwparam_set error:"); continue;}
      err = set_swparams(alsa_outdev[i].a_handle, sw_params,1);
      if (err<0) {check_error(err,"playback device swparam_set error:"); continue;}
      alsamm_outchannels += alsa_outdev[i].a_channels;
      alsa_outdev[i].a_addr = (char **)malloc(sizeof(char *)*alsa_outdev[i].a_channels);
      if(alsa_outdev[i].a_addr == NULL) {
        check_error(errno,"playback device outaddr allocation error:");
        continue;
      }
      memset(alsa_outdev[i].a_addr, 0, sizeof(char*) * alsa_outdev[i].a_channels);
      post("playback device with %d channels and buffer_time %d us opened",
           alsa_outdev[i].a_channels, alsamm_buffertime);
  }
  for(i=0;i<alsa_nindev;i++) {
      if(sys_verbose) post("capture card %d:--------------------",i);
      if((err = set_hwparams(alsa_indev[i].a_handle, hw_params, &(alsa_indev[i].a_channels))) < 0) {
          check_error(err,"capture device hwparam_set error:");
          continue;
      }
      alsamm_inchannels += alsa_indev[i].a_channels;
      if((err = set_swparams(alsa_indev[i].a_handle, sw_params,0)) < 0){
        check_error(err,"capture device swparam_set error:");
        continue;
      }
      alsa_indev[i].a_addr = (char **)malloc(sizeof(char*)*alsa_indev[i].a_channels);
      if(alsa_indev[i].a_addr == NULL){
        check_error(errno,"capture device inaddr allocation error:");
        continue;
      }
      memset(alsa_indev[i].a_addr, 0, sizeof(char*) * alsa_indev[i].a_channels);
      if(sys_verbose) post("capture device with %d channels and buffertime %d us opened", alsa_indev[i].a_channels,alsamm_buffertime);
  }
  /* check for linked handles of input for each output*/
  for(int i=0; i<(alsa_noutdev < alsa_nindev ? alsa_noutdev:alsa_nindev); i++) {
    if (alsa_outdev[i].a_devno == alsa_indev[i].a_devno) {
      if ((err = snd_pcm_link(alsa_indev[i].a_handle, alsa_outdev[i].a_handle)) == 0) {
        alsa_indev[i].a_synced = alsa_outdev[i].a_synced = 1;
        if(sys_verbose) post("Linking in and outs of card %d",i);
      } else check_error(err,"could not link in and outs");
    }
  }
  /* some globals */
  sleep_time =  (float) alsamm_period_size/ (float) alsamm_sr;
 if (debug) {
  /* start ---------------------------- */
  if(sys_verbose) post("open_audio: after dacsend=%d (xruns=%d)done",dac_send,alsamm_xruns);
  alsamm_xruns = dac_send = 0; /* reset debug */
  /* start alsa in open or better in send_dacs once ??? we will see */
  for(i=0;i<alsa_noutdev;i++) snd_pcm_dump(alsa_outdev[i].a_handle, alsa_stdout);
  for(i=0;i<alsa_nindev;i++)  snd_pcm_dump( alsa_indev[i].a_handle, alsa_stdout);
  fflush(stdout);
 }
  sys_setchsr(alsamm_inchannels,  alsamm_outchannels, alsamm_sr, sys_dacblocksize);
  alsamm_start();
  /* report success  */
  return 0;
}

void alsamm_close_audio() {
  int i,err;
  if(debug&&sys_verbose) post("closing devices");
  alsamm_stop();
  for(i=0;i< alsa_noutdev;i++) {
    //if(debug&&sys_verbose) post("unlink audio out %d, of %lx",i,used_outdevice[i]);
    if(alsa_outdev[i].a_synced != 0){
      if((err = snd_pcm_unlink(alsa_outdev[i].a_handle)) < 0) check_error(err, "snd_pcm_unlink (output)");
      alsa_outdev[i].a_synced = 0;
     }
    if((err = snd_pcm_close(alsa_outdev[i].a_handle)) <= 0) check_error(err, "snd_pcm_close (output)");
    if(alsa_outdev[i].a_addr) {
      free(alsa_outdev[i].a_addr);
      alsa_outdev[i].a_addr = NULL;
    }
    alsa_outdev[i].a_channels = 0;
  }
  for(i=0;i< alsa_nindev;i++) {
    err = snd_pcm_close(alsa_indev[i].a_handle);
    if(sys_verbose) check_error(err, "snd_pcm_close (input)");
    if(alsa_indev[i].a_addr){
      free(alsa_indev[i].a_addr);
      alsa_indev[i].a_addr = NULL;
    }
    alsa_indev[i].a_channels = 0;
  }
  alsa_nindev = alsa_noutdev = 0;
 if(debug) {
  if(sys_verbose) post("close_audio: after dacsend=%d (xruns=%d)done",dac_send,alsamm_xruns);
   alsamm_xruns = dac_send = 0;
 }
}

/* ------- PCM INITS --------------------------------- */
static int set_hwparams(snd_pcm_t *handle, snd_pcm_hw_params_t *params,int *chs) {
#ifndef ALSAAPI9
  unsigned int rrate;
  int err, dir;
  /* choose all parameters */
  err = snd_pcm_hw_params_any(handle, params);
  if (err < 0) {
    check_error(err,"Broken configuration: no configurations available");
    return err;
  }
  /* set the nointerleaved read/write format */
  err = snd_pcm_hw_params_set_access(handle, params,
                                     SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
  if (err >= 0) {
    if(debug&&sys_verbose) post("Access type %s available","SND_PCM_ACCESS_MMAP_NONINTERLEAVED");
  }
  else{
    check_error(err,"No Accesstype SND_PCM_ACCESS_MMAP_NONINTERLEAVED");
    return err;
  }
  /* set the sample format */
  err = snd_pcm_hw_params_set_format(handle, params, ALSAMM_FORMAT);
  if (err < 0) {
    check_error(err,"Sample format not available for playback");
    return err;
  }
  if(debug&&sys_verbose) post("Setting format to %s",snd_pcm_format_name(ALSAMM_FORMAT));
  /* first check samplerate since channels numbers are samplerate dependend (double speed) */
  /* set the stream rate */
  rrate = alsamm_sr;
  if(debug&&sys_verbose) post("Samplerate request: %i Hz",rrate);
  dir=-1;
  err = snd_pcm_hw_params_set_rate_near(handle, params, &rrate, &dir);
  if (err < 0) {
    check_error(err,"Rate not available");
    return err;
  }
  if (rrate != alsamm_sr) {
    post("Warning: rate %iHz doesn't match requested %iHz", rrate,alsamm_sr);
    alsamm_sr = rrate;
  }
  else
    if(sys_verbose)
      post("Samplerate is set to %iHz",alsamm_sr);
  /* Info on channels */
  {
    int maxchs,minchs,channels = *chs;
    if((err = snd_pcm_hw_params_get_channels_max(params,
    	(unsigned int *)&maxchs)) < 0){
      check_error(err,"Getting channels_max not available");
      return err;
    }
    if((err = snd_pcm_hw_params_get_channels_min(params,
    	(unsigned int *)&minchs)) < 0){
      check_error(err,"Getting channels_min not available");
      return err;
    }
    if(debug&&sys_verbose) post("Getting channels:min=%d, max= %d for request=%d",minchs,maxchs,channels);
    if(channels < 0)channels=maxchs;
    if(channels > maxchs)channels = maxchs;
    if(channels < minchs)channels = minchs;
    if(channels != *chs) post("requested channels=%d but used=%d",*chs,channels);
    *chs = channels;
    if(debug&&sys_verbose) post("trying to use channels: %d",channels);
  }
  /* set the count of channels */
  err = snd_pcm_hw_params_set_channels(handle, params, *chs);
  if (err < 0) {
    check_error(err,"Channels count not available");
    return err;
  }
  /* testing for channels */
  if((err = snd_pcm_hw_params_get_channels(params,(unsigned int *)chs)) < 0)
    check_error(err,"Get channels not available");
  else if(debug&&sys_verbose) post("When setting channels count and got %d",*chs);
  /* if buffersize is set use this instead buffertime */
  if(alsamm_buffersize > 0) {
    if(debug&&sys_verbose) post("hw_params: ask for max buffersize of %d samples", (unsigned int) alsamm_buffersize);
    alsamm_buffer_size = alsamm_buffersize;
    err = snd_pcm_hw_params_set_buffer_size_near(handle, params, (unsigned long *)&alsamm_buffer_size);
    if (err < 0) {
      check_error(err,"Unable to set max buffer size");
      return err;
    }
  }
  else {
    if(alsamm_buffertime <= 0) /* should never happen, but use 20ms */
      alsamm_buffertime = 20000;
    if(debug&&sys_verbose) post("hw_params: ask for max buffertime of %d ms", (unsigned int) (alsamm_buffertime*0.001) );
    err = snd_pcm_hw_params_set_buffer_time_near(handle, params, &alsamm_buffertime, &dir);
    if (err < 0) {
      check_error(err,"Unable to set max buffer time");
      return err;
    }
  }
  err = snd_pcm_hw_params_get_buffer_time(params,
    (unsigned int *)&alsamm_buffertime, &dir);
  if (err < 0) {
    check_error(err,"Unable to get buffer time");
    return err;
  }
  if(debug&&sys_verbose) post("hw_params: got buffertime to %f ms", float(alsamm_buffertime*0.001));
  err = snd_pcm_hw_params_get_buffer_size(params, (unsigned long *)&alsamm_buffer_size);
  if (err < 0) {
    check_error(err,"Unable to get buffer size");
    return err;
  }
  if(debug&&sys_verbose) post("hw_params: got  buffersize to %d samples",(int) alsamm_buffer_size);
  err = snd_pcm_hw_params_get_period_size(params, (unsigned long *)&alsamm_period_size, &dir);
  if (err > 0) {
    check_error(err,"Unable to get period size");
    return err;
  }
  if(debug&&sys_verbose) post("Got period size of %d", (int) alsamm_period_size);
  {
    unsigned int pmin,pmax;
    err = snd_pcm_hw_params_get_periods_min(params, &pmin, &dir);
    if (err > 0) {
      check_error(err,"Unable to get period size");
      return err;
    }
    err = snd_pcm_hw_params_get_periods_min(params, &pmax, &dir);
    if (err > 0) {
      check_error(err,"Unable to get period size");
      return err;
    }
    /* use maximum of periods */
    if( alsamm_periods <= 0)
      alsamm_periods = pmax;
    alsamm_periods = (alsamm_periods > pmax)?pmax:alsamm_periods;
    alsamm_periods = (alsamm_periods < pmin)?pmin:alsamm_periods;
    err = snd_pcm_hw_params_set_periods(handle, params, alsamm_periods, dir);
    if (err > 0) {
      check_error(err,"Unable to set periods");
      return err;
    }
    err = snd_pcm_hw_params_get_periods(params, &pmin, &dir);
    if (err > 0) {
      check_error(err,"Unable to get periods");
      return err;
    }
    if(debug&&sys_verbose) post("Got periods of %d, where periodsmin=%d, periodsmax=%d",alsamm_periods,pmin,pmax);
  }
  /* write the parameters to device */
  err = snd_pcm_hw_params(handle, params);
  if (err < 0) {
    check_error(err,"Unable to set hw params");
    return err;
  }
#endif /* ALSAAPI9 */
  return 0;
}

static int set_swparams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams, int playback) {
#ifndef ALSAAPI9
  int err;
  snd_pcm_uframes_t ps,ops;
  snd_pcm_uframes_t bs,obs;
  /* get the current swparams */
  err = snd_pcm_sw_params_current(handle, swparams);
  if (err < 0) {
    check_error(err,"Unable to determine current swparams for playback");
    return err;
  }
  /* AUTOSTART: start the transfer on each write/commit ??? */
  snd_pcm_sw_params_get_start_threshold(swparams, &obs);
  err = snd_pcm_sw_params_set_start_threshold(handle, swparams, 0U);
  if (err < 0) {
    check_error(err,"Unable to set start threshold mode");
    return err;
  }
  snd_pcm_sw_params_get_start_threshold(swparams, &bs);
  if(debug&&sys_verbose) post("sw_params: got start_thresh_hold= %d (was %d)",(int) bs,(int)obs);
  /* AUTOSTOP:  never stop the machine */
  snd_pcm_sw_params_get_stop_threshold(swparams, &obs);
  err = snd_pcm_sw_params_set_stop_threshold(handle, swparams, (snd_pcm_uframes_t)-1);
  if (err < 0) {
    check_error(err,"Unable to set stop threshold mode");
    return err;
  }
  snd_pcm_sw_params_get_stop_threshold(swparams, &bs);
  if(debug&&sys_verbose) post("sw_params: set stop_thresh_hold= %d (was %d)", (int) bs,(int)obs);
  /* AUTOSILENCE: silence if overrun.... */
  snd_pcm_sw_params_get_silence_threshold (swparams, &ops);
  if ((err = snd_pcm_sw_params_set_silence_threshold (handle, swparams, alsamm_period_size)) < 0) {
    check_error (err,"cannot set silence threshold for");
    return -1;
  }
  snd_pcm_sw_params_get_silence_threshold (swparams, &ps);
  if(debug&&sys_verbose) post("sw_params: set silence_threshold = %d (was %d)", (int) ps,(int)ops);
  snd_pcm_sw_params_get_silence_size (swparams, &ops);
  if ((err = snd_pcm_sw_params_set_silence_size(handle, swparams, alsamm_period_size)) < 0) {
    check_error (err,"cannot set silence size for");
    return -1;
  }
  snd_pcm_sw_params_get_silence_size (swparams, &ps);
  if(debug&&sys_verbose) post("sw_params: set silence_size = %d (was %d)", (int) ps,(int)ops);
  /* AVAIL: allow the transfer when at least period_size samples can be processed */
  snd_pcm_sw_params_get_avail_min(swparams, &ops);
  err = snd_pcm_sw_params_set_avail_min(handle, swparams, sys_dacblocksize/2);
  if (err < 0) {
    check_error(err,"Unable to set avail min for");
    return err;
    }
  snd_pcm_sw_params_get_avail_min(swparams, &ps);
  if(debug&&sys_verbose) post("sw_params: set avail_min= %d (was  %d)", (int) ps, (int) ops);
  /* ALIGN: align all transfers to 1 sample */
  snd_pcm_sw_params_get_xfer_align(swparams, &ops);
  err = snd_pcm_sw_params_set_xfer_align(handle, swparams, 1);
  if (err < 0) {
    check_error(err,"Unable to set transfer align for playback");
    return err;
  }
  snd_pcm_sw_params_get_xfer_align(swparams, &ps);
  if(debug&&sys_verbose) post("sw_params: set xfer_align = %d (was  %d)", (int) ps, (int) ops);
  /* write the parameters to the playback device */
  err = snd_pcm_sw_params(handle, swparams);
  if (err < 0) {
    check_error(err,"Unable to set sw params");
    return err;
  }
  if(debug&&sys_verbose) post("set sw finished");
#else
  post("alsa: need version 1.0 or above for mmap operation");
#endif /* ALSAAPI9 */
  return 0;
}

/* ALSA Transfer helps */

/* xrun_recovery is called if time to late or error
  Note: use outhandle if synced i/o
        the devices are linked so prepare
        has only be called on out,
        hopefully resume too...
*/
static int xrun_recovery(snd_pcm_t *handle, int err) {
  if (debug) alsamm_xruns++; /* count xruns */
  if (err == -EPIPE) {    /* under-run */
    err = snd_pcm_prepare(handle);
    if (err < 0) check_error(err,"Can't recovery from underrun, prepare failed.");
    err = snd_pcm_start(handle);
    if (err < 0) check_error(err,"Can't start when recover from underrun.");
    return 0;
  } else if (err == -ESTRPIPE) {
    while ((err = snd_pcm_resume(handle)) == -EAGAIN)
      sleep(1);       /* wait until the suspend flag is released */
    if (err < 0) {
      err = snd_pcm_prepare(handle);
      if (err<0) check_error(err,"Can't recovery from suspend, prepare failed.");
      err = snd_pcm_start(handle);
      if (err<0) check_error(err,"Can't start when recover from underrun.");
    }
    return 0;
  }
  return err;
}

/* note that snd_pcm_avail has to be called before using this funtion */
static int alsamm_get_channels(snd_pcm_t *dev, snd_pcm_uframes_t *avail, snd_pcm_uframes_t *offset, int nchns, char **addr) {
  int err = 0;
  const snd_pcm_channel_area_t *mm_areas;
  if (nchns > 0 && avail != NULL && offset != NULL) {
    if ((err = snd_pcm_mmap_begin(dev, &mm_areas, offset, avail)) < 0){
      check_error(err,"setmems: begin_mmap failure ???");
      return err;
    }
    for (int chn = 0; chn < nchns; chn++) {
      const snd_pcm_channel_area_t *a = &mm_areas[chn];
      addr[chn] = (char *) a->addr + ((a->first + a->step * *offset) / 8);
    }
    return err;
  }
  return -1;
}

static int alsamm_start() {
  int err = 0;
  int devno;
  int chn;
  /* first prepare for in/out */
  for(devno=0; devno<alsa_noutdev; devno++) {
    snd_pcm_uframes_t offset, avail;
    t_alsa_dev *dev = &alsa_outdev[devno];
    /* snd_pcm_prepare also in xrun, but cannot harm here */
    if ((err = snd_pcm_prepare (dev->a_handle)) < 0) {
      check_error (err,"outcard prepare error for playback");
      return err;
    }
    offset = 0;
    avail = snd_pcm_avail_update(dev->a_handle);
    if (avail != (snd_pcm_uframes_t) alsamm_buffer_size) {
      check_error (avail,"full buffer not available at start");
    }
    /* cleaning out mmap buffer before start */
    if(debug&&sys_verbose) post("start: set mems for avail=%d,offset=%d at buffersize=%d",avail,offset,alsamm_buffer_size);
    if(avail > 0) {
      int comitted = 0;
      if ((err = alsamm_get_channels(dev->a_handle, &avail, &offset, dev->a_channels,dev->a_addr)) < 0) {
        check_error(err,"setting initial out channelspointer failure ?");
        continue;
      }
      for (chn = 0; chn < dev->a_channels; chn++)
        memset(dev->a_addr[chn],0,avail*ALSAMM_SAMPLEWIDTH_32);
      comitted = snd_pcm_mmap_commit (dev->a_handle, offset, avail);
      avail = snd_pcm_avail_update(dev->a_handle);
      if(debug&&sys_verbose) post("start: now channels cleared, out with avail=%d, offset=%d,comitted=%d",avail,offset,comitted);
    }
    /* now start, should be autostarted */
    avail = snd_pcm_avail_update(dev->a_handle);
    if(debug&&sys_verbose) post("start: finish start, out with avail=%d, offset=%d",avail,offset);
    /* we have no autostart so anyway start*/
    if ((err = snd_pcm_start (dev->a_handle)) < 0) {
      check_error (err,"could not start playback");
    }
  }
  for(devno = 0;devno < alsa_nindev;devno++){
    snd_pcm_uframes_t ioffset, iavail;
    t_alsa_dev *dev = &alsa_indev[devno];
    /* if devices are synced then dont need to prepare
       hopefully dma in aereas allready filled correct by the card */
    if(dev->a_synced == 0) {
      if ((err = snd_pcm_prepare (dev->a_handle)) < 0) {
        check_error (err,"incard prepare error for capture");
        /*      return err;*/
      }
    }
    ioffset = 0;
    iavail = snd_pcm_avail_update (dev->a_handle);
    /* cleaning out mmap buffer before start */
    if (debug) post("start in: set in mems for avail=%d,offset=%d at buffersize=%d",iavail,ioffset,alsamm_buffer_size);
    if (iavail > (snd_pcm_uframes_t) 0) {
      if (debug) post("empty buffer not available at start, since avail %d != %d buffersize", iavail, alsamm_buffer_size);
      if ((err = alsamm_get_channels(dev->a_handle, &iavail, &ioffset, dev->a_channels,dev->a_addr)) < 0) {
        check_error(err,"getting in channelspointer failure ????");
        continue;
      }
      snd_pcm_mmap_commit (dev->a_handle, ioffset, iavail);
      iavail = snd_pcm_avail_update (dev->a_handle);
      if (debug) post("start in now avail=%d",iavail);
    }
    if (debug) post("start: init inchannels with avail=%d, offset=%d",iavail,ioffset);
    /* if devices are synced then dont need to start */
    /* start with autostart , but anyway start */
    if(dev->a_synced == 0) {
      if ((err = snd_pcm_start (dev->a_handle)) < 0) {
        check_error (err,"could not start capture");
        continue;
      }
    }
  }
  return err;
}

static int alsamm_stop() {
  int err = 0;
  /* first stop in... */
  for(int devno=0; devno<alsa_nindev; devno++) {
    t_alsa_dev *dev = &alsa_indev[devno];
    if(sys_verbose) post("stop in device %d",devno);
    int err = snd_pcm_drop(dev->a_handle);
    if (err<0) check_error(err,"channel flush for capture failed");
  }
  /* then outs */
  for(int devno=0; devno<alsa_noutdev;devno++) {
    t_alsa_dev *dev = &alsa_outdev[devno];
    if(sys_verbose) post("stop out device %d",devno);
    int err = snd_pcm_drop(dev->a_handle);
    if (err<0) check_error(err,"channel flush for playback failed");
  }
  if (debug) show_availist();
  return err;
}

/* ---------- ADC/DAC tranfer in  the main loop ------- */
/* I see: (a guess as a documentation)
   all DAC data is in sys_soundout array with
   sys_dacblocksize (mostly 64) for each channels which
   if we have more channels opened then dac-channels = sys_outchannels
   we have to zero (silence them), which should be done once.

Problems to solve:

   a) Since in ALSA MMAP, the MMAP reagion can change (dont ask me why)
   we have to do it each cycle or we say on RME HAMMERFALL/HDSP/DSPMADI
   it never changes to it once. so maybe we can do it once in open

   b) we never know if inputs are synced and zero them if not,
   except we use the control interface to check for, but this is
   a systemcall we cannot afford in RT Loops so we just dont
   and if not it will click... users fault ;-)))
*/

int alsamm_send_dacs() {
  static double timenow,timelast;
  t_sample *fpo, *fpi, *fp1, *fp2;
  int i, err, devno;
  snd_pcm_sframes_t size;
  snd_pcm_sframes_t commitres;
  snd_pcm_state_t state;
  snd_pcm_sframes_t ooffset, oavail;
  snd_pcm_sframes_t ioffset, iavail;
  /* unused channels should be zeroed out on startup (open) and stay this */
  int inchannels = sys_inchannels;
  int outchannels = sys_outchannels;
  timelast = sys_getrealtime();
 if (debug) {
  if(dac_send++ < 0)
    post("dac send called in %d, out %d, xrun %d",inchannels,outchannels, alsamm_xruns);
  if(alsamm_xruns && (alsamm_xruns % 1000) == 0)
    post("1000 xruns accoured");
  if(dac_send < WATCH_PERIODS){
    out_cm[dac_send] = -1;
    in_avail[dac_send] = out_avail[dac_send] = -1;
    in_offset[dac_send] = out_offset[dac_send] = -1;
    outaddr[dac_send] = inaddr[dac_send] = NULL;
    xruns_watch[dac_send] = alsamm_xruns;
  }
 }
  if (!inchannels && !outchannels) return SENDDACS_NO;
  /* here we should check if in and out samples are here.
     but, the point is if out samples available also in sample should,
     so we dont make a precheck of insamples here and let outsample check be the
     the first of the forst card.
  */
  /* OUTPUT Transfer */
  fpo = sys_soundout;
  for(devno = 0;devno < alsa_noutdev;devno++){
    t_alsa_dev *dev = &alsa_outdev[devno];
    snd_pcm_t *out = dev->a_handle;
    int ochannels =dev->a_channels;
    /* how much samples available ??? */
    oavail = snd_pcm_avail_update(out);
    /* only one reason i can think about,
       the driver stopped and says broken pipe
       so this should not happen if we have enough stopthreshhold
       but if try to restart with next commit
    */
    if (oavail < 0) {
      if (debug) broken_opipe++;
      err = xrun_recovery(out, -EPIPE);
      if (err < 0) {
        check_error(err,"otavail<0 recovery failed");
        return SENDDACS_NO;
      }
      oavail = snd_pcm_avail_update(out);
    }
    /* check if we are late and have to (able to) catch up */
    /* xruns will be ignored since you cant do anything since already happend */
    state = snd_pcm_state(out);
    if (state == SND_PCM_STATE_XRUN) {
      err = xrun_recovery(out, -EPIPE);
      if (err < 0) {
        check_error(err,"DAC XRUN recovery failed");
        return SENDDACS_NO;
      }
      oavail = snd_pcm_avail_update(out);
    } else if (state == SND_PCM_STATE_SUSPENDED) {
      err = xrun_recovery(out, -ESTRPIPE);
      if (err < 0) {
        check_error(err,"DAC SUSPEND recovery failed");
        return SENDDACS_NO;
      }
      oavail = snd_pcm_avail_update(out);
    }
    if(debug && dac_send < WATCH_PERIODS){
      out_avail[dac_send] = oavail;
    }
    /* we only transfer transfersize of bytes request,
       this should only happen on first card otherwise we got a problem :-(()*/
    if(oavail < sys_dacblocksize) return SENDDACS_NO;
    /* transfer now */
    size = sys_dacblocksize;
    fp1 = fpo;
    ooffset = 0;
    /* since this can go over a buffer boundery we maybe need two steps to
       transfer (normally when buffersize is a multiple of transfersize
       this should never happen) */
    while (size > 0) {
      int chn;
      snd_pcm_sframes_t oframes;
      oframes = size;
      err =  alsamm_get_channels(out, (unsigned long *)&oframes, (unsigned long *)&ooffset,ochannels,dev->a_addr);
      if(debug && dac_send < WATCH_PERIODS){
        out_offset[dac_send] = ooffset;
        outaddr[dac_send] = (char *) dev->a_addr[0];
      }
      if (err < 0) {
        if ((err = xrun_recovery(out, err)) < 0) {
          check_error(err,"MMAP begins avail error");
          break; /* next card please */
        }
      }
      /* transfer into memory */
      for (chn = 0; chn < ochannels; chn++) {
        t_alsa_sample32 *buf = (t_alsa_sample32 *)dev->a_addr[chn];
        /* osc(buf, oframes, (dac_send%1000 < 500)?-100.0:-10.0,440,&(indexes[chn])); */
        for (i = 0, fp2 = fp1 + chn*sys_dacblocksize; i < oframes; i++,fp2++) {
            float s1 = *fp2 * F32MAX;
            /* better but slower, better never clip ;-)
               buf[i]= CLIP32(s1); */
            buf[i]= ((int) s1 & 0xFFFFFF00);
            *fp2 = 0.0;
        }
      }
      commitres = snd_pcm_mmap_commit(out, ooffset, oframes);
      if (commitres < 0 || commitres != oframes) {
        if ((err = xrun_recovery(out, commitres >= 0 ? -EPIPE : commitres)) < 0) {
          check_error(err,"MMAP commit error");
          return SENDDACS_NO;
        }
      }
      if(debug && dac_send < WATCH_PERIODS) out_cm[dac_send] = oframes;
      fp1 += oframes;
      size -= oframes;
    } /* while size */
    fpo += ochannels*sys_dacblocksize;
  }/* for devno */
  fpi = sys_soundin; /* star first card first channel */
  for(devno = 0;devno < alsa_nindev;devno++){
    t_alsa_dev *dev = &alsa_indev[devno];
    snd_pcm_t *in = dev->a_handle;
    int ichannels = dev->a_channels;
    iavail = snd_pcm_avail_update(in);
    if (iavail < 0) {
      err = xrun_recovery(in, iavail);
      if (err < 0) {
        check_error(err,"input avail update failed");
        return SENDDACS_NO;
      }
      iavail=snd_pcm_avail_update(in);
    }
    state = snd_pcm_state(in);
    if (state == SND_PCM_STATE_XRUN) {
      err = xrun_recovery(in, -EPIPE);
      if (err < 0) {
        check_error(err,"ADC XRUN recovery failed");
        return SENDDACS_NO;
      }
      iavail=snd_pcm_avail_update(in);
    } else if (state == SND_PCM_STATE_SUSPENDED) {
      err = xrun_recovery(in, -ESTRPIPE);
      if (err < 0) {
        check_error(err,"ADC SUSPEND recovery failed");
        return SENDDACS_NO;
      }
      iavail=snd_pcm_avail_update(in);
    }
    /* only transfer full transfersize or nothing */
    if(iavail < sys_dacblocksize){
      return SENDDACS_NO;
    }
    size = sys_dacblocksize;
    fp1 = fpi;
    ioffset = 0;
    /* since sysdata can go over a driver buffer boundery we maybe need two steps to
       transfer (normally when buffersize is a multiple of transfersize
       this should never happen) */
    while(size > 0) {
      int chn;
      snd_pcm_sframes_t iframes = size;
      err =  alsamm_get_channels(in, (unsigned long *)&iframes, (unsigned long *)&ioffset,ichannels,dev->a_addr);
      if (err < 0){
        if ((err = xrun_recovery(in, err)) < 0) {
          check_error(err,"MMAP begins avail error");
          return SENDDACS_NO;
        }
      }
      if(debug && dac_send < WATCH_PERIODS){
        in_avail[dac_send] = iavail;
        in_offset[dac_send] = ioffset;
        inaddr[dac_send] = dev->a_addr[0];
      }
      /* transfer into memory */
      for (chn = 0; chn < ichannels; chn++) {
        t_alsa_sample32 *buf = (t_alsa_sample32 *) dev->a_addr[chn];
        for (i = 0, fp2 = fp1 + chn*sys_dacblocksize; i < iframes; i++,fp2++) {
            /* mask the lowest bits, since subchannels info can make zero samples nonzero */
            *fp2 = (float) ((t_alsa_sample32) (buf[i] & 0xFFFFFF00))
              * (1.0 / (float) INT32_MAX);
        }
      }
      commitres = snd_pcm_mmap_commit(in, ioffset, iframes);
      if (commitres < 0 || commitres != iframes) {
        post("please never");
        if ((err = xrun_recovery(in, commitres >= 0 ? -EPIPE : commitres)) < 0) {
          check_error(err,"MMAP synced in commit error");
          return SENDDACS_NO;
        }
      }
      fp1 += iframes;
      size -= iframes;
    }
    fpi += ichannels*sys_dacblocksize;
  } /* for out devno < alsamm_outcards*/
  if ((timenow = sys_getrealtime()) > (timelast + sleep_time)) {
      if(debug && dac_send < 10 && sys_verbose)
        post("slept %f > %f + %f (=%f)", timenow,timelast,sleep_time,(timelast + sleep_time));
      return (SENDDACS_SLEPT);
  }
  return SENDDACS_YES;
}

/* extra debug info */
void alsamm_showstat(snd_pcm_t *handle) {
  int err;
  snd_pcm_status_t *status;
  snd_pcm_status_alloca(&status);
  if ((err = snd_pcm_status(handle, status)) < 0) {
    check_error(err, "Get Stream status error");
    return;
  }
  snd_pcm_status_dump(status, alsa_stdout);
}