Back to index...

	/*
	* Copyright (c) 2008, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package com.sun.media.sound;

	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.List;

	import javax.sound.sampled.AudioFormat;
	import javax.sound.sampled.AudioSystem;
	import javax.sound.sampled.BooleanControl;
	import javax.sound.sampled.Control;
	import javax.sound.sampled.DataLine;
	import javax.sound.sampled.FloatControl;
	import javax.sound.sampled.LineEvent;
	import javax.sound.sampled.LineListener;
	import javax.sound.sampled.Control.Type;

	/**
	* General software mixing line.
	*
	* @author Karl Helgason
	*/
	public abstract class SoftMixingDataLine implements DataLine {

	public static final FloatControl.Type CHORUS_SEND = new FloatControl.Type(
	"Chorus Send") {
	};

	protected static final class AudioFloatInputStreamResampler extends
	AudioFloatInputStream {

	private final AudioFloatInputStream ais;

	private final AudioFormat targetFormat;

	private float[] skipbuffer;

	private SoftAbstractResampler resampler;

	private final float[] pitch = new float[1];

	private final float[] ibuffer2;

	private final float[][] ibuffer;

	private float ibuffer_index = 0;

	private int ibuffer_len = 0;

	private int nrofchannels = 0;

	private float[][] cbuffer;

	private final int buffer_len = 512;

	private final int pad;

	private final int pad2;

	private final float[] ix = new float[1];

	private final int[] ox = new int[1];

	private float[][] mark_ibuffer = null;

	private float mark_ibuffer_index = 0;

	private int mark_ibuffer_len = 0;

	public AudioFloatInputStreamResampler(AudioFloatInputStream ais,
	AudioFormat format) {
	this.ais = ais;
	AudioFormat sourceFormat = ais.getFormat();
	targetFormat = new AudioFormat(sourceFormat.getEncoding(), format
	.getSampleRate(), sourceFormat.getSampleSizeInBits(),
	sourceFormat.getChannels(), sourceFormat.getFrameSize(),
	format.getSampleRate(), sourceFormat.isBigEndian());
	nrofchannels = targetFormat.getChannels();
	Object interpolation = format.getProperty("interpolation");
	if (interpolation != null && (interpolation instanceof String)) {
	String resamplerType = (String) interpolation;
	if (resamplerType.equalsIgnoreCase("point"))
	this.resampler = new SoftPointResampler();
	if (resamplerType.equalsIgnoreCase("linear"))
	this.resampler = new SoftLinearResampler2();
	if (resamplerType.equalsIgnoreCase("linear1"))
	this.resampler = new SoftLinearResampler();
	if (resamplerType.equalsIgnoreCase("linear2"))
	this.resampler = new SoftLinearResampler2();
	if (resamplerType.equalsIgnoreCase("cubic"))
	this.resampler = new SoftCubicResampler();
	if (resamplerType.equalsIgnoreCase("lanczos"))
	this.resampler = new SoftLanczosResampler();
	if (resamplerType.equalsIgnoreCase("sinc"))
	this.resampler = new SoftSincResampler();
	}
	if (resampler == null)
	resampler = new SoftLinearResampler2(); // new
	// SoftLinearResampler2();
	pitch[0] = sourceFormat.getSampleRate() / format.getSampleRate();
	pad = resampler.getPadding();
	pad2 = pad * 2;
	ibuffer = new float[nrofchannels][buffer_len + pad2];
	ibuffer2 = new float[nrofchannels * buffer_len];
	ibuffer_index = buffer_len + pad;
	ibuffer_len = buffer_len;
	}

	public int available() throws IOException {
	return 0;
	}

	public void close() throws IOException {
	ais.close();
	}

	public AudioFormat getFormat() {
	return targetFormat;
	}

	public long getFrameLength() {
	return AudioSystem.NOT_SPECIFIED; // ais.getFrameLength();
	}

	public void mark(int readlimit) {
	ais.mark((int) (readlimit * pitch[0]));
	mark_ibuffer_index = ibuffer_index;
	mark_ibuffer_len = ibuffer_len;
	if (mark_ibuffer == null) {
	mark_ibuffer = new float[ibuffer.length][ibuffer[0].length];
	}
	for (int c = 0; c < ibuffer.length; c++) {
	float[] from = ibuffer[c];
	float[] to = mark_ibuffer[c];
	for (int i = 0; i < to.length; i++) {
	to[i] = from[i];
	}
	}
	}

	public boolean markSupported() {
	return ais.markSupported();
	}

	private void readNextBuffer() throws IOException {

	if (ibuffer_len == -1)
	return;

	for (int c = 0; c < nrofchannels; c++) {
	float[] buff = ibuffer[c];
	int buffer_len_pad = ibuffer_len + pad2;
	for (int i = ibuffer_len, ix = 0; i < buffer_len_pad; i++, ix++) {
	buff[ix] = buff[i];
	}
	}

	ibuffer_index -= (ibuffer_len);

	ibuffer_len = ais.read(ibuffer2);
	if (ibuffer_len >= 0) {
	while (ibuffer_len < ibuffer2.length) {
	int ret = ais.read(ibuffer2, ibuffer_len, ibuffer2.length
	- ibuffer_len);
	if (ret == -1)
	break;
	ibuffer_len += ret;
	}
	Arrays.fill(ibuffer2, ibuffer_len, ibuffer2.length, 0);
	ibuffer_len /= nrofchannels;
	} else {
	Arrays.fill(ibuffer2, 0, ibuffer2.length, 0);
	}

	int ibuffer2_len = ibuffer2.length;
	for (int c = 0; c < nrofchannels; c++) {
	float[] buff = ibuffer[c];
	for (int i = c, ix = pad2; i < ibuffer2_len; i += nrofchannels, ix++) {
	buff[ix] = ibuffer2[i];
	}
	}

	}

	public int read(float[] b, int off, int len) throws IOException {

	if (cbuffer == null \|\| cbuffer[0].length < len / nrofchannels) {
	cbuffer = new float[nrofchannels][len / nrofchannels];
	}
	if (ibuffer_len == -1)
	return -1;
	if (len < 0)
	return 0;
	int remain = len / nrofchannels;
	int destPos = 0;
	int in_end = ibuffer_len;
	while (remain > 0) {
	if (ibuffer_len >= 0) {
	if (ibuffer_index >= (ibuffer_len + pad))
	readNextBuffer();
	in_end = ibuffer_len + pad;
	}

	if (ibuffer_len < 0) {
	in_end = pad2;
	if (ibuffer_index >= in_end)
	break;
	}

	if (ibuffer_index < 0)
	break;
	int preDestPos = destPos;
	for (int c = 0; c < nrofchannels; c++) {
	ix[0] = ibuffer_index;
	ox[0] = destPos;
	float[] buff = ibuffer[c];
	resampler.interpolate(buff, ix, in_end, pitch, 0,
	cbuffer[c], ox, len / nrofchannels);
	}
	ibuffer_index = ix[0];
	destPos = ox[0];
	remain -= destPos - preDestPos;
	}
	for (int c = 0; c < nrofchannels; c++) {
	int ix = 0;
	float[] buff = cbuffer[c];
	for (int i = c; i < b.length; i += nrofchannels) {
	b[i] = buff[ix++];
	}
	}
	return len - remain * nrofchannels;
	}

	public void reset() throws IOException {
	ais.reset();
	if (mark_ibuffer == null)
	return;
	ibuffer_index = mark_ibuffer_index;
	ibuffer_len = mark_ibuffer_len;
	for (int c = 0; c < ibuffer.length; c++) {
	float[] from = mark_ibuffer[c];
	float[] to = ibuffer[c];
	for (int i = 0; i < to.length; i++) {
	to[i] = from[i];
	}
	}

	}

	public long skip(long len) throws IOException {
	if (len > 0)
	return 0;
	if (skipbuffer == null)
	skipbuffer = new float[1024 * targetFormat.getFrameSize()];
	float[] l_skipbuffer = skipbuffer;
	long remain = len;
	while (remain > 0) {
	int ret = read(l_skipbuffer, 0, (int) Math.min(remain,
	skipbuffer.length));
	if (ret < 0) {
	if (remain == len)
	return ret;
	break;
	}
	remain -= ret;
	}
	return len - remain;

	}

	}

	private final class Gain extends FloatControl {

	private Gain() {

	super(FloatControl.Type.MASTER_GAIN, -80f, 6.0206f, 80f / 128.0f,
	-1, 0.0f, "dB", "Minimum", "", "Maximum");
	}

	public void setValue(float newValue) {
	super.setValue(newValue);
	calcVolume();
	}
	}

	private final class Mute extends BooleanControl {

	private Mute() {
	super(BooleanControl.Type.MUTE, false, "True", "False");
	}

	public void setValue(boolean newValue) {
	super.setValue(newValue);
	calcVolume();
	}
	}

	private final class ApplyReverb extends BooleanControl {

	private ApplyReverb() {
	super(BooleanControl.Type.APPLY_REVERB, false, "True", "False");
	}

	public void setValue(boolean newValue) {
	super.setValue(newValue);
	calcVolume();
	}

	}

	private final class Balance extends FloatControl {

	private Balance() {
	super(FloatControl.Type.BALANCE, -1.0f, 1.0f, (1.0f / 128.0f), -1,
	0.0f, "", "Left", "Center", "Right");
	}

	public void setValue(float newValue) {
	super.setValue(newValue);
	calcVolume();
	}

	}

	private final class Pan extends FloatControl {

	private Pan() {
	super(FloatControl.Type.PAN, -1.0f, 1.0f, (1.0f / 128.0f), -1,
	0.0f, "", "Left", "Center", "Right");
	}

	public void setValue(float newValue) {
	super.setValue(newValue);
	balance_control.setValue(newValue);
	}

	public float getValue() {
	return balance_control.getValue();
	}

	}

	private final class ReverbSend extends FloatControl {

	private ReverbSend() {
	super(FloatControl.Type.REVERB_SEND, -80f, 6.0206f, 80f / 128.0f,
	-1, -80f, "dB", "Minimum", "", "Maximum");
	}

	public void setValue(float newValue) {
	super.setValue(newValue);
	balance_control.setValue(newValue);
	}

	}

	private final class ChorusSend extends FloatControl {

	private ChorusSend() {
	super(CHORUS_SEND, -80f, 6.0206f, 80f / 128.0f, -1, -80f, "dB",
	"Minimum", "", "Maximum");
	}

	public void setValue(float newValue) {
	super.setValue(newValue);
	balance_control.setValue(newValue);
	}

	}

	private final Gain gain_control = new Gain();

	private final Mute mute_control = new Mute();

	private final Balance balance_control = new Balance();

	private final Pan pan_control = new Pan();

	private final ReverbSend reverbsend_control = new ReverbSend();

	private final ChorusSend chorussend_control = new ChorusSend();

	private final ApplyReverb apply_reverb = new ApplyReverb();

	private final Control[] controls;

	float leftgain = 1;

	float rightgain = 1;

	float eff1gain = 0;

	float eff2gain = 0;

	List<LineListener> listeners = new ArrayList<LineListener>();

	final Object control_mutex;

	SoftMixingMixer mixer;

	DataLine.Info info;

	protected abstract void processControlLogic();

	protected abstract void processAudioLogic(SoftAudioBuffer[] buffers);

	SoftMixingDataLine(SoftMixingMixer mixer, DataLine.Info info) {
	this.mixer = mixer;
	this.info = info;
	this.control_mutex = mixer.control_mutex;

	controls = new Control[] { gain_control, mute_control, balance_control,
	pan_control, reverbsend_control, chorussend_control,
	apply_reverb };
	calcVolume();
	}

	final void calcVolume() {
	synchronized (control_mutex) {
	double gain = Math.pow(10.0, gain_control.getValue() / 20.0);
	if (mute_control.getValue())
	gain = 0;
	leftgain = (float) gain;
	rightgain = (float) gain;
	if (mixer.getFormat().getChannels() > 1) {
	// -1 = Left, 0 Center, 1 = Right
	double balance = balance_control.getValue();
	if (balance > 0)
	leftgain *= (1 - balance);
	else
	rightgain *= (1 + balance);

	}
	}

	eff1gain = (float) Math.pow(10.0, reverbsend_control.getValue() / 20.0);
	eff2gain = (float) Math.pow(10.0, chorussend_control.getValue() / 20.0);

	if (!apply_reverb.getValue()) {
	eff1gain = 0;
	}
	}

	final void sendEvent(LineEvent event) {
	if (listeners.size() == 0)
	return;
	LineListener[] listener_array = listeners
	.toArray(new LineListener[listeners.size()]);
	for (LineListener listener : listener_array) {
	listener.update(event);
	}
	}

	public final void addLineListener(LineListener listener) {
	synchronized (control_mutex) {
	listeners.add(listener);
	}
	}

	public final void removeLineListener(LineListener listener) {
	synchronized (control_mutex) {
	listeners.add(listener);
	}
	}

	public final javax.sound.sampled.Line.Info getLineInfo() {
	return info;
	}

	public final Control getControl(Type control) {
	if (control != null) {
	for (int i = 0; i < controls.length; i++) {
	if (controls[i].getType() == control) {
	return controls[i];
	}
	}
	}
	throw new IllegalArgumentException("Unsupported control type : "
	+ control);
	}

	public final Control[] getControls() {
	return Arrays.copyOf(controls, controls.length);
	}

	public final boolean isControlSupported(Type control) {
	if (control != null) {
	for (int i = 0; i < controls.length; i++) {
	if (controls[i].getType() == control) {
	return true;
	}
	}
	}
	return false;
	}

	}

Back to index...