/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright (C) 4Front Technologies 1996-2008.
*
* Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
*/
/*
* Purpose: Virtual mixing audio input routines
*
* This file contains the actual mixing and resampling engine for input.
*/
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sysmacros.h>
#include <sys/sdt.h>
#include "audio_impl.h"
#define DECL_AUDIO_IMPORT(NAME, TYPE, SWAP, SHIFT) \
void \
auimpl_import_##NAME(audio_engine_t *e, uint_t nfr, audio_stream_t *sp) \
{ \
int nch = e->e_nchan; \
int32_t *out = (void *)sp->s_cnv_src; \
TYPE *in = (void *)e->e_data; \
int ch = 0; \
int vol = sp->s_gain_eff; \
\
do { /* for each channel */ \
TYPE *ip; \
int32_t *op; \
int i; \
int incr = e->e_chincr[ch]; \
uint_t tidx = e->e_tidx; \
\
/* get value and adjust next channel offset */ \
op = out++; \
ip = in + e->e_choffs[ch] + (tidx * incr); \
\
i = nfr; \
\
do { /* for each frame */ \
int32_t sample = (TYPE)SWAP(*ip); \
int32_t scaled = sample SHIFT; \
\
scaled *= vol; \
scaled /= AUDIO_VOL_SCALE; \
\
*op = scaled; \
op += nch; \
\
ip += incr; \
if (++tidx == e->e_nframes) { \
tidx = 0; \
ip = in + e->e_choffs[ch]; \
} \
} while (--i); \
ch++; \
} while (ch < nch); \
}
DECL_AUDIO_IMPORT(16ne, int16_t, /* nop */, << 8)
DECL_AUDIO_IMPORT(16oe, int16_t, ddi_swap16, << 8)
DECL_AUDIO_IMPORT(32ne, int32_t, /* nop */, >> 8)
DECL_AUDIO_IMPORT(32oe, int32_t, ddi_swap32, >> 8)
DECL_AUDIO_IMPORT(24ne, int32_t, /* nop */, /* nop */)
DECL_AUDIO_IMPORT(24oe, int32_t, ddi_swap32, /* nop */)
/*
* Produce capture data. This takes data from the conversion buffer
* and copies it into the stream data buffer.
*/
static void
auimpl_produce_data(audio_stream_t *sp, uint_t count)
{
uint_t nframes;
uint_t framesz;
caddr_t cnvsrc;
caddr_t data;
nframes = sp->s_nframes;
framesz = sp->s_framesz;
ASSERT(sp->s_head >= sp->s_tail);
ASSERT(sp->s_hidx < nframes);
ASSERT(sp->s_tidx < nframes);
/*
* Copy data. We deal properly with wraps. Done as a
* do...while to minimize the number of tests.
*/
cnvsrc = sp->s_cnv_src;
data = sp->s_data + (sp->s_hidx * framesz);
do {
unsigned nf;
unsigned nb;
nf = min(nframes - sp->s_hidx, count);
nb = nf * framesz;
bcopy(cnvsrc, data, nb);
data += nb;
cnvsrc += nb;
sp->s_hidx += nf;
sp->s_head += nf;
count -= nf;
sp->s_samples += nf;
if (sp->s_hidx == nframes) {
sp->s_hidx = 0;
data = sp->s_data;
}
} while (count);
ASSERT(sp->s_tail <= sp->s_head);
ASSERT(sp->s_hidx < nframes);
}
void
auimpl_input_callback(void *arg)
{
audio_engine_t *e = arg;
uint_t fragfr = e->e_fragfr;
audio_stream_t *sp;
audio_client_t *c;
audio_client_t *clist = NULL;
list_t *l = &e->e_streams;
uint64_t h;
mutex_enter(&e->e_lock);
if (e->e_suspended || e->e_failed || !e->e_periodic) {
mutex_exit(&e->e_lock);
return;
}
if (e->e_need_start) {
int rv;
if ((rv = ENG_START(e)) != 0) {
e->e_failed = B_TRUE;
mutex_exit(&e->e_lock);
audio_dev_warn(e->e_dev,
"failed starting input, rv = %d", rv);
return;
}
e->e_need_start = B_FALSE;
}
h = ENG_COUNT(e);
ASSERT(h >= e->e_head);
if (h < e->e_head) {
/*
* This is a sign of a serious bug. We should
* probably offline the device via FMA, if we ever
* support FMA for audio devices.
*/
e->e_failed = B_TRUE;
ENG_STOP(e);
mutex_exit(&e->e_lock);
audio_dev_warn(e->e_dev,
"device malfunction: broken capture sample counter");
return;
}
e->e_head = h;
ASSERT(e->e_head >= e->e_tail);
if ((e->e_head - e->e_tail) > e->e_nframes) {
/* no room for data, not much we can do */
e->e_errors++;
e->e_overruns++;
}
/* consume all fragments in the buffer */
while ((e->e_head - e->e_tail) > fragfr) {
/*
* Consider doing the SYNC outside of the lock.
*/
ENG_SYNC(e, fragfr);
for (sp = list_head(l); sp != NULL; sp = list_next(l, sp)) {
int space;
int count;
mutex_enter(&sp->s_lock);
/* skip over streams paused or not running */
if (sp->s_paused || !sp->s_running) {
mutex_exit(&sp->s_lock);
continue;
}
sp->s_cnv_src = sp->s_cnv_buf0;
sp->s_cnv_dst = sp->s_cnv_buf1;
e->e_import(e, fragfr, sp);
/*
* Optionally convert fragment to requested sample
* format and rate.
*/
if (sp->s_converter != NULL) {
count = sp->s_converter(sp, fragfr);
} else {
count = fragfr;
}
ASSERT(sp->s_head >= sp->s_tail);
space = sp->s_nframes - (sp->s_head - sp->s_tail);
if (count > space) {
e->e_stream_overruns++;
e->e_errors++;
sp->s_errors += count - space;
count = space;
}
auimpl_produce_data(sp, count);
/* wake blocked threads (blocking reads, etc.) */
cv_broadcast(&sp->s_cv);
mutex_exit(&sp->s_lock);
/*
* Add client to notification list. We'll
* process it after dropping the lock.
*/
c = sp->s_client;
if ((c->c_input != NULL) &&
(c->c_next_input == NULL)) {
auclnt_hold(c);
c->c_next_input = clist;
clist = c;
}
}
/*
* Update the tail pointer, and the data pointer.
*/
e->e_tail += fragfr;
e->e_tidx += fragfr;
if (e->e_tidx >= e->e_nframes) {
e->e_tidx -= e->e_nframes;
}
}
mutex_exit(&e->e_lock);
/*
* Notify client personalities.
*/
while ((c = clist) != NULL) {
clist = c->c_next_input;
c->c_next_input = NULL;
c->c_input(c);
auclnt_release(c);
}
}