ref: 60e502a9b5a169a508bf9b8872c6fa371ecf8c1d
dir: /src/alsa.c/
/* * Copyright 1997 Jimen Ching And Sundry Contributors * This source code is freely redistributable and may be used for * any purpose. This copyright notice must be maintained. * Jimen Ching And Sundry Contributors are not * responsible for the consequences of using this software. */ /* Direct to ALSA sound driver * * added by Jimen Ching (jching@flex.com) 19990207 * based on info grabed from aplay.c in alsa-utils package. * Updated for ALSA 0.9.X API 20020824. */ #include "st_i.h" #if defined(HAVE_ALSA) #include <string.h> #include <fcntl.h> #include <sys/ioctl.h> #ifdef HAVE_ERRNO_H #include <errno.h> #endif static int get_format(ft_t ft, int formats, int *fmt); #if HAVE_ALSA9 #include <limits.h> #include <sound/asound.h> /* Backwards compatibility. */ #define SND_PCM_SFMT_S8 SNDRV_PCM_FORMAT_S8 #define SND_PCM_SFMT_U8 SNDRV_PCM_FORMAT_U8 #define SND_PCM_SFMT_S16_LE SNDRV_PCM_FORMAT_S16 #define SND_PCM_SFMT_U16_LE SNDRV_PCM_FORMAT_U16 #define SND_PCM_FMT_S8 (1 << SNDRV_PCM_FORMAT_S8) #define SND_PCM_FMT_U8 (1 << SNDRV_PCM_FORMAT_U8) #define SND_PCM_FMT_S16 (1 << SNDRV_PCM_FORMAT_S16) #define SND_PCM_FMT_U16 (1 << SNDRV_PCM_FORMAT_U16) #define alsa_params_masks(p, i) \ (&((p)->masks[(i)-SNDRV_PCM_HW_PARAM_FIRST_MASK])) #define alsa_params_intervals(p, i) \ (&((p)->intervals[(i)-SNDRV_PCM_HW_PARAM_FIRST_INTERVAL])) struct alsa_info { unsigned int formats; unsigned int min_buffer_size; unsigned int max_buffer_size; unsigned int min_channels; unsigned int max_channels; unsigned int min_rate; unsigned int max_rate; unsigned int min_periods; unsigned int max_periods; unsigned int min_period_size; unsigned int max_period_size; }; struct alsa_setup { int format; char channels; st_rate_t rate; size_t buffer_size; int periods; size_t period_size; }; int alsa_hw_info_get(fd, a_info, params) int fd; struct alsa_info *a_info; struct sndrv_pcm_hw_params *params; { unsigned int i; struct sndrv_mask *msk; struct sndrv_interval *intr; memset(params, '\0', sizeof(struct sndrv_pcm_hw_params)); for (i = 0; i <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; ++i) { if (i >= SNDRV_PCM_HW_PARAM_FIRST_MASK && i <= SNDRV_PCM_HW_PARAM_LAST_MASK) { msk = alsa_params_masks(params, i); memset(msk->bits, 0xff, sizeof(msk->bits)); } else { intr = alsa_params_intervals(params, i); intr->min = 0; intr->openmin = 0; intr->max = UINT_MAX; intr->openmax = 0; intr->integer = 0; intr->empty = 0; } params->cmask |= 1 << i; params->rmask |= 1 << i; } if (ioctl(fd, SNDRV_PCM_IOCTL_HW_REFINE, params) < 0) { return -1; } msk = alsa_params_masks(params, SNDRV_PCM_HW_PARAM_FORMAT); a_info->formats = msk->bits[0]; /* Only care about first 32 bits. */ a_info->min_buffer_size = alsa_params_intervals(params, SNDRV_PCM_HW_PARAM_BUFFER_BYTES)->min; a_info->max_buffer_size = alsa_params_intervals(params, SNDRV_PCM_HW_PARAM_BUFFER_BYTES)->max; a_info->min_channels = alsa_params_intervals(params, SNDRV_PCM_HW_PARAM_CHANNELS)->min; a_info->max_channels = alsa_params_intervals(params, SNDRV_PCM_HW_PARAM_CHANNELS)->max; a_info->min_rate = alsa_params_intervals(params, SNDRV_PCM_HW_PARAM_RATE)->min; a_info->max_rate = alsa_params_intervals(params, SNDRV_PCM_HW_PARAM_RATE)->max; a_info->min_periods = alsa_params_intervals(params, SNDRV_PCM_HW_PARAM_PERIODS)->min; a_info->max_periods = alsa_params_intervals(params, SNDRV_PCM_HW_PARAM_PERIODS)->max; a_info->min_period_size = alsa_params_intervals(params, SNDRV_PCM_HW_PARAM_PERIOD_BYTES)->min; a_info->max_period_size = alsa_params_intervals(params, SNDRV_PCM_HW_PARAM_PERIOD_BYTES)->max; return 0; } int alsa_hw_info_set(fd, params, setup) int fd; struct sndrv_pcm_hw_params *params; struct alsa_setup *setup; { int i; struct sndrv_mask *msk; struct sndrv_interval *intr; i = SNDRV_PCM_HW_PARAM_ACCESS; msk = alsa_params_masks(params, i); msk->bits[0] &= 1 << SNDRV_PCM_ACCESS_RW_INTERLEAVED; /* Only care about first 32 bits. */ params->cmask = 1 << i; params->rmask = 1 << i; i = SNDRV_PCM_HW_PARAM_FORMAT; msk = alsa_params_masks(params, i); msk->bits[0] &= 1 << setup->format; /* Only care about first 32 bits. */ params->cmask = 1 << i; params->rmask = 1 << i; i = SNDRV_PCM_HW_PARAM_CHANNELS; intr = alsa_params_intervals(params, i); intr->empty = 0; intr->min = intr->max = setup->channels; intr->openmin = intr->openmax = 0; intr->integer = 1; params->cmask = 1 << i; params->rmask = 1 << i; i = SNDRV_PCM_HW_PARAM_RATE; intr = alsa_params_intervals(params, i); intr->empty = 0; intr->min = intr->max = setup->rate; intr->openmin = intr->openmax = 0; intr->integer = 1; params->cmask = 1 << i; params->rmask = 1 << i; i = SNDRV_PCM_HW_PARAM_BUFFER_BYTES; intr = alsa_params_intervals(params, i); intr->empty = 0; intr->min = intr->max = setup->buffer_size; intr->openmin = intr->openmax = 0; intr->integer = 1; params->cmask = 1 << i; params->rmask = 1 << i; i = SNDRV_PCM_HW_PARAM_PERIODS; intr = alsa_params_intervals(params, i); intr->empty = 0; intr->min = intr->max = setup->periods; intr->openmin = intr->openmax = 0; intr->integer = 1; params->cmask = 1 << i; params->rmask = 1 << i; i = SNDRV_PCM_HW_PARAM_PERIOD_BYTES; intr = alsa_params_intervals(params, i); intr->empty = 0; intr->min = intr->max = setup->period_size; intr->openmin = intr->openmax = 0; intr->integer = 1; params->cmask = 1 << i; params->rmask = 1 << i; if (ioctl(fd, SNDRV_PCM_IOCTL_HW_PARAMS, params) < 0) { return -1; } if (ioctl(fd, SNDRV_PCM_IOCTL_PREPARE) < 0) { return -1; } return 0; } /* * Do anything required before you start reading samples. * Read file header. * Find out sampling rate, * size and encoding of samples, * mono/stereo/quad. */ int st_alsastartread(ft) ft_t ft; { int fmt; struct alsa_info a_info; struct alsa_setup a_setup; struct sndrv_pcm_hw_params params; if (alsa_hw_info_get(fileno(ft->fp), &a_info, ¶ms) < 0) { st_fail_errno(ft,ST_EPERM,"ioctl operation failed %d",errno); return(ST_EOF); } ft->file.count = 0; ft->file.pos = 0; ft->file.eof = 0; ft->file.size = a_info.max_buffer_size; if ((ft->file.buf = malloc (ft->file.size)) == NULL) { st_fail_errno(ft,ST_ENOMEM,"unable to allocate output buffer of size %d", ft->file.size); return(ST_EOF); } if (ft->info.rate < a_info.min_rate) ft->info.rate = 2 * a_info.min_rate; else if (ft->info.rate > a_info.max_rate) ft->info.rate = a_info.max_rate; if (ft->info.channels == -1) ft->info.channels = a_info.min_channels; else if (ft->info.channels > a_info.max_channels) ft->info.channels = a_info.max_channels; if (get_format(ft, a_info.formats, &fmt) < 0) return (ST_EOF); a_setup.format = fmt; a_setup.channels = ft->info.channels; a_setup.rate = ft->info.rate; a_setup.buffer_size = ft->file.size; a_setup.periods = 16; if (a_setup.periods < a_info.min_periods) a_setup.periods = a_info.min_periods; else if (a_setup.periods > a_info.max_periods) a_setup.periods = a_info.max_periods; a_setup.period_size = a_setup.buffer_size / a_setup.periods; if (a_setup.period_size < a_info.min_period_size) a_setup.period_size = a_info.min_period_size; else if (a_setup.period_size > a_info.max_period_size) a_setup.period_size = a_info.max_period_size; if (alsa_hw_info_set(fileno(ft->fp), ¶ms, &a_setup) < 0) { st_fail_errno(ft,ST_EPERM,"ioctl operation failed %d",errno); return(ST_EOF); } /* Change to non-buffered I/O */ setvbuf(ft->fp, NULL, _IONBF, sizeof(char) * ft->file.size); sigintreg(ft); /* Prepare to catch SIGINT */ return (ST_SUCCESS); } int st_alsastartwrite(ft) ft_t ft; { int fmt; struct alsa_info a_info; struct alsa_setup a_setup; struct sndrv_pcm_hw_params params; if (alsa_hw_info_get(fileno(ft->fp), &a_info, ¶ms) < 0) { st_fail_errno(ft,ST_EPERM,"ioctl operation failed %d",errno); return(ST_EOF); } ft->file.pos = 0; ft->file.eof = 0; ft->file.size = a_info.max_buffer_size; if ((ft->file.buf = malloc (ft->file.size)) == NULL) { st_fail_errno(ft,ST_ENOMEM,"unable to allocate output buffer of size %d", ft->file.size); return(ST_EOF); } if (ft->info.rate < a_info.min_rate) ft->info.rate = 2 * a_info.min_rate; else if (ft->info.rate > a_info.max_rate) ft->info.rate = a_info.max_rate; if (ft->info.channels == -1) ft->info.channels = a_info.min_channels; else if (ft->info.channels > a_info.max_channels) ft->info.channels = a_info.max_channels; if (get_format(ft, a_info.formats, &fmt) < 0) return (ST_EOF); a_setup.format = fmt; a_setup.channels = ft->info.channels; a_setup.rate = ft->info.rate; a_setup.buffer_size = ft->file.size; a_setup.periods = 16; if (a_setup.periods < a_info.min_periods) a_setup.periods = a_info.min_periods; else if (a_setup.periods > a_info.max_periods) a_setup.periods = a_info.max_periods; a_setup.period_size = a_setup.buffer_size / a_setup.periods; if (a_setup.period_size < a_info.min_period_size) a_setup.period_size = a_info.min_period_size; else if (a_setup.period_size > a_info.max_period_size) a_setup.period_size = a_info.max_period_size; if (alsa_hw_info_set(fileno(ft->fp), ¶ms, &a_setup) < 0) { st_fail_errno(ft,ST_EPERM,"ioctl operation failed %d",errno); return(ST_EOF); } /* Change to non-buffered I/O */ setvbuf(ft->fp, NULL, _IONBF, sizeof(char) * ft->file.size); return(ST_SUCCESS); } int st_alsastopwrite(ft) ft_t ft; { ioctl(fileno(ft->fp), SNDRV_PCM_IOCTL_DRAIN); return(st_rawstopwrite(ft)); } #else /* ! HAVE_ALSA9 */ #include <linux/asound.h> #if HAVE_ALSA4 /* Start 0.4.x API */ int st_alsastartread(ft) ft_t ft; { int bps, fmt, size; snd_pcm_capture_info_t c_info; snd_pcm_format_t format; snd_pcm_capture_params_t c_params; memset(&c_info, 0, sizeof(c_info)); if (ioctl(fileno(ft->fp), SND_PCM_IOCTL_CAPTURE_INFO, &c_info) < 0) { st_fail_errno(ft,ST_EPERM,"ioctl operation failed %d",errno); return(ST_EOF); } ft->file.count = 0; ft->file.pos = 0; ft->file.eof = 0; ft->file.size = c_info.buffer_size; if ((ft->file.buf = malloc (ft->file.size)) == NULL) { st_fail_errno(ft,ST_ENOMEM,"unable to allocate output buffer of size %d", ft->file.size); return(ST_EOF); } if (ft->info.rate < c_info.min_rate) ft->info.rate = 2 * c_info.min_rate; else if (ft->info.rate > c_info.max_rate) ft->info.rate = c_info.max_rate; if (ft->info.channels == -1) ft->info.channels = c_info.min_channels; else if (ft->info.channels > c_info.max_channels) ft->info.channels = c_info.max_channels; if (get_format(ft, c_info.hw_formats, &fmt) < 0) return(ST_EOF); memset(&format, 0, sizeof(format)); format.format = fmt; format.rate = ft->info.rate; format.channels = ft->info.channels; if (ioctl(fileno(ft->fp), SND_PCM_IOCTL_CAPTURE_FORMAT, &format) < 0) { st_fail_errno(ft,ST_EPERM,"ioctl operation failed %d",errno); return(ST_EOF); } size = ft->file.size; bps = format.rate * format.channels; if (ft->info.size == ST_SIZE_WORD) bps <<= 1; bps >>= 2; while (size > bps) size >>= 1; if (size < 16) size = 16; memset(&c_params, 0, sizeof(c_params)); c_params.fragment_size = size; c_params.fragments_min = 1; if (ioctl(fileno(ft->fp), SND_PCM_IOCTL_CAPTURE_PARAMS, &c_params) < 0) { st_fail_errno(ft,ST_EPERM,"ioctl operation failed %d",errno); return(ST_EOF); } /* Change to non-buffered I/O */ setvbuf(ft->fp, NULL, _IONBF, sizeof(char) * ft->file.size); sigintreg(ft); /* Prepare to catch SIGINT */ return (ST_SUCCESS); } int st_alsastartwrite(ft) ft_t ft; { int bps, fmt, size; snd_pcm_playback_info_t p_info; snd_pcm_format_t format; snd_pcm_playback_params_t p_params; memset(&p_info, 0, sizeof(p_info)); if (ioctl(fileno(ft->fp), SND_PCM_IOCTL_PLAYBACK_INFO, &p_info) < 0) { st_fail_errno(ft,ST_EPERM,"ioctl operation failed %d",errno); return(ST_EOF); } ft->file.pos = 0; ft->file.eof = 0; ft->file.size = p_info.buffer_size; if ((ft->file.buf = malloc (ft->file.size)) == NULL) { st_fail_errno(ft,ST_ENOMEM,"unable to allocate output buffer of size %d", ft->file.size); return(ST_EOF); } if (ft->info.rate < p_info.min_rate) ft->info.rate = 2 * p_info.min_rate; else if (ft->info.rate > p_info.max_rate) ft->info.rate = p_info.max_rate; if (ft->info.channels == -1) ft->info.channels = p_info.min_channels; else if (ft->info.channels > p_info.max_channels) ft->info.channels = p_info.max_channels; if (get_format(ft, p_info.hw_formats, &fmt) < 0) return(ST_EOF); memset(&format, 0, sizeof(format)); format.format = fmt; format.rate = ft->info.rate; format.channels = ft->info.channels; if (ioctl(fileno(ft->fp), SND_PCM_IOCTL_PLAYBACK_FORMAT, &format) < 0) { st_fail_errno(ft,ST_EPERM,"ioctl operation failed %d",errno); return(ST_EOF); } size = ft->file.size; bps = format.rate * format.channels; if (ft->info.size == ST_SIZE_WORD) bps <<= 1; bps >>= 2; while (size > bps) size >>= 1; if (size < 16) size = 16; memset(&p_params, 0, sizeof(p_params)); p_params.fragment_size = size; p_params.fragments_max = -1; p_params.fragments_room = 1; if (ioctl(fileno(ft->fp), SND_PCM_IOCTL_PLAYBACK_PARAMS, &p_params) < 0) { st_fail_errno(ft,ST_EPERM,"ioctl operation failed %d",errno); return(ST_EOF); } /* Change to non-buffered I/O */ setvbuf(ft->fp, NULL, _IONBF, sizeof(char) * ft->file.size); return(ST_SUCCESS); } int st_alsastopwrite(ft) ft_t ft; { /* Is there a drain operation for ALSA 0.4.X? */ return(st_rawstopwrite(ft)); } #elif HAVE_ALSA5 /* Start 0.5.x API */ int st_alsastartread(ft) ft_t ft; { int bps, fmt, size; snd_pcm_channel_info_t c_info; snd_pcm_channel_params_t c_params; memset(&c_info, 0, sizeof(c_info)); if (ioctl(fileno(ft->fp), SND_PCM_IOCTL_CHANNEL_INFO, &c_info) < 0) { st_fail_errno(ft,ST_EPERM,"ioctl operation failed %d",errno); return(ST_EOF); } ft->file.count = 0; ft->file.pos = 0; ft->file.eof = 0; ft->file.size = c_info.buffer_size; if ((ft->file.buf = malloc (ft->file.size)) == NULL) { st_fail_errno(ft,ST_ENOMEM,"unable to allocate output buffer of size %d", ft->file.size); return(ST_EOF); } if (ft->info.rate < c_info.min_rate) ft->info.rate = 2 * c_info.min_rate; else if (ft->info.rate > c_info.max_rate) ft->info.rate = c_info.max_rate; if (ft->info.channels == -1) ft->info.channels = c_info.min_voices; else if (ft->info.channels > c_info.max_voices) ft->info.channels = c_info.max_voices; if (get_format(ft, c_info.formats, &fmt) < 0) return (ST_EOF); memset(&c_params, 0, sizeof(c_params)); c_params.format.format = fmt; c_params.format.rate = ft->info.rate; c_params.format.voices = ft->info.channels; c_params.format.interleave = 1; c_params.channel = SND_PCM_CHANNEL_CAPTURE; c_params.mode = SND_PCM_MODE_BLOCK; c_params.start_mode = SND_PCM_START_DATA; c_params.stop_mode = SND_PCM_STOP_STOP; bps = c_params.format.rate * c_params.format.voices; if (ft->info.size == ST_SIZE_WORD) bps <<= 1; bps >>= 2; size = 1; while ((size << 1) < bps) size <<= 1; if (size > ft->file.size) size = ft->file.size; if (size < c_info.min_fragment_size) size = c_info.min_fragment_size; else if (size > c_info.max_fragment_size) size = c_info.max_fragment_size; c_params.buf.block.frag_size = size; c_params.buf.block.frags_max = 32; c_params.buf.block.frags_min = 1; if (ioctl(fileno(ft->fp), SND_PCM_IOCTL_CHANNEL_PARAMS, &c_params) < 0) { st_fail_errno(ft,ST_EPERM,"ioctl operation failed %d",errno); return(ST_EOF); } if (ioctl(fileno(ft->fp), SND_PCM_IOCTL_CHANNEL_PREPARE) < 0) { st_fail_errno(ft,ST_EPERM,"ioctl operation failed %d",errno); return(ST_EOF); } /* Change to non-buffered I/O */ setvbuf(ft->fp, NULL, _IONBF, sizeof(char) * ft->file.size); sigintreg(ft); /* Prepare to catch SIGINT */ return (ST_SUCCESS); } int st_alsastartwrite(ft) ft_t ft; { int bps, fmt, size; snd_pcm_channel_info_t p_info; snd_pcm_channel_params_t p_params; memset(&p_info, 0, sizeof(p_info)); if (ioctl(fileno(ft->fp), SND_PCM_IOCTL_CHANNEL_INFO, &p_info) < 0) { st_fail_errno(ft,ST_EPERM,"ioctl operation failed %d",errno); return(ST_EOF); } ft->file.pos = 0; ft->file.eof = 0; ft->file.size = p_info.buffer_size; if ((ft->file.buf = malloc (ft->file.size)) == NULL) { st_fail_errno(ft,ST_ENOMEM,"unable to allocate output buffer of size %d", ft->file.size); return(ST_EOF); } if (ft->info.rate < p_info.min_rate) ft->info.rate = 2 * p_info.min_rate; else if (ft->info.rate > p_info.max_rate) ft->info.rate = p_info.max_rate; if (ft->info.channels == -1) ft->info.channels = p_info.min_voices; else if (ft->info.channels > p_info.max_voices) ft->info.channels = p_info.max_voices; if (get_format(ft, p_info.formats, &fmt) < 0) return(ST_EOF); memset(&p_params, 0, sizeof(p_params)); p_params.format.format = fmt; p_params.format.rate = ft->info.rate; p_params.format.voices = ft->info.channels; p_params.format.interleave = 1; p_params.channel = SND_PCM_CHANNEL_PLAYBACK; p_params.mode = SND_PCM_MODE_BLOCK; p_params.start_mode = SND_PCM_START_DATA; p_params.stop_mode = SND_PCM_STOP_STOP; bps = p_params.format.rate * p_params.format.voices; if (ft->info.size == ST_SIZE_WORD) bps <<= 1; bps >>= 2; size = 1; while ((size << 1) < bps) size <<= 1; if (size > ft->file.size) size = ft->file.size; if (size < p_info.min_fragment_size) size = p_info.min_fragment_size; else if (size > p_info.max_fragment_size) size = p_info.max_fragment_size; p_params.buf.block.frag_size = size; p_params.buf.block.frags_max = -1; /* Little trick (playback only) */ p_params.buf.block.frags_min = 1; if (ioctl(fileno(ft->fp), SND_PCM_IOCTL_CHANNEL_PARAMS, &p_params) < 0) { st_fail_errno(ft,ST_EPERM,"ioctl operation failed %d",errno); return(ST_EOF); } if (ioctl(fileno(ft->fp), SND_PCM_IOCTL_CHANNEL_PREPARE) < 0) { st_fail_errno(ft,ST_EPERM,"ioctl operation failed %d",errno); return(ST_EOF); } /* Change to non-buffered I/O */ setvbuf(ft->fp, NULL, _IONBF, sizeof(char) * ft->file.size); return(ST_SUCCESS); } int st_alsastopwrite(ft) ft_t ft; { ioctl(fileno(ft->fp), SND_PCM_IOCTL_CHANNEL_DRAIN); return(st_rawstopwrite(ft)); } #endif /* HAVE_ALSA4/5 */ #endif /* HAVE_ALSA9 */ #define EMSGFMT "ALSA driver does not support %s %s output" static int get_format(ft, formats, fmt) ft_t ft; int formats, *fmt; { if (ft->info.size == -1) { if ((formats & SND_PCM_FMT_U8) || (formats & SND_PCM_FMT_S8)) ft->info.size = ST_SIZE_BYTE; else ft->info.size = ST_SIZE_WORD; } if (ft->info.encoding == -1) { if ((formats & SND_PCM_FMT_S16) || (formats & SND_PCM_FMT_S8)) ft->info.encoding = ST_ENCODING_SIGN2; else ft->info.encoding = ST_ENCODING_UNSIGNED; } if (ft->info.size == ST_SIZE_BYTE) { switch (ft->info.encoding) { case ST_ENCODING_SIGN2: if (!(formats & SND_PCM_FMT_S8)) { st_fail_errno(ft,ST_EFMT,"ALSA driver does not support signed byte samples"); return ST_EOF; } *fmt = SND_PCM_SFMT_S8; break; case ST_ENCODING_UNSIGNED: if (!(formats & SND_PCM_FMT_U8)) { st_fail_errno(ft,ST_EFMT,"ALSA driver does not support unsigned byte samples"); return ST_EOF; } *fmt = SND_PCM_SFMT_U8; break; default: st_fail_errno(ft,ST_EFMT,EMSGFMT,st_encodings_str[(unsigned char)ft->info.encoding],"byte"); return ST_EOF; break; } } else if (ft->info.size == ST_SIZE_WORD) { switch (ft->info.encoding) { case ST_ENCODING_SIGN2: if (!(formats & SND_PCM_FMT_S16)) { st_fail_errno(ft,ST_EFMT,"ALSA driver does not support signed word samples"); return ST_EOF; } *fmt = SND_PCM_SFMT_S16_LE; break; case ST_ENCODING_UNSIGNED: if (!(formats & SND_PCM_FMT_U16)) { st_fail_errno(ft,ST_EFMT,"ALSA driver does not support unsigned word samples"); return ST_EOF; } *fmt = SND_PCM_SFMT_U16_LE; break; default: st_fail_errno(ft,ST_EFMT,EMSGFMT,st_encodings_str[(unsigned char)ft->info.encoding],"word"); return ST_EOF; break; } } else { st_fail_errno(ft,ST_EFMT,EMSGFMT,st_encodings_str[(unsigned char)ft->info.encoding],st_sizes_str[(unsigned char)ft->info.size]); return ST_EOF; } return 0; } st_ssize_t st_alsaread(ft_t ft, st_sample_t *buf, st_ssize_t nsamp) { st_ssize_t len; len = st_rawread(ft, buf, nsamp); #if HAVE_ALSA9 /* ALSA 0.9 and above require that we detects underruns and * reset the driver if it occurs. */ if (len != nsamp) { /* Reset the driver. A future enhancement would be to * fill up the empty spots in the buffer (starting at * nsamp - len). But I'm being lazy (cbagwell) and just * returning with a partial buffer. */ ioctl(fileno(ft->fp), SNDRV_PCM_IOCTL_PREPARE); /* Raw routines use eof flag to store when we've * hit EOF or if an internal error occurs. The * above ioctl is much like calling the stdio clearerr() function * and so we should reset libst's flag as well. If the * error condition is still really there, it will be * detected on a future read. */ ft->file.eof = ST_SUCCESS; } #endif return len; } st_ssize_t st_alsawrite(ft_t ft, st_sample_t *buf, st_ssize_t nsamp) { st_ssize_t len; len = st_rawwrite(ft, buf, nsamp); #if HAVE_ALSA9 /* ALSA 0.9 and above require that we detects overruns and * reset the driver if it occurs. */ if (len != nsamp) { /* Reset the driver. A future enhancement would be to * resend the remaining data (starting at (nsamp - len) in the buffer). * But since we've already lost some data, I'm being lazy * and letting a little more data be lost as well. */ ioctl(fileno(ft->fp), SNDRV_PCM_IOCTL_PREPARE); /* Raw routines use eof flag to store when an internal error * the above ioctl is much like calling the stdio clearerr() function * and so we should reset libst's flag as well. If the * error condition is still really there, it will be * detected on a future write. */ ft->file.eof = ST_SUCCESS; } #endif return len; } #endif /* HAVE_ALSA */