ref: 5e23e9c24393638380e8474fae1f42661c498967
dir: /src/alsa.c/
/* libSoX device driver: ALSA (c) 2006-2012 SoX contributors
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 2.1 of the License, or (at
* your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
* General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "sox_i.h"
#include <alsa/asoundlib.h>
typedef struct {
snd_pcm_uframes_t buf_len, period;
snd_pcm_t * pcm;
char * buf;
unsigned int format;
} priv_t;
static const
struct {
unsigned int bits;
enum _snd_pcm_format alsa_fmt;
unsigned int bytes; /* occupied in the buffer per sample */
sox_encoding_t enc;
} formats[] = {
/* order by # of bits; within that, preferred first */
{ 8, SND_PCM_FORMAT_S8, 1, SOX_ENCODING_SIGN2 },
{ 8, SND_PCM_FORMAT_U8, 1, SOX_ENCODING_UNSIGNED },
{ 16, SND_PCM_FORMAT_S16, 2, SOX_ENCODING_SIGN2 },
{ 16, SND_PCM_FORMAT_U16, 2, SOX_ENCODING_UNSIGNED },
{ 24, SND_PCM_FORMAT_S24, 4, SOX_ENCODING_SIGN2 },
{ 24, SND_PCM_FORMAT_U24, 4, SOX_ENCODING_UNSIGNED },
{ 24, SND_PCM_FORMAT_S24_3LE, 3, SOX_ENCODING_SIGN2 },
{ 32, SND_PCM_FORMAT_S32, 4, SOX_ENCODING_SIGN2 },
{ 32, SND_PCM_FORMAT_U32, 4, SOX_ENCODING_UNSIGNED },
{ 0, 0, 0, SOX_ENCODING_UNKNOWN } /* end of list */
};
static int select_format(
sox_encoding_t * encoding_,
unsigned * nbits_,
snd_pcm_format_mask_t const * mask,
unsigned int * format)
{
unsigned int from = 0, to; /* NB: "to" actually points one after the last */
int cand = -1;
while (formats[from].bits < *nbits_ && formats[from].bits != 0)
from++; /* find the first entry with at least *nbits_ bits */
for (to = from; formats[to].bits != 0; to++) ; /* find end of list */
while (to > 0) {
unsigned int i, bits_next = 0;
for (i = from; i < to; i++) {
lsx_debug_most("select_format: trying #%u", i);
if (snd_pcm_format_mask_test(mask, formats[i].alsa_fmt)) {
if (formats[i].enc == *encoding_) {
cand = i;
break; /* found a match */
} else if (cand == -1) /* don't overwrite a candidate that
was earlier in the list */
cand = i; /* will work, but encoding differs */
}
}
if (cand != -1)
break;
/* no candidate found yet; now try formats with less bits: */
to = from;
if (from > 0)
bits_next = formats[from-1].bits;
while (from && formats[from-1].bits == bits_next)
from--; /* go back to the first entry with bits_next bits */
}
if (cand == -1) {
lsx_debug("select_format: no suitable ALSA format found");
return -1;
}
if (*nbits_ != formats[cand].bits || *encoding_ != formats[cand].enc) {
lsx_warn("can't encode %u-bit %s", *nbits_,
sox_encodings_info[*encoding_].desc);
*nbits_ = formats[cand].bits;
*encoding_ = formats[cand].enc;
}
lsx_debug("selecting format %d: %s (%s)", cand,
snd_pcm_format_name(formats[cand].alsa_fmt),
snd_pcm_format_description(formats[cand].alsa_fmt));
*format = cand;
return 0;
}
#define _(x,y) do {if ((err = x y) < 0) {lsx_fail_errno(ft, SOX_EPERM, #x " error: %s", snd_strerror(err)); goto error;} } while (0)
static int setup(sox_format_t * ft)
{
priv_t * p = (priv_t *)ft->priv;
snd_pcm_hw_params_t * params = NULL;
snd_pcm_format_mask_t * mask = NULL;
snd_pcm_uframes_t min, max;
unsigned n;
int err;
_(snd_pcm_open, (&p->pcm, ft->filename, ft->mode == 'r'? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK, 0));
_(snd_pcm_hw_params_malloc, (¶ms));
_(snd_pcm_hw_params_any, (p->pcm, params));
#if SND_LIB_VERSION >= 0x010009 /* Disable alsa-lib resampling: */
_(snd_pcm_hw_params_set_rate_resample, (p->pcm, params, 0));
#endif
_(snd_pcm_hw_params_set_access, (p->pcm, params, SND_PCM_ACCESS_RW_INTERLEAVED));
_(snd_pcm_format_mask_malloc, (&mask)); /* Set format: */
snd_pcm_hw_params_get_format_mask(params, mask);
_(select_format, (&ft->encoding.encoding, &ft->encoding.bits_per_sample, mask, &p->format));
_(snd_pcm_hw_params_set_format, (p->pcm, params, formats[p->format].alsa_fmt));
snd_pcm_format_mask_free(mask), mask = NULL;
n = ft->signal.rate; /* Set rate: */
_(snd_pcm_hw_params_set_rate_near, (p->pcm, params, &n, 0));
ft->signal.rate = n;
n = ft->signal.channels; /* Set channels: */
_(snd_pcm_hw_params_set_channels_near, (p->pcm, params, &n));
ft->signal.channels = n;
/* Get number of significant bits: */
if ((err = snd_pcm_hw_params_get_sbits(params)) > 0)
ft->signal.precision = min(err, SOX_SAMPLE_PRECISION);
else lsx_debug("snd_pcm_hw_params_get_sbits can't tell precision: %s",
snd_strerror(err));
/* Set buf_len > > sox_globals.bufsiz for no underrun: */
p->buf_len = sox_globals.bufsiz * 8 / formats[p->format].bytes /
ft->signal.channels;
_(snd_pcm_hw_params_get_buffer_size_min, (params, &min));
_(snd_pcm_hw_params_get_buffer_size_max, (params, &max));
p->period = range_limit(p->buf_len, min, max) / 8;
p->buf_len = p->period * 8;
_(snd_pcm_hw_params_set_period_size_near, (p->pcm, params, &p->period, 0));
_(snd_pcm_hw_params_set_buffer_size_near, (p->pcm, params, &p->buf_len));
if (p->period * 2 > p->buf_len) {
lsx_fail_errno(ft, SOX_EPERM, "buffer too small");
goto error;
}
_(snd_pcm_hw_params, (p->pcm, params)); /* Configure ALSA */
snd_pcm_hw_params_free(params), params = NULL;
_(snd_pcm_prepare, (p->pcm));
p->buf_len *= ft->signal.channels; /* No longer in `frames' */
p->buf = lsx_malloc(p->buf_len * formats[p->format].bytes);
return SOX_SUCCESS;
error:
if (mask) snd_pcm_format_mask_free(mask);
if (params) snd_pcm_hw_params_free(params);
return SOX_EOF;
}
static int recover(sox_format_t * ft, snd_pcm_t * pcm, int err)
{
if (err == -EPIPE)
lsx_warn("%s-run", ft->mode == 'r'? "over" : "under");
else if (err != -ESTRPIPE)
lsx_warn("%s", snd_strerror(err));
else while ((err = snd_pcm_resume(pcm)) == -EAGAIN) {
lsx_report("suspended");
sleep(1); /* Wait until the suspend flag is released */
}
if (err < 0 && (err = snd_pcm_prepare(pcm)) < 0)
lsx_fail_errno(ft, SOX_EPERM, "%s", snd_strerror(err));
return err;
}
static size_t read_(sox_format_t * ft, sox_sample_t * buf, size_t len)
{
priv_t * p = (priv_t *)ft->priv;
snd_pcm_sframes_t i, n;
size_t done;
len = min(len, p->buf_len);
for (done = 0; done < len; done += n) {
do {
n = snd_pcm_readi(p->pcm, p->buf, (len - done) / ft->signal.channels);
if (n < 0 && recover(ft, p->pcm, (int)n) < 0)
return 0;
} while (n <= 0);
i = n *= ft->signal.channels;
switch (formats[p->format].alsa_fmt) {
case SND_PCM_FORMAT_S8: {
int8_t * buf1 = (int8_t *)p->buf;
while (i--) *buf++ = SOX_SIGNED_8BIT_TO_SAMPLE(*buf1++,);
break;
}
case SND_PCM_FORMAT_U8: {
uint8_t * buf1 = (uint8_t *)p->buf;
while (i--) *buf++ = SOX_UNSIGNED_8BIT_TO_SAMPLE(*buf1++,);
break;
}
case SND_PCM_FORMAT_S16: {
int16_t * buf1 = (int16_t *)p->buf;
if (ft->encoding.reverse_bytes) while (i--)
*buf++ = SOX_SIGNED_16BIT_TO_SAMPLE(lsx_swapw(*buf1++),);
else
while (i--) *buf++ = SOX_SIGNED_16BIT_TO_SAMPLE(*buf1++,);
break;
}
case SND_PCM_FORMAT_U16: {
uint16_t * buf1 = (uint16_t *)p->buf;
if (ft->encoding.reverse_bytes) while (i--)
*buf++ = SOX_UNSIGNED_16BIT_TO_SAMPLE(lsx_swapw(*buf1++),);
else
while (i--) *buf++ = SOX_UNSIGNED_16BIT_TO_SAMPLE(*buf1++,);
break;
}
case SND_PCM_FORMAT_S24: {
sox_int24_t * buf1 = (sox_int24_t *)p->buf;
while (i--) *buf++ = SOX_SIGNED_24BIT_TO_SAMPLE(*buf1++,);
break;
}
case SND_PCM_FORMAT_S24_3LE: {
unsigned char *buf1 = (unsigned char *)p->buf;
while (i--) {
uint32_t temp;
temp = *buf1++;
temp |= *buf1++ << 8;
temp |= *buf1++ << 16;
*buf++ = SOX_SIGNED_24BIT_TO_SAMPLE((sox_int24_t)temp,);
}
break;
}
case SND_PCM_FORMAT_U24: {
sox_uint24_t * buf1 = (sox_uint24_t *)p->buf;
while (i--) *buf++ = SOX_UNSIGNED_24BIT_TO_SAMPLE(*buf1++,);
break;
}
case SND_PCM_FORMAT_S32: {
int32_t * buf1 = (int32_t *)p->buf;
while (i--) *buf++ = SOX_SIGNED_32BIT_TO_SAMPLE(*buf1++,);
break;
}
case SND_PCM_FORMAT_U32: {
uint32_t * buf1 = (uint32_t *)p->buf;
while (i--) *buf++ = SOX_UNSIGNED_32BIT_TO_SAMPLE(*buf1++,);
break;
}
default: lsx_fail_errno(ft, SOX_EFMT, "invalid format");
return 0;
}
}
return len;
}
static size_t write_(sox_format_t * ft, sox_sample_t const * buf, size_t len)
{
priv_t * p = (priv_t *)ft->priv;
size_t done, i, n;
snd_pcm_sframes_t actual;
SOX_SAMPLE_LOCALS;
for (done = 0; done < len; done += n) {
i = n = min(len - done, p->buf_len);
switch (formats[p->format].alsa_fmt) {
case SND_PCM_FORMAT_S8: {
int8_t * buf1 = (int8_t *)p->buf;
while (i--) *buf1++ = SOX_SAMPLE_TO_SIGNED_8BIT(*buf++, ft->clips);
break;
}
case SND_PCM_FORMAT_U8: {
uint8_t * buf1 = (uint8_t *)p->buf;
while (i--) *buf1++ = SOX_SAMPLE_TO_UNSIGNED_8BIT(*buf++, ft->clips);
break;
}
case SND_PCM_FORMAT_S16: {
int16_t * buf1 = (int16_t *)p->buf;
if (ft->encoding.reverse_bytes) while (i--)
*buf1++ = lsx_swapw(SOX_SAMPLE_TO_SIGNED_16BIT(*buf++, ft->clips));
else
while (i--) *buf1++ = SOX_SAMPLE_TO_SIGNED_16BIT(*buf++, ft->clips);
break;
}
case SND_PCM_FORMAT_U16: {
uint16_t * buf1 = (uint16_t *)p->buf;
if (ft->encoding.reverse_bytes) while (i--)
*buf1++ = lsx_swapw(SOX_SAMPLE_TO_UNSIGNED_16BIT(*buf++, ft->clips));
else
while (i--) *buf1++ = SOX_SAMPLE_TO_UNSIGNED_16BIT(*buf++, ft->clips);
break;
}
case SND_PCM_FORMAT_S24: {
sox_int24_t * buf1 = (sox_int24_t *)p->buf;
while (i--) *buf1++ = SOX_SAMPLE_TO_SIGNED_24BIT(*buf++, ft->clips);
break;
}
case SND_PCM_FORMAT_S24_3LE: {
unsigned char *buf1 = (unsigned char *)p->buf;
while (i--) {
uint32_t temp = (uint32_t)SOX_SAMPLE_TO_SIGNED_24BIT(*buf++, ft->clips);
*buf1++ = (temp & 0x000000FF);
*buf1++ = (temp & 0x0000FF00) >> 8;
*buf1++ = (temp & 0x00FF0000) >> 16;
}
break;
}
case SND_PCM_FORMAT_U24: {
sox_uint24_t * buf1 = (sox_uint24_t *)p->buf;
while (i--) *buf1++ = SOX_SAMPLE_TO_UNSIGNED_24BIT(*buf++, ft->clips);
break;
}
case SND_PCM_FORMAT_S32: {
int32_t * buf1 = (int32_t *)p->buf;
while (i--) *buf1++ = SOX_SAMPLE_TO_SIGNED_32BIT(*buf++, ft->clips);
break;
}
case SND_PCM_FORMAT_U32: {
uint32_t * buf1 = (uint32_t *)p->buf;
while (i--) *buf1++ = SOX_SAMPLE_TO_UNSIGNED_32BIT(*buf++, ft->clips);
break;
}
default: lsx_fail_errno(ft, SOX_EFMT, "invalid format");
return 0;
}
for (i = 0; i < n; i += actual * ft->signal.channels) do {
actual = snd_pcm_writei(p->pcm,
p->buf + i * formats[p->format].bytes,
(n - i) / ft->signal.channels);
if (errno == EAGAIN) /* Happens naturally; don't report it: */
errno = 0;
if (actual < 0 && recover(ft, p->pcm, (int)actual) < 0)
return 0;
} while (actual < 0);
}
return len;
}
static int stop(sox_format_t * ft)
{
priv_t * p = (priv_t *)ft->priv;
snd_pcm_close(p->pcm);
free(p->buf);
return SOX_SUCCESS;
}
static int stop_write(sox_format_t * ft)
{
priv_t * p = (priv_t *)ft->priv;
size_t n = ft->signal.channels * p->period, npad = n - (ft->olength % n);
sox_sample_t * buf = lsx_calloc(npad, sizeof(*buf)); /* silent samples */
if (npad != n) /* pad to hardware period: */
write_(ft, buf, npad);
free(buf);
snd_pcm_drain(p->pcm);
return stop(ft);
}
LSX_FORMAT_HANDLER(alsa)
{
static char const * const names[] = {"alsa", NULL};
static unsigned const write_encodings[] = {
SOX_ENCODING_SIGN2 , 32, 24, 16, 8, 0,
SOX_ENCODING_UNSIGNED, 32, 24, 16, 8, 0,
0};
static sox_format_handler_t const handler = {SOX_LIB_VERSION_CODE,
"Advanced Linux Sound Architecture device driver",
names, SOX_FILE_DEVICE | SOX_FILE_NOSTDIO,
setup, read_, stop, setup, write_, stop_write,
NULL, write_encodings, NULL, sizeof(priv_t)
};
return &handler;
}