ref: 5fb5573e26bdac46be6953e0e0399d1a2aaeb350
dir: /src/sndio.c/
/*
* libsndio sound handler
*
* Copyright (c) 2009 Alexandre Ratchov <alex@caoua.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "sox_i.h"
#include <string.h>
#include <sndio.h>
struct sndio_priv {
struct sio_hdl *hdl; /* handle to speak to libsndio */
struct sio_par par; /* current device parameters */
#define SNDIO_BUFSZ 0x1000
unsigned char buf[SNDIO_BUFSZ]; /* temp buffer for converions */
};
/*
* convert ``count'' samples from sox encoding to sndio encoding
*/
static void encode(struct sio_par *par,
sox_sample_t const *idata, unsigned char *odata, unsigned count)
{
int obnext, osnext, s, osigbit;
unsigned oshift, obps, i;
obps = par->bps;
osigbit = par->sig ? 0 : 1 << (par->bits - 1);
oshift = 32 - (par->msb ? par->bps * 8 : par->bits);
if (par->le) {
obnext = 1;
osnext = 0;
} else {
odata += par->bps - 1;
obnext = -1;
osnext = 2 * par->bps;
}
for (; count > 0; count--) {
s = (*idata++ >> oshift) ^ osigbit;
for (i = obps; i > 0; i--) {
*odata = (unsigned char)s;
s >>= 8;
odata += obnext;
}
odata += osnext;
}
}
/*
* convert ``count'' samples from sndio encoding to sox encoding
*/
static void decode(struct sio_par *par,
unsigned char *idata, sox_sample_t *odata, unsigned count)
{
unsigned ishift, ibps, i;
int s = 0xdeadbeef, ibnext, isnext, isigbit;
ibps = par->bps;
isigbit = par->sig ? 0 : 1 << (par->bits - 1);
ishift = 32 - (par->msb ? par->bps * 8 : par->bits);
if (par->le) {
idata += par->bps - 1;
ibnext = -1;
isnext = 2 * par->bps;
} else {
ibnext = 1;
isnext = 0;
}
for (; count > 0; count--) {
for (i = ibps; i > 0; i--) {
s <<= 8;
s |= *idata;
idata += ibnext;
}
idata += isnext;
*odata++ = (s ^ isigbit) << ishift;
}
}
static int startany(sox_format_t *ft, unsigned mode)
{
struct sndio_priv *p = (struct sndio_priv *)ft->priv;
struct sio_par reqpar;
char *device;
device = ft->filename;
if (strcmp("default", device) == 0)
device = NULL;
p->hdl = sio_open(device, mode, 0);
if (p->hdl == NULL)
return SOX_EOF;
/*
* set specified parameters, leaving others to the defaults
*/
sio_initpar(&reqpar);
if (ft->signal.rate > 0)
reqpar.rate = ft->signal.rate;
if (ft->signal.channels > 0) {
if (mode == SIO_PLAY)
reqpar.pchan = ft->signal.channels;
else
reqpar.rchan = ft->signal.channels;
}
if (ft->signal.precision > 0)
reqpar.bits = ft->signal.precision;
switch (ft->encoding.encoding) {
case SOX_ENCODING_SIGN2:
reqpar.sig = 1;
break;
case SOX_ENCODING_UNSIGNED:
reqpar.sig = 0;
break;
default:
break; /* use device default */
}
if (ft->encoding.bits_per_sample > 0)
reqpar.bits = ft->encoding.bits_per_sample;
if (ft->encoding.reverse_bytes != sox_option_default) {
reqpar.le = SIO_LE_NATIVE;
if (ft->encoding.reverse_bytes)
reqpar.le = !reqpar.le;
}
if (!sio_setpar(p->hdl, &reqpar) ||
!sio_getpar(p->hdl, &p->par))
goto failed;
ft->signal.channels = (mode == SIO_PLAY) ? p->par.pchan : p->par.rchan;
ft->signal.precision = p->par.bits;
ft->signal.rate = p->par.rate;
ft->encoding.encoding = p->par.sig ? SOX_ENCODING_SIGN2 : SOX_ENCODING_UNSIGNED;
ft->encoding.bits_per_sample = p->par.bps * 8;
ft->encoding.reverse_bytes = SIO_LE_NATIVE ? !p->par.le : p->par.le;
ft->encoding.reverse_nibbles = sox_option_no;
ft->encoding.reverse_bits = sox_option_no;
if (!sio_start(p->hdl))
goto failed;
return SOX_SUCCESS;
failed:
sio_close(p->hdl);
return SOX_EOF;
}
static int stopany(sox_format_t *ft)
{
sio_close(((struct sndio_priv *)ft->priv)->hdl);
return SOX_SUCCESS;
}
static int startread(sox_format_t *ft)
{
return startany(ft, SIO_REC);
}
static int startwrite(sox_format_t *ft)
{
return startany(ft, SIO_PLAY);
}
static size_t readsamples(sox_format_t *ft, sox_sample_t *buf, size_t len)
{
struct sndio_priv *p = (struct sndio_priv *)ft->priv;
unsigned char partial[4];
unsigned cpb, cc, pc;
size_t todo, n;
pc = 0;
todo = len * p->par.bps;
cpb = SNDIO_BUFSZ - (SNDIO_BUFSZ % p->par.bps);
while (todo > 0) {
memcpy(p->buf, partial, (size_t)pc);
cc = cpb - pc;
if (cc > todo)
cc = todo;
n = sio_read(p->hdl, p->buf + pc, (size_t)cc);
if (n == 0 && sio_eof(p->hdl))
break;
n += pc;
pc = n % p->par.bps;
n -= pc;
memcpy(partial, p->buf + n, (size_t)pc);
decode(&p->par, p->buf, buf, (unsigned)(n / p->par.bps));
buf += n / p->par.bps;
todo -= n;
}
return len - todo / p->par.bps;
}
static size_t writesamples(sox_format_t *ft, const sox_sample_t *buf, size_t len)
{
struct sndio_priv *p = (struct sndio_priv *)ft->priv;
unsigned sc, spb;
size_t n, todo;
todo = len;
spb = SNDIO_BUFSZ / p->par.bps;
while (todo > 0) {
sc = spb;
if (sc > todo)
sc = todo;
encode(&p->par, buf, p->buf, sc);
n = sio_write(p->hdl, p->buf, (size_t)(sc * p->par.bps));
if (n == 0 && sio_eof(p->hdl))
break;
n /= p->par.bps;
todo -= n;
buf += n;
}
return len - todo;
}
LSX_FORMAT_HANDLER(sndio)
{
static char const * const names[] = {"sndio", 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,
"libsndio device driver",
names,
SOX_FILE_DEVICE | SOX_FILE_NOSTDIO,
startread, readsamples, stopany,
startwrite, writesamples, stopany,
NULL, write_encodings, NULL,
sizeof(struct sndio_priv)
};
return &handler;
}