xref: /onnv-gate/usr/src/uts/common/io/audio/impl/audio_input.c (revision 12165:e481916a5729)

/*
 * 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);
	}
}