adin_mic_linux_alsa.c

Go to the documentation of this file.

/*
 * Copyright (c) 1991-2006 Kawahara Lab., Kyoto University
 * Copyright (c) 2000-2005 Shikano Lab., Nara Institute of Science and Technology
 * Copyright (c) 2005-2006 Julius project team, Nagoya Institute of Technology, Nagoya Institute of Technology
 * All rights reserved
 */

#include <sent/stddefs.h>
#include <sent/adin.h>

#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include <alsa/asoundlib.h>

static snd_pcm_t *handle;       
static snd_pcm_hw_params_t *hwparams; 
static char *pcm_name = "hw:0,0"; 

static boolean need_swap;       
static int latency = 50;        

static struct pollfd *ufds;     
static int count;               


boolean
adin_mic_standby(int sfreq, void *dummy)
{
  int err;
#if (SND_LIB_MAJOR == 0)
  int actual_rate;              /* sample rate returned by hardware */
#else
  unsigned int actual_rate;             /* sample rate returned by hardware */
#endif
  int dir;                      /* comparison result of exact rate and given rate */

  /* allocate hwparam structure */
  snd_pcm_hw_params_alloca(&hwparams);

  /* open device (for resource test, open in non-block mode) */
  if ((err = snd_pcm_open(&handle, pcm_name, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK)) < 0) {
    j_printerr("Error: cannot open PCM device %s (%s)\n", pcm_name, snd_strerror(err));
    return(FALSE);
  }
  
  /* set device to non-block mode */
  if ((err = snd_pcm_nonblock(handle, 0)) < 0) {
    j_printerr("Error: cannot set PCM device to block mode\n");
    return(FALSE);
  }

  /* initialize hwparam structure */
  if ((err = snd_pcm_hw_params_any(handle, hwparams)) < 0) {
    j_printerr("Error: cannot initialize PCM device parameter structure (%s)\n", snd_strerror(err));
    return(FALSE);
  }

  /* set interleaved read/write format */
  if ((err = snd_pcm_hw_params_set_access(handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
    j_printerr("Error: cannot set PCM device access mode (%s)\n", snd_strerror(err));
    return(FALSE);
  }

  /* set sample format */
#ifdef WORDS_BIGENDIAN
  /* try big endian, then little endian with byte swap */
  if ((err = snd_pcm_hw_params_set_format(handle, hwparams, SND_PCM_FORMAT_S16_BE)) >= 0) {
    need_swap = FALSE;
  } else if ((err = snd_pcm_hw_params_set_format(handle, hwparams, SND_PCM_FORMAT_S16_LE)) >= 0) {
    need_swap = TRUE;
  } else {
    j_printerr("Error: cannot set PCM device format to 16bit-signed (%s)\n", snd_strerror(err));
    return(FALSE);
  }
#else  /* LITTLE ENDIAN */
  /* try little endian, then big endian with byte swap */
  if ((err = snd_pcm_hw_params_set_format(handle, hwparams, SND_PCM_FORMAT_S16_LE)) >= 0) {
    need_swap = FALSE;
  } else if ((err = snd_pcm_hw_params_set_format(handle, hwparams, SND_PCM_FORMAT_S16_BE)) >= 0) {
    need_swap = TRUE;
  } else {
    j_printerr("Error: cannot set PCM device format to 16bit-signed (%s)\n", snd_strerror(err));
    return(FALSE);
  }
#endif
  
  /* set sample rate (if the exact rate is not supported by the hardware, use nearest possible rate */
#if (SND_LIB_MAJOR == 0)
  actual_rate = snd_pcm_hw_params_set_rate_near(handle, hwparams, sfreq, &dir);
  if (actual_rate < 0) {
    j_printerr("Error: cannot set PCM device sample rate to %d (%s)\n", sfreq, snd_strerror(actual_rate));
    return(FALSE);
  }
#else
  actual_rate = sfreq;
  err = snd_pcm_hw_params_set_rate_near(handle, hwparams, &actual_rate, &dir);
  if (err < 0) {
    j_printerr("Error: cannot set PCM device sample rate to %d (%s)\n", sfreq, snd_strerror(err));
    return(FALSE);
  }
#endif
  if (actual_rate != sfreq) {
    j_printerr("Warning: the rate %d Hz is not supported by your PCM hardware.\n         ==> Using %d Hz instead.\n", sfreq, actual_rate);
  }

  /* set number of channels */
  if ((err = snd_pcm_hw_params_set_channels(handle, hwparams, 1)) < 0) {
    j_printerr("Error: cannot set PCM monoral channel (%s)\n", snd_strerror(err));
    return(FALSE);
  }

  /* set period size */
  {
#if (SND_LIB_MAJOR == 0)
    int periodsize;             /* period size (bytes) */
    int actual_size;
    int maxsize, minsize;
#else
    snd_pcm_uframes_t periodsize;               /* period size (bytes) */
    snd_pcm_uframes_t actual_size;
    snd_pcm_uframes_t maxsize, minsize;
#endif
    
    /* get hardware max/min size */
    dir = 0;
#if (SND_LIB_MAJOR == 0)
    if ((maxsize = snd_pcm_hw_params_get_period_size_max(hwparams, &dir)) < 0) {
      j_printerr("Error: cannot get maximum period size\n");
      return(FALSE);
    }
    if ((minsize = snd_pcm_hw_params_get_period_size_min(hwparams, &dir)) < 0) {
      j_printerr("Error: cannot get minimum period size\n");
      return(FALSE);
    }
#else    
    if ((err = snd_pcm_hw_params_get_period_size_max(hwparams, &maxsize, &dir)) < 0) {
      j_printerr("Error: cannot get maximum period size\n");
      return(FALSE);
    }
    if ((err = snd_pcm_hw_params_get_period_size_min(hwparams, &minsize, &dir)) < 0) {
      j_printerr("Error: cannot get minimum period size\n");
      return(FALSE);
    }
#endif

    /* set apropriate period size */
    periodsize = actual_rate * latency / 1000 * sizeof(SP16);
    if (periodsize < minsize) {
      j_printerr("Warning: PCM latency of %d ms (%d bytes) too small, use device minimum %d bytes\n", latency, periodsize, minsize);
      periodsize = minsize;
    } else if (periodsize > maxsize) {
      j_printerr("Warning: PCM latency of %d ms (%d bytes) too large, use device maximum %d bytes\n", latency, periodsize, maxsize);
      periodsize = maxsize;
    }
    
    /* set size (near value will be used) */
#if (SND_LIB_MAJOR == 0)
    actual_size = snd_pcm_hw_params_set_period_size_near(handle, hwparams, periodsize, &dir);
    if (actual_size < 0) {
      j_printerr("Error: cannot set PCM record period size to %d (%s)\n", periodsize, snd_strerror(actual_size));
      return(FALSE);
    }
#else
    actual_size = periodsize;
    err = snd_pcm_hw_params_set_period_size_near(handle, hwparams, &actual_size, &dir);
    if (err < 0) {
      j_printerr("Error: cannot set PCM record period size to %d (%s)\n", periodsize, snd_strerror(err));
      return(FALSE);
    }
#endif
    if (actual_size != periodsize) {
      j_printerr("Warning: PCM period size: %d bytes (%d ms) -> %d bytes\n", periodsize, latency, actual_size);
    }
    /* set number of periods ( = 2) */
    if ((err = snd_pcm_hw_params_set_periods(handle, hwparams, 2, 0)) < 0) {
      j_printerr("Error: cannot set PCM number of periods to %d (%s)\n", 1, snd_strerror(err));
      return(FALSE);
    }
  }

  /* apply the configuration to the PCM device */
  if ((err = snd_pcm_hw_params(handle, hwparams)) < 0) {
    j_printerr("Error: cannot set PCM hardware parameters (%s)\n", snd_strerror(err));
    return(FALSE);
  }

  /* prepare for recording */
  if ((err = snd_pcm_prepare(handle)) < 0) {
    j_printerr("Error: cannot prepare audio interface (%s)\n", snd_strerror(err));
  }

  /* prepare for polling */
  count = snd_pcm_poll_descriptors_count(handle);
  if (count <= 0) {
    j_printerr("Error: invalid PCM poll descriptors count\n");
    return(FALSE);
  }
  ufds = mymalloc(sizeof(struct pollfd) * count);

  if ((err = snd_pcm_poll_descriptors(handle, ufds, count)) < 0) {
    j_printerr("Error: unable to obtain poll descriptors for PCM recording (%s)\n", snd_strerror(err));
    return(FALSE);
  }

  return(TRUE);
}

static int
xrun_recovery(snd_pcm_t *handle, int err)
{
  if (err == -EPIPE) {    /* under-run */
    err = snd_pcm_prepare(handle);
    if (err < 0)
      j_printerr("Can't recovery from PCM buffer underrun, prepare failed: %s\n", snd_strerror(err));
    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)
        j_printerr("Can't recovery from PCM buffer suspend, prepare failed: %s\n", snd_strerror(err));
    }
    return 0;
  }
  return err;
}

boolean
adin_mic_start()
{
  int err;
  snd_pcm_state_t status;

  /* check hardware status */
  while(1) {                    /* wait till prepared */
    status = snd_pcm_state(handle);
    switch(status) {
    case SND_PCM_STATE_PREPARED: /* prepared for operation */
      if ((err = snd_pcm_start(handle)) < 0) {
        j_printerr("Error: cannot start PCM (%s)\n", snd_strerror(err));
        return (FALSE);
      }
      return(TRUE);
      break;
    case SND_PCM_STATE_RUNNING: /* capturing the samples of other application */
      if ((err = snd_pcm_drop(handle)) < 0) { /* discard the existing samples */
        j_printerr("Error: cannot drop PCM (%s)\n", snd_strerror(err));
        return (FALSE);
      }
      break;
    case SND_PCM_STATE_XRUN:    /* buffer overrun */
      if ((err = xrun_recovery(handle, -EPIPE)) < 0) {
        j_printerr("Error: PCM XRUN recovery failed (%s)\n", snd_strerror(err));
        return(FALSE);
      }
      break;
    case SND_PCM_STATE_SUSPENDED:       /* suspended by power management system */
      if ((err = xrun_recovery(handle, -ESTRPIPE)) < 0) {
        j_printerr("Error: PCM XRUN recovery failed (%s)\n", snd_strerror(err));
        return(FALSE);
      }
      break;
    }
  }

  return(TRUE);
}
  
boolean
adin_mic_stop()
{
  return(TRUE);
}

int
adin_mic_read(SP16 *buf, int sampnum)
{
  int cnt;
  snd_pcm_sframes_t avail;

  while ((avail = snd_pcm_avail_update(handle)) <= 0) {
    usleep(latency * 1000);
  }
  if (avail < sampnum) {
    cnt = snd_pcm_readi(handle, buf, avail);
  } else {
    cnt = snd_pcm_readi(handle, buf, sampnum);
  }

  if (cnt < 0) {
    j_printerr("Error: PCM read failed (%s)\n", snd_strerror(cnt));
    return(-2);
  }

  if (need_swap) {
    swap_sample_bytes(buf, cnt);
  }
  return(cnt);
}

---