/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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) 1992-2001 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <stdlib.h>
#include <memory.h>
#include <math.h>

#include <AudioTypeMux.h>

// This is a conversion class for channel multiplex/demultiplex

// class AudioTypeMux methods

// Constructor
AudioTypeMux::
AudioTypeMux()
{
}

// Destructor
AudioTypeMux::
~AudioTypeMux()
{
}

// Test conversion possibilities.
// Return TRUE if conversion to/from the specified type is possible.
Boolean AudioTypeMux::
CanConvert(
	AudioHdr	/* h */) const		// target header
{
	// XXX - The test is whether we're converting 1->many or many->1
	//	This routine needs a to/from argument.
	// XXX - What if the format doesn't have fixed-size sample units?
	return (TRUE);
}

// Multiplex or demultiplex.
// The buffer pointer should be a NULL-terminated array of buffers if 1-channel
AudioError AudioTypeMux::
Convert(
	AudioBuffer*&	inbuf,			// data buffer to process
	AudioHdr	outhdr)			// target header
{
	AudioBuffer*	outbuf;
	AudioBuffer**	multibuf;
	AudioHdr	inhdr;
	Double		length;
	unsigned int	channels;
	size_t		nsamps;
	size_t		nbytes;
	size_t		unitsz;
	unsigned char	**inptrs;
	unsigned char	*in;
	unsigned char	*out;
	int		i;
	int		j;
	int		k;
	AudioError	err;

	channels = outhdr.channels;
	if (channels == 1) {
		inhdr = inbuf->GetHeader();	// Demux multi-channel data
		length = inbuf->GetLength();
	} else {
		multibuf = (AudioBuffer**) inbuf;	// Mux multiple buffers
		inhdr = multibuf[0]->GetHeader();
		length = multibuf[0]->GetLength();
	}

	// Make sure we're not being asked to do the impossible or trivial
	if ((err = inhdr.Validate()))
		return (err);
	if ((inhdr.sample_rate != outhdr.sample_rate) ||
	    (inhdr.encoding != outhdr.encoding) ||
	    (inhdr.samples_per_unit != outhdr.samples_per_unit) ||
	    (inhdr.bytes_per_unit != outhdr.bytes_per_unit))
		return (AUDIO_ERR_HDRINVAL);
	if (inhdr.channels == outhdr.channels)
		return (AUDIO_SUCCESS);
	if ((inhdr.channels != 1) && (outhdr.channels != 1))
		return (AUDIO_ERR_HDRINVAL);
	if (Undefined(length))
		return (AUDIO_ERR_BADARG);

	// Get the number of sample frames and the size of each
	nsamps = (size_t)inhdr.Time_to_Samples(length);
	nbytes = (size_t)inhdr.FrameLength();
	unitsz = (size_t)inhdr.bytes_per_unit;

	// Figure out if we're multiplexing or demultiplexing
	if (channels == 1) {
		// Demultiplex multi-channel data into several mono channels

		// Allocate buffer pointer array and each buffer
		channels = inhdr.channels;
		multibuf = (AudioBuffer**)
		    calloc((channels + 1), sizeof (AudioBuffer*));
		for (i = 0; i < channels; i++) {
			multibuf[i] = new AudioBuffer(length,
			    "(Demultiplex conversion buffer)");
			if (multibuf[i] == 0) {
				err = AUDIO_UNIXERROR;
				goto cleanup;
			}
			if (err = multibuf[i]->SetHeader(outhdr)) {
				delete multibuf[i];
cleanup:			while (--i >= 0) {
					delete multibuf[i];
				}
				delete multibuf;
				return (err);
			}
		}
		multibuf[i] = NULL;

		for (i = 0; i < channels; i++) {
			// Get output pointer and input channel pointer
			out = (unsigned char *)multibuf[i]->GetAddress();
			in = (unsigned char *)inbuf->GetAddress();
			in += (i * unitsz);

			// Copy a sample unit and bump the input pointer
			for (j = 0; j < nsamps; j++) {
				for (k = 0; k < unitsz; k++) {
					*out++ = *in++;
				}
				in += ((channels - 1) * unitsz);
			}

			// Set the valid data length
			multibuf[i]->SetLength(length);
		}
		// Release the input buffer
		inbuf->Reference();
		inbuf->Dereference();

		// Return the array pointer (callers beware!)
		inbuf = (AudioBuffer*) multibuf;

	} else {
		// Multiplex several mono channels into multi-channel data

		// Allocate an output buffer
		outbuf = new AudioBuffer(length,
		    "(Multiplex conversion buffer)");
		if (outbuf == 0)
			return (AUDIO_UNIXERROR);
		if (err = outbuf->SetHeader(outhdr)) {
			delete outbuf;
			return (err);
		}

		// Verify the input pointer is an array of buffer pointers
		multibuf = (AudioBuffer**) inbuf;
		for (channels = 0; ; channels++) {
			// Look for NULL termination
			if (multibuf[channels] == NULL)
				break;
			if (!multibuf[channels]->isBuffer())
				return (AUDIO_ERR_BADARG);
		}
		if (channels != outhdr.channels)
			return (AUDIO_ERR_BADARG);

		// Allocate a bunch of input pointers
		inptrs = (unsigned char **)
		    calloc(channels, sizeof (unsigned char *));
		for (i = 0; i < channels; i++) {
			inptrs[i] = (unsigned char *) multibuf[i]->GetAddress();
		}

		// Get output pointer
		out = (unsigned char *)outbuf->GetAddress();

		for (i = 0; i < nsamps; i++) {
			// Copy a sample frame from each input buffer
			for (j = 0; j < channels; j++) {
				in = inptrs[j];
				for (k = 0; k < nbytes; k++) {
					*out++ = *in++;
				}
				inptrs[j] = in;
			}
		}
		// Set the valid data length
		outbuf->SetLength(length);

		// Release the input buffers and pointer arrays
		for (i = 0; i < channels; i++) {
			multibuf[i]->Reference();
			multibuf[i]->Dereference();
			multibuf[i] = NULL;
		}
		delete multibuf;
		delete inptrs;

		// Set the valid data length and return the new pointer
		outbuf->SetLength(length);
		inbuf = outbuf;
	}
	return (AUDIO_SUCCESS);
}

AudioError AudioTypeMux::
Flush(
	AudioBuffer*&	/* buf */)
{
	return (AUDIO_SUCCESS);
}