mirror of https://github.com/ericonr/sndio.git
switch to new obsd audio api
This commit is contained in:
Alexandre Ratchov
parent
d6bc5ae04f
commit
85c75911dc
|
|
@ -42,7 +42,7 @@
|
|||
struct sio_sun_hdl {
|
||||
struct sio_hdl sio;
|
||||
int fd;
|
||||
int filling;
|
||||
int filltodo;
|
||||
unsigned int ibpf, obpf; /* bytes per frame */
|
||||
unsigned int ibytes, obytes; /* bytes the hw transferred */
|
||||
unsigned int ierr, oerr; /* frames the hw dropped */
|
||||
|
|
@ -77,127 +77,68 @@ static struct sio_ops sio_sun_ops = {
|
|||
NULL, /* getvol */
|
||||
};
|
||||
|
||||
/*
|
||||
* convert sun encoding to sio_par encoding
|
||||
*/
|
||||
static int
|
||||
sio_sun_infotoenc(struct sio_sun_hdl *hdl, struct audio_prinfo *ai,
|
||||
struct sio_par *par)
|
||||
sio_sun_adjpar(struct sio_sun_hdl *hdl, struct audio_swpar *ap)
|
||||
{
|
||||
par->msb = ai->msb;
|
||||
par->bits = ai->precision;
|
||||
par->bps = ai->bps;
|
||||
switch (ai->encoding) {
|
||||
case AUDIO_ENCODING_SLINEAR_LE:
|
||||
par->le = 1;
|
||||
par->sig = 1;
|
||||
break;
|
||||
case AUDIO_ENCODING_SLINEAR_BE:
|
||||
par->le = 0;
|
||||
par->sig = 1;
|
||||
break;
|
||||
case AUDIO_ENCODING_ULINEAR_LE:
|
||||
par->le = 1;
|
||||
par->sig = 0;
|
||||
break;
|
||||
case AUDIO_ENCODING_ULINEAR_BE:
|
||||
par->le = 0;
|
||||
par->sig = 0;
|
||||
break;
|
||||
case AUDIO_ENCODING_SLINEAR:
|
||||
par->le = SIO_LE_NATIVE;
|
||||
par->sig = 1;
|
||||
break;
|
||||
case AUDIO_ENCODING_ULINEAR:
|
||||
par->le = SIO_LE_NATIVE;
|
||||
par->sig = 0;
|
||||
break;
|
||||
default:
|
||||
DPRINTF("sio_sun_infotoenc: unsupported encoding\n");
|
||||
if (hdl->sio.eof)
|
||||
return 0;
|
||||
if (ioctl(hdl->fd, AUDIO_SETPAR, ap)) {
|
||||
DPERROR("AUDIO_SETPAR");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
}
|
||||
if (ioctl(hdl->fd, AUDIO_GETPAR, ap)) {
|
||||
DPERROR("AUDIO_GETPAR");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* convert sio_par encoding to sun encoding
|
||||
*/
|
||||
static void
|
||||
sio_sun_enctoinfo(struct sio_sun_hdl *hdl,
|
||||
unsigned int *renc, struct sio_par *par)
|
||||
{
|
||||
if (par->le == ~0U && par->sig == ~0U) {
|
||||
*renc = ~0U;
|
||||
} else if (par->le == ~0U || par->sig == ~0U) {
|
||||
*renc = AUDIO_ENCODING_SLINEAR;
|
||||
} else if (par->le && par->sig) {
|
||||
*renc = AUDIO_ENCODING_SLINEAR_LE;
|
||||
} else if (!par->le && par->sig) {
|
||||
*renc = AUDIO_ENCODING_SLINEAR_BE;
|
||||
} else if (par->le && !par->sig) {
|
||||
*renc = AUDIO_ENCODING_ULINEAR_LE;
|
||||
} else {
|
||||
*renc = AUDIO_ENCODING_ULINEAR_BE;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* try to set the device to the given parameters and check that the
|
||||
* device can use them; return 1 on success, 0 on failure or error
|
||||
*/
|
||||
static int
|
||||
sio_sun_tryinfo(struct sio_sun_hdl *hdl, struct sio_enc *enc,
|
||||
sio_sun_testpar(struct sio_sun_hdl *hdl, struct sio_enc *enc,
|
||||
unsigned int pchan, unsigned int rchan, unsigned int rate)
|
||||
{
|
||||
struct audio_info aui;
|
||||
struct audio_prinfo *pr;
|
||||
struct audio_swpar ap;
|
||||
|
||||
pr = (hdl->sio.mode & SIO_PLAY) ? &aui.play : &aui.record;
|
||||
|
||||
AUDIO_INITINFO(&aui);
|
||||
if (enc) {
|
||||
if (enc->le && enc->sig) {
|
||||
pr->encoding = AUDIO_ENCODING_SLINEAR_LE;
|
||||
} else if (!enc->le && enc->sig) {
|
||||
pr->encoding = AUDIO_ENCODING_SLINEAR_BE;
|
||||
} else if (enc->le && !enc->sig) {
|
||||
pr->encoding = AUDIO_ENCODING_ULINEAR_LE;
|
||||
} else {
|
||||
pr->encoding = AUDIO_ENCODING_ULINEAR_BE;
|
||||
}
|
||||
pr->precision = enc->bits;
|
||||
AUDIO_INITPAR(&ap);
|
||||
if (enc != NULL) {
|
||||
ap.sig = enc->sig;
|
||||
ap.bits = enc->bits;
|
||||
ap.bps = enc->bps;
|
||||
if (ap.bps > 1)
|
||||
ap.le = enc->le;
|
||||
if (ap.bps * 8 > ap.bits)
|
||||
ap.msb = enc->msb;
|
||||
}
|
||||
if (rate)
|
||||
pr->sample_rate = rate;
|
||||
if ((hdl->sio.mode & (SIO_PLAY | SIO_REC)) == (SIO_PLAY | SIO_REC))
|
||||
aui.record = aui.play;
|
||||
ap.rate = rate;
|
||||
if (pchan && (hdl->sio.mode & SIO_PLAY))
|
||||
aui.play.channels = pchan;
|
||||
ap.pchan = pchan;
|
||||
if (rchan && (hdl->sio.mode & SIO_REC))
|
||||
aui.record.channels = rchan;
|
||||
if (ioctl(hdl->fd, AUDIO_SETINFO, &aui) < 0) {
|
||||
if (errno == EINVAL)
|
||||
ap.rchan = rchan;
|
||||
if (!sio_sun_adjpar(hdl, &ap))
|
||||
return 0;
|
||||
if (pchan && ap.pchan != pchan)
|
||||
return 0;
|
||||
if (rchan && ap.rchan != rchan)
|
||||
return 0;
|
||||
if (rate && ap.rate != rate)
|
||||
return 0;
|
||||
if (enc) {
|
||||
if (ap.sig != enc->sig)
|
||||
return 0;
|
||||
DPERROR("sio_sun_tryinfo: setinfo");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
}
|
||||
if (ioctl(hdl->fd, AUDIO_GETINFO, &aui) < 0) {
|
||||
DPERROR("sio_sun_tryinfo: getinfo");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
}
|
||||
if (pchan && aui.play.channels != pchan)
|
||||
return 0;
|
||||
if (rchan && aui.record.channels != rchan)
|
||||
return 0;
|
||||
if (rate) {
|
||||
if ((hdl->sio.mode & SIO_PLAY) &&
|
||||
(aui.play.sample_rate != rate))
|
||||
if (ap.bits != enc->bits)
|
||||
return 0;
|
||||
if ((hdl->sio.mode & SIO_REC) &&
|
||||
(aui.record.sample_rate != rate))
|
||||
if (ap.bps != enc->bps)
|
||||
return 0;
|
||||
if (ap.bps > 1 && ap.le != enc->le)
|
||||
return 0;
|
||||
if (ap.bits < ap.bps * 8 && ap.msb != enc->msb)
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
|
|
@ -209,8 +150,6 @@ sio_sun_tryinfo(struct sio_sun_hdl *hdl, struct sio_enc *enc,
|
|||
static int
|
||||
sio_sun_getcap(struct sio_hdl *sh, struct sio_cap *cap)
|
||||
{
|
||||
#define NCHANS (sizeof(chans) / sizeof(chans[0]))
|
||||
#define NRATES (sizeof(rates) / sizeof(rates[0]))
|
||||
static unsigned int chans[] = {
|
||||
1, 2, 4, 6, 8, 10, 12
|
||||
};
|
||||
|
|
@ -218,56 +157,38 @@ sio_sun_getcap(struct sio_hdl *sh, struct sio_cap *cap)
|
|||
8000, 11025, 12000, 16000, 22050, 24000,
|
||||
32000, 44100, 48000, 64000, 88200, 96000
|
||||
};
|
||||
static unsigned int encs[] = {
|
||||
8, 16, 24, 32
|
||||
};
|
||||
struct sio_sun_hdl *hdl = (struct sio_sun_hdl *)sh;
|
||||
struct sio_par savepar;
|
||||
struct audio_encoding ae;
|
||||
unsigned int nenc = 0, nconf = 0;
|
||||
struct audio_swpar savepar, ap;
|
||||
unsigned int nconf = 0;
|
||||
unsigned int enc_map = 0, rchan_map = 0, pchan_map = 0, rate_map;
|
||||
unsigned int i, j, conf;
|
||||
|
||||
if (!sio_sun_getpar(&hdl->sio, &savepar))
|
||||
if (ioctl(hdl->fd, AUDIO_GETPAR, &savepar)) {
|
||||
DPERROR("AUDIO_GETPAR");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* fill encoding list
|
||||
* get a subset of supported encodings
|
||||
*/
|
||||
for (ae.index = 0; nenc < SIO_NENC; ae.index++) {
|
||||
if (ioctl(hdl->fd, AUDIO_GETENC, &ae) < 0) {
|
||||
if (errno == EINVAL)
|
||||
break;
|
||||
DPERROR("sio_sun_getcap: getenc");
|
||||
hdl->sio.eof = 1;
|
||||
for (i = 0; i < sizeof(encs) / sizeof(encs[0]); i++) {
|
||||
AUDIO_INITPAR(&ap);
|
||||
ap.bits = encs[i];
|
||||
ap.sig = (ap.bits > 8) ? 1 : 0;
|
||||
if (!sio_sun_adjpar(hdl, &ap))
|
||||
return 0;
|
||||
if (ap.bits == encs[i]) {
|
||||
cap->enc[i].sig = ap.sig;
|
||||
cap->enc[i].bits = ap.bits;
|
||||
cap->enc[i].le = ap.le;
|
||||
cap->enc[i].bps = ap.bps;
|
||||
cap->enc[i].msb = ap.msb;
|
||||
enc_map |= 1 << i;
|
||||
}
|
||||
if (ae.flags & AUDIO_ENCODINGFLAG_EMULATED)
|
||||
continue;
|
||||
if (ae.encoding == AUDIO_ENCODING_SLINEAR_LE) {
|
||||
cap->enc[nenc].le = 1;
|
||||
cap->enc[nenc].sig = 1;
|
||||
} else if (ae.encoding == AUDIO_ENCODING_SLINEAR_BE) {
|
||||
cap->enc[nenc].le = 0;
|
||||
cap->enc[nenc].sig = 1;
|
||||
} else if (ae.encoding == AUDIO_ENCODING_ULINEAR_LE) {
|
||||
cap->enc[nenc].le = 1;
|
||||
cap->enc[nenc].sig = 0;
|
||||
} else if (ae.encoding == AUDIO_ENCODING_ULINEAR_BE) {
|
||||
cap->enc[nenc].le = 0;
|
||||
cap->enc[nenc].sig = 0;
|
||||
} else if (ae.encoding == AUDIO_ENCODING_SLINEAR) {
|
||||
cap->enc[nenc].le = SIO_LE_NATIVE;
|
||||
cap->enc[nenc].sig = 1;
|
||||
} else if (ae.encoding == AUDIO_ENCODING_ULINEAR) {
|
||||
cap->enc[nenc].le = SIO_LE_NATIVE;
|
||||
cap->enc[nenc].sig = 0;
|
||||
} else {
|
||||
/* unsipported encoding */
|
||||
continue;
|
||||
}
|
||||
cap->enc[nenc].bits = ae.precision;
|
||||
cap->enc[nenc].bps = ae.bps;
|
||||
cap->enc[nenc].msb = ae.msb;
|
||||
enc_map |= (1 << nenc);
|
||||
nenc++;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -278,17 +199,27 @@ sio_sun_getcap(struct sio_hdl *sh, struct sio_cap *cap)
|
|||
* use the current encoding and try various channels.
|
||||
*/
|
||||
if (hdl->sio.mode & SIO_PLAY) {
|
||||
memcpy(&cap->pchan, chans, NCHANS * sizeof(unsigned int));
|
||||
for (i = 0; i < NCHANS; i++) {
|
||||
if (sio_sun_tryinfo(hdl, NULL, chans[i], 0, 0))
|
||||
for (i = 0; i < sizeof(chans) / sizeof(chans[0]); i++) {
|
||||
AUDIO_INITPAR(&ap);
|
||||
ap.pchan = chans[i];
|
||||
if (!sio_sun_adjpar(hdl, &ap))
|
||||
return 0;
|
||||
if (ap.pchan == chans[i]) {
|
||||
cap->pchan[i] = chans[i];
|
||||
pchan_map |= (1 << i);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (hdl->sio.mode & SIO_REC) {
|
||||
memcpy(&cap->rchan, chans, NCHANS * sizeof(unsigned int));
|
||||
for (i = 0; i < NCHANS; i++) {
|
||||
if (sio_sun_tryinfo(hdl, NULL, 0, chans[i], 0))
|
||||
for (i = 0; i < sizeof(chans) / sizeof(chans[0]); i++) {
|
||||
AUDIO_INITPAR(&ap);
|
||||
ap.pchan = chans[i];
|
||||
if (!sio_sun_adjpar(hdl, &ap))
|
||||
return 0;
|
||||
if (ap.rchan == chans[i]) {
|
||||
cap->rchan[i] = chans[i];
|
||||
rchan_map |= (1 << i);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -299,12 +230,16 @@ sio_sun_getcap(struct sio_hdl *sh, struct sio_cap *cap)
|
|||
* uaudio devices), so certain rates may not be allowed with
|
||||
* certain encodings. We have to check rates for all encodings
|
||||
*/
|
||||
memcpy(&cap->rate, rates, NRATES * sizeof(unsigned int));
|
||||
for (j = 0; j < nenc; j++) {
|
||||
for (j = 0; j < sizeof(encs) / sizeof(encs[0]); j++) {
|
||||
rate_map = 0;
|
||||
for (i = 0; i < NRATES; i++) {
|
||||
if (sio_sun_tryinfo(hdl, &cap->enc[j], 0, 0, rates[i]))
|
||||
if ((enc_map & (1 << j)) == 0)
|
||||
continue;
|
||||
for (i = 0; i < sizeof(rates) / sizeof(rates[0]); i++) {
|
||||
if (sio_sun_testpar(hdl,
|
||||
&cap->enc[j], 0, 0, rates[i])) {
|
||||
cap->rate[i] = rates[i];
|
||||
rate_map |= (1 << i);
|
||||
}
|
||||
}
|
||||
for (conf = 0; conf < nconf; conf++) {
|
||||
if (cap->confs[conf].rate == rate_map) {
|
||||
|
|
@ -323,11 +258,13 @@ sio_sun_getcap(struct sio_hdl *sh, struct sio_cap *cap)
|
|||
}
|
||||
}
|
||||
cap->nconf = nconf;
|
||||
if (!sio_sun_setpar(&hdl->sio, &savepar))
|
||||
|
||||
if (ioctl(hdl->fd, AUDIO_SETPAR, &savepar)) {
|
||||
DPERROR("AUDIO_SETPAR");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
#undef NCHANS
|
||||
#undef NRATES
|
||||
}
|
||||
|
||||
static int
|
||||
|
|
@ -373,9 +310,7 @@ sio_sun_getfd(const char *str, unsigned int mode, int nbio)
|
|||
static struct sio_hdl *
|
||||
sio_sun_fdopen(int fd, unsigned int mode, int nbio)
|
||||
{
|
||||
struct audio_info aui;
|
||||
struct sio_sun_hdl *hdl;
|
||||
struct sio_par par;
|
||||
|
||||
hdl = malloc(sizeof(struct sio_sun_hdl));
|
||||
if (hdl == NULL)
|
||||
|
|
@ -385,36 +320,13 @@ sio_sun_fdopen(int fd, unsigned int mode, int nbio)
|
|||
/*
|
||||
* pause the device
|
||||
*/
|
||||
AUDIO_INITINFO(&aui);
|
||||
if (mode & SIO_PLAY)
|
||||
aui.play.pause = 1;
|
||||
if (mode & SIO_REC)
|
||||
aui.record.pause = 1;
|
||||
if (ioctl(fd, AUDIO_SETINFO, &aui) < 0) {
|
||||
DPERROR("sio_open_sun: setinfo");
|
||||
goto bad_free;
|
||||
if (ioctl(fd, AUDIO_STOP) < 0) {
|
||||
DPERROR("AUDIO_STOP");
|
||||
free(hdl);
|
||||
return NULL;
|
||||
}
|
||||
hdl->fd = fd;
|
||||
|
||||
/*
|
||||
* Default parameters may not be compatible with libsndio (eg. mulaw
|
||||
* encodings, different playback and recording parameters, etc...), so
|
||||
* set parameters to a random value. If the requested parameters are
|
||||
* not supported by the device, then sio_setpar() will pick supported
|
||||
* ones.
|
||||
*/
|
||||
sio_initpar(&par);
|
||||
par.rate = 48000;
|
||||
par.le = SIO_LE_NATIVE;
|
||||
par.sig = 1;
|
||||
par.bits = 16;
|
||||
par.appbufsz = 1200;
|
||||
if (!sio_setpar(&hdl->sio, &par))
|
||||
goto bad_free;
|
||||
return (struct sio_hdl *)hdl;
|
||||
bad_free:
|
||||
free(hdl);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
struct sio_hdl *
|
||||
|
|
@ -448,7 +360,6 @@ static int
|
|||
sio_sun_start(struct sio_hdl *sh)
|
||||
{
|
||||
struct sio_sun_hdl *hdl = (struct sio_sun_hdl *)sh;
|
||||
struct audio_info aui;
|
||||
|
||||
hdl->obpf = hdl->sio.par.pchan * hdl->sio.par.bps;
|
||||
hdl->ibpf = hdl->sio.par.rchan * hdl->sio.par.bps;
|
||||
|
|
@ -464,20 +375,17 @@ sio_sun_start(struct sio_hdl *sh)
|
|||
* keep the device paused and let sio_sun_write() trigger the
|
||||
* start later, to avoid buffer underruns
|
||||
*/
|
||||
hdl->filling = 1;
|
||||
hdl->filltodo = hdl->sio.par.bufsz * hdl->obpf;
|
||||
} else {
|
||||
/*
|
||||
* no play buffers to fill, start now!
|
||||
*/
|
||||
AUDIO_INITINFO(&aui);
|
||||
if (hdl->sio.mode & SIO_REC)
|
||||
aui.record.pause = 0;
|
||||
if (ioctl(hdl->fd, AUDIO_SETINFO, &aui) < 0) {
|
||||
DPERROR("sio_sun_start: setinfo");
|
||||
if (ioctl(hdl->fd, AUDIO_START) < 0) {
|
||||
DPERROR("AUDIO_START");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
}
|
||||
hdl->filling = 0;
|
||||
hdl->filltodo = 0;
|
||||
_sio_onmove_cb(&hdl->sio, 0);
|
||||
}
|
||||
return 1;
|
||||
|
|
@ -487,35 +395,11 @@ static int
|
|||
sio_sun_stop(struct sio_hdl *sh)
|
||||
{
|
||||
struct sio_sun_hdl *hdl = (struct sio_sun_hdl *)sh;
|
||||
struct audio_info aui;
|
||||
int mode;
|
||||
|
||||
if (ioctl(hdl->fd, AUDIO_GETINFO, &aui) < 0) {
|
||||
DPERROR("sio_sun_stop: getinfo");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
}
|
||||
mode = aui.mode;
|
||||
|
||||
/*
|
||||
* there's no way to drain the device without blocking, so just
|
||||
* stop it until the kernel driver get fixed
|
||||
*/
|
||||
AUDIO_INITINFO(&aui);
|
||||
aui.mode = 0;
|
||||
if (hdl->sio.mode & SIO_PLAY)
|
||||
aui.play.pause = 1;
|
||||
if (hdl->sio.mode & SIO_REC)
|
||||
aui.record.pause = 1;
|
||||
if (ioctl(hdl->fd, AUDIO_SETINFO, &aui) < 0) {
|
||||
DPERROR("sio_sun_stop: setinfo1");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
}
|
||||
AUDIO_INITINFO(&aui);
|
||||
aui.mode = mode;
|
||||
if (ioctl(hdl->fd, AUDIO_SETINFO, &aui) < 0) {
|
||||
DPERROR("sio_sun_stop: setinfo2");
|
||||
if (hdl->filltodo > 0)
|
||||
return 1;
|
||||
if (ioctl(hdl->fd, AUDIO_STOP) < 0) {
|
||||
DPERROR("AUDIO_STOP");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -525,210 +409,59 @@ sio_sun_stop(struct sio_hdl *sh)
|
|||
static int
|
||||
sio_sun_setpar(struct sio_hdl *sh, struct sio_par *par)
|
||||
{
|
||||
#define NRETRIES 8
|
||||
struct sio_sun_hdl *hdl = (struct sio_sun_hdl *)sh;
|
||||
struct audio_info aui;
|
||||
unsigned int i, infr, ibpf, onfr, obpf;
|
||||
unsigned int bufsz, round;
|
||||
unsigned int rate, req_rate, prec, enc;
|
||||
struct audio_swpar ap;
|
||||
|
||||
/*
|
||||
* try to set parameters until the device accepts
|
||||
* a common encoding and rate for play and record
|
||||
*/
|
||||
rate = par->rate;
|
||||
prec = par->bits;
|
||||
sio_sun_enctoinfo(hdl, &enc, par);
|
||||
for (i = 0;; i++) {
|
||||
if (i == NRETRIES) {
|
||||
DPRINTF("sio_sun_setpar: couldn't set parameters\n");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
}
|
||||
AUDIO_INITINFO(&aui);
|
||||
if (hdl->sio.mode & SIO_PLAY) {
|
||||
aui.play.sample_rate = rate;
|
||||
aui.play.precision = prec;
|
||||
aui.play.encoding = enc;
|
||||
aui.play.channels = par->pchan;
|
||||
}
|
||||
if (hdl->sio.mode & SIO_REC) {
|
||||
aui.record.sample_rate = rate;
|
||||
aui.record.precision = prec;
|
||||
aui.record.encoding = enc;
|
||||
aui.record.channels = par->rchan;
|
||||
}
|
||||
DPRINTFN(2, "sio_sun_setpar: %i: trying pars = %u/%u/%u\n",
|
||||
i, rate, prec, enc);
|
||||
if (ioctl(hdl->fd, AUDIO_SETINFO, &aui) < 0 &&
|
||||
errno != EINVAL) {
|
||||
DPERROR("sio_sun_setpar: setinfo(pars)");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
}
|
||||
if (ioctl(hdl->fd, AUDIO_GETINFO, &aui) < 0) {
|
||||
DPERROR("sio_sun_setpar: getinfo(pars)");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
}
|
||||
enc = (hdl->sio.mode & SIO_REC) ?
|
||||
aui.record.encoding : aui.play.encoding;
|
||||
switch (enc) {
|
||||
case AUDIO_ENCODING_SLINEAR_LE:
|
||||
case AUDIO_ENCODING_SLINEAR_BE:
|
||||
case AUDIO_ENCODING_ULINEAR_LE:
|
||||
case AUDIO_ENCODING_ULINEAR_BE:
|
||||
case AUDIO_ENCODING_SLINEAR:
|
||||
case AUDIO_ENCODING_ULINEAR:
|
||||
break;
|
||||
default:
|
||||
DPRINTF("sio_sun_setpar: couldn't find encoding\n");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
}
|
||||
if (hdl->sio.mode != (SIO_REC | SIO_PLAY))
|
||||
break;
|
||||
if (aui.play.sample_rate == aui.record.sample_rate &&
|
||||
aui.play.precision == aui.record.precision &&
|
||||
aui.play.encoding == aui.record.encoding)
|
||||
break;
|
||||
if (i < NRETRIES / 2) {
|
||||
rate = aui.play.sample_rate;
|
||||
prec = aui.play.precision;
|
||||
enc = aui.play.encoding;
|
||||
} else {
|
||||
rate = aui.record.sample_rate;
|
||||
prec = aui.record.precision;
|
||||
enc = aui.record.encoding;
|
||||
}
|
||||
AUDIO_INITPAR(&ap);
|
||||
ap.sig = par->sig;
|
||||
ap.le = par->le;
|
||||
ap.bits = par->bits;
|
||||
ap.bps = par->bps;
|
||||
ap.msb = par->msb;
|
||||
ap.rate = par->rate;
|
||||
if (hdl->sio.mode & SIO_PLAY)
|
||||
ap.pchan = par->pchan;
|
||||
if (hdl->sio.mode & SIO_REC)
|
||||
ap.rchan = par->rchan;
|
||||
if (par->round != ~0U && par->appbufsz != ~0U) {
|
||||
ap.round = par->round;
|
||||
ap.nblks = par->appbufsz / par->round;
|
||||
} else if (par->round != ~0U) {
|
||||
ap.round = par->round;
|
||||
ap.nblks = 2;
|
||||
} else if (par->appbufsz != ~0U) {
|
||||
ap.round = par->appbufsz / 2;
|
||||
ap.nblks = 2;
|
||||
}
|
||||
|
||||
/*
|
||||
* If the rate that the hardware is using is different than
|
||||
* the requested rate, scale buffer sizes so they will be the
|
||||
* same time duration as what was requested. This just gets
|
||||
* the rates to use for scaling, that actual scaling is done
|
||||
* later.
|
||||
*/
|
||||
rate = (hdl->sio.mode & SIO_REC) ? aui.record.sample_rate :
|
||||
aui.play.sample_rate;
|
||||
req_rate = rate;
|
||||
if (par->rate && par->rate != ~0U)
|
||||
req_rate = par->rate;
|
||||
|
||||
/*
|
||||
* if block size and buffer size are not both set then
|
||||
* set the blocksize to half the buffer size
|
||||
*/
|
||||
bufsz = par->appbufsz;
|
||||
round = par->round;
|
||||
if (bufsz != ~0U) {
|
||||
bufsz = bufsz * rate / req_rate;
|
||||
if (round == ~0U)
|
||||
round = (bufsz + 1) / 2;
|
||||
else
|
||||
round = round * rate / req_rate;
|
||||
} else if (round != ~0U) {
|
||||
round = round * rate / req_rate;
|
||||
bufsz = round * 2;
|
||||
} else
|
||||
return 1;
|
||||
|
||||
/*
|
||||
* get the play/record frame size in bytes
|
||||
*/
|
||||
if (ioctl(hdl->fd, AUDIO_GETINFO, &aui) < 0) {
|
||||
DPERROR("sio_sun_setpar: GETINFO");
|
||||
if (ioctl(hdl->fd, AUDIO_SETPAR, &ap) < 0) {
|
||||
DPERROR("AUDIO_SETPAR");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
}
|
||||
ibpf = (hdl->sio.mode & SIO_REC) ?
|
||||
aui.record.channels * aui.record.bps : 1;
|
||||
obpf = (hdl->sio.mode & SIO_PLAY) ?
|
||||
aui.play.channels * aui.play.bps : 1;
|
||||
|
||||
DPRINTFN(2, "sio_sun_setpar: bpf = (%u, %u)\n", ibpf, obpf);
|
||||
|
||||
/*
|
||||
* try to set parameters until the device accepts
|
||||
* a common block size for play and record
|
||||
*/
|
||||
for (i = 0; i < NRETRIES; i++) {
|
||||
AUDIO_INITINFO(&aui);
|
||||
aui.hiwat = (bufsz + round - 1) / round;
|
||||
aui.lowat = aui.hiwat;
|
||||
if (hdl->sio.mode & SIO_REC)
|
||||
aui.record.block_size = round * ibpf;
|
||||
if (hdl->sio.mode & SIO_PLAY)
|
||||
aui.play.block_size = round * obpf;
|
||||
if (ioctl(hdl->fd, AUDIO_SETINFO, &aui) < 0) {
|
||||
DPERROR("sio_sun_setpar2: SETINFO");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
}
|
||||
if (ioctl(hdl->fd, AUDIO_GETINFO, &aui) < 0) {
|
||||
DPERROR("sio_sun_setpar2: GETINFO");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
}
|
||||
infr = aui.record.block_size / ibpf;
|
||||
onfr = aui.play.block_size / obpf;
|
||||
DPRINTFN(2, "sio_sun_setpar: %i: round = %u -> (%u, %u)\n",
|
||||
i, round, infr, onfr);
|
||||
|
||||
/*
|
||||
* if half-duplex or both block sizes match, we're done
|
||||
*/
|
||||
if (hdl->sio.mode != (SIO_REC | SIO_PLAY) || infr == onfr) {
|
||||
DPRINTFN(2, "sio_sun_setpar: blocksize ok\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* half of the retries, retry with the smaller value,
|
||||
* then with the larger returned value
|
||||
*/
|
||||
if (i < NRETRIES / 2)
|
||||
round = infr < onfr ? infr : onfr;
|
||||
else
|
||||
round = infr < onfr ? onfr : infr;
|
||||
}
|
||||
DPRINTFN(2, "sio_sun_setpar: couldn't find a working blocksize\n");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
#undef NRETRIES
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int
|
||||
sio_sun_getpar(struct sio_hdl *sh, struct sio_par *par)
|
||||
{
|
||||
struct sio_sun_hdl *hdl = (struct sio_sun_hdl *)sh;
|
||||
struct audio_info aui;
|
||||
struct audio_swpar ap;
|
||||
|
||||
if (ioctl(hdl->fd, AUDIO_GETINFO, &aui) < 0) {
|
||||
DPERROR("sio_sun_getpar: getinfo");
|
||||
if (ioctl(hdl->fd, AUDIO_GETPAR, &ap) < 0) {
|
||||
DPERROR("AUDIO_GETPAR");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
}
|
||||
if (hdl->sio.mode & SIO_PLAY) {
|
||||
par->rate = aui.play.sample_rate;
|
||||
if (!sio_sun_infotoenc(hdl, &aui.play, par))
|
||||
return 0;
|
||||
} else if (hdl->sio.mode & SIO_REC) {
|
||||
par->rate = aui.record.sample_rate;
|
||||
if (!sio_sun_infotoenc(hdl, &aui.record, par))
|
||||
return 0;
|
||||
} else
|
||||
return 0;
|
||||
par->pchan = (hdl->sio.mode & SIO_PLAY) ?
|
||||
aui.play.channels : 0;
|
||||
par->rchan = (hdl->sio.mode & SIO_REC) ?
|
||||
aui.record.channels : 0;
|
||||
par->round = (hdl->sio.mode & SIO_REC) ?
|
||||
aui.record.block_size / (par->bps * par->rchan) :
|
||||
aui.play.block_size / (par->bps * par->pchan);
|
||||
par->appbufsz = aui.hiwat * par->round;
|
||||
par->bufsz = par->appbufsz;
|
||||
par->sig = ap.sig;
|
||||
par->le = ap.le;
|
||||
par->bits = ap.bits;
|
||||
par->bps = ap.bps;
|
||||
par->msb = ap.msb;
|
||||
par->rate = ap.rate;
|
||||
par->pchan = ap.pchan;
|
||||
par->rchan = ap.rchan;
|
||||
par->round = ap.round;
|
||||
par->appbufsz = par->bufsz = ap.nblks * ap.round;
|
||||
par->xrun = SIO_IGNORE;
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -756,38 +489,6 @@ sio_sun_read(struct sio_hdl *sh, void *buf, size_t len)
|
|||
return n;
|
||||
}
|
||||
|
||||
static size_t
|
||||
sio_sun_autostart(struct sio_sun_hdl *hdl)
|
||||
{
|
||||
struct audio_info aui;
|
||||
struct pollfd pfd;
|
||||
|
||||
pfd.fd = hdl->fd;
|
||||
pfd.events = POLLOUT;
|
||||
while (poll(&pfd, 1, 0) < 0) {
|
||||
if (errno == EINTR)
|
||||
continue;
|
||||
DPERROR("sio_sun_autostart: poll");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
}
|
||||
if (!(pfd.revents & POLLOUT)) {
|
||||
hdl->filling = 0;
|
||||
AUDIO_INITINFO(&aui);
|
||||
if (hdl->sio.mode & SIO_PLAY)
|
||||
aui.play.pause = 0;
|
||||
if (hdl->sio.mode & SIO_REC)
|
||||
aui.record.pause = 0;
|
||||
if (ioctl(hdl->fd, AUDIO_SETINFO, &aui) < 0) {
|
||||
DPERROR("sio_sun_autostart: setinfo");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
}
|
||||
_sio_onmove_cb(&hdl->sio, 0);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static size_t
|
||||
sio_sun_write(struct sio_hdl *sh, const void *buf, size_t len)
|
||||
{
|
||||
|
|
@ -805,10 +506,6 @@ sio_sun_write(struct sio_hdl *sh, const void *buf, size_t len)
|
|||
}
|
||||
return 0;
|
||||
}
|
||||
if (hdl->filling) {
|
||||
if (!sio_sun_autostart(hdl))
|
||||
return 0;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
|
|
@ -825,6 +522,15 @@ sio_sun_pollfd(struct sio_hdl *sh, struct pollfd *pfd, int events)
|
|||
|
||||
pfd->fd = hdl->fd;
|
||||
pfd->events = events;
|
||||
if (hdl->filltodo > 0 && hdl->sio.wused == hdl->filltodo) {
|
||||
hdl->filltodo = 0;
|
||||
if (ioctl(hdl->fd, AUDIO_START) < 0) {
|
||||
DPERROR("AUDIO_START");
|
||||
hdl->sio.eof = 1;
|
||||
return 0;
|
||||
}
|
||||
_sio_onmove_cb(&hdl->sio, 0);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
|
@ -836,7 +542,8 @@ sio_sun_revents(struct sio_hdl *sh, struct pollfd *pfd)
|
|||
int dierr = 0, doerr = 0, offset, delta;
|
||||
int revents = pfd->revents;
|
||||
|
||||
if (!hdl->sio.started)
|
||||
if ((pfd->revents & POLLHUP) ||
|
||||
(pfd->revents & (POLLIN | POLLOUT)) == 0)
|
||||
return pfd->revents;
|
||||
if (ioctl(hdl->fd, AUDIO_GETPOS, &ap) < 0) {
|
||||
DPERROR("sio_sun_revents: GETPOS");
|
||||
|
|
@ -894,9 +601,6 @@ sio_sun_revents(struct sio_hdl *sh, struct pollfd *pfd)
|
|||
hdl->idelta -= delta;
|
||||
hdl->odelta -= delta;
|
||||
}
|
||||
|
||||
if (hdl->filling)
|
||||
revents |= POLLOUT; /* XXX: is this necessary ? */
|
||||
return revents;
|
||||
}
|
||||
#endif /* defined USE_SUN */
|
||||
|
|
|
|||
Loading…
Reference in New Issue