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.List;

	import javax.sound.sampled.AudioFormat;
	import javax.sound.sampled.AudioInputStream;
	import javax.sound.sampled.AudioSystem;
	import javax.sound.sampled.Clip;
	import javax.sound.sampled.Control;
	import javax.sound.sampled.DataLine;
	import javax.sound.sampled.Line;
	import javax.sound.sampled.LineEvent;
	import javax.sound.sampled.LineListener;
	import javax.sound.sampled.LineUnavailableException;
	import javax.sound.sampled.Mixer;
	import javax.sound.sampled.SourceDataLine;
	import javax.sound.sampled.AudioFormat.Encoding;
	import javax.sound.sampled.Control.Type;

	/**
	* Software audio mixer
	*
	* @author Karl Helgason
	*/
	public final class SoftMixingMixer implements Mixer {

	private static class Info extends Mixer.Info {
	Info() {
	super(INFO_NAME, INFO_VENDOR, INFO_DESCRIPTION, INFO_VERSION);
	}
	}

	static final String INFO_NAME = "Gervill Sound Mixer";

	static final String INFO_VENDOR = "OpenJDK Proposal";

	static final String INFO_DESCRIPTION = "Software Sound Mixer";

	static final String INFO_VERSION = "1.0";

	static final Mixer.Info info = new Info();

	final Object control_mutex = this;

	boolean implicitOpen = false;

	private boolean open = false;

	private SoftMixingMainMixer mainmixer = null;

	private AudioFormat format = new AudioFormat(44100, 16, 2, true, false);

	private SourceDataLine sourceDataLine = null;

	private SoftAudioPusher pusher = null;

	private AudioInputStream pusher_stream = null;

	private final float controlrate = 147f;

	private final long latency = 100000; // 100 msec

	private final boolean jitter_correction = false;

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

	private final javax.sound.sampled.Line.Info[] sourceLineInfo;

	public SoftMixingMixer() {

	sourceLineInfo = new javax.sound.sampled.Line.Info[2];

	ArrayList<AudioFormat> formats = new ArrayList<AudioFormat>();
	for (int channels = 1; channels <= 2; channels++) {
	formats.add(new AudioFormat(Encoding.PCM_SIGNED,
	AudioSystem.NOT_SPECIFIED, 8, channels, channels,
	AudioSystem.NOT_SPECIFIED, false));
	formats.add(new AudioFormat(Encoding.PCM_UNSIGNED,
	AudioSystem.NOT_SPECIFIED, 8, channels, channels,
	AudioSystem.NOT_SPECIFIED, false));
	for (int bits = 16; bits < 32; bits += 8) {
	formats.add(new AudioFormat(Encoding.PCM_SIGNED,
	AudioSystem.NOT_SPECIFIED, bits, channels, channels
	* bits / 8, AudioSystem.NOT_SPECIFIED, false));
	formats.add(new AudioFormat(Encoding.PCM_UNSIGNED,
	AudioSystem.NOT_SPECIFIED, bits, channels, channels
	* bits / 8, AudioSystem.NOT_SPECIFIED, false));
	formats.add(new AudioFormat(Encoding.PCM_SIGNED,
	AudioSystem.NOT_SPECIFIED, bits, channels, channels
	* bits / 8, AudioSystem.NOT_SPECIFIED, true));
	formats.add(new AudioFormat(Encoding.PCM_UNSIGNED,
	AudioSystem.NOT_SPECIFIED, bits, channels, channels
	* bits / 8, AudioSystem.NOT_SPECIFIED, true));
	}
	formats.add(new AudioFormat(Encoding.PCM_FLOAT,
	AudioSystem.NOT_SPECIFIED, 32, channels, channels * 4,
	AudioSystem.NOT_SPECIFIED, false));
	formats.add(new AudioFormat(Encoding.PCM_FLOAT,
	AudioSystem.NOT_SPECIFIED, 32, channels, channels * 4,
	AudioSystem.NOT_SPECIFIED, true));
	formats.add(new AudioFormat(Encoding.PCM_FLOAT,
	AudioSystem.NOT_SPECIFIED, 64, channels, channels * 8,
	AudioSystem.NOT_SPECIFIED, false));
	formats.add(new AudioFormat(Encoding.PCM_FLOAT,
	AudioSystem.NOT_SPECIFIED, 64, channels, channels * 8,
	AudioSystem.NOT_SPECIFIED, true));
	}
	AudioFormat[] formats_array = formats.toArray(new AudioFormat[formats
	.size()]);
	sourceLineInfo[0] = new DataLine.Info(SourceDataLine.class,
	formats_array, AudioSystem.NOT_SPECIFIED,
	AudioSystem.NOT_SPECIFIED);
	sourceLineInfo[1] = new DataLine.Info(Clip.class, formats_array,
	AudioSystem.NOT_SPECIFIED, AudioSystem.NOT_SPECIFIED);
	}

	public Line getLine(Line.Info info) throws LineUnavailableException {

	if (!isLineSupported(info))
	throw new IllegalArgumentException("Line unsupported: " + info);

	if ((info.getLineClass() == SourceDataLine.class)) {
	return new SoftMixingSourceDataLine(this, (DataLine.Info) info);
	}
	if ((info.getLineClass() == Clip.class)) {
	return new SoftMixingClip(this, (DataLine.Info) info);
	}

	throw new IllegalArgumentException("Line unsupported: " + info);
	}

	public int getMaxLines(Line.Info info) {
	if (info.getLineClass() == SourceDataLine.class)
	return AudioSystem.NOT_SPECIFIED;
	if (info.getLineClass() == Clip.class)
	return AudioSystem.NOT_SPECIFIED;
	return 0;
	}

	public javax.sound.sampled.Mixer.Info getMixerInfo() {
	return info;
	}

	public javax.sound.sampled.Line.Info[] getSourceLineInfo() {
	Line.Info[] localArray = new Line.Info[sourceLineInfo.length];
	System.arraycopy(sourceLineInfo, 0, localArray, 0,
	sourceLineInfo.length);
	return localArray;
	}

	public javax.sound.sampled.Line.Info[] getSourceLineInfo(
	javax.sound.sampled.Line.Info info) {
	int i;
	ArrayList<javax.sound.sampled.Line.Info> infos = new ArrayList<javax.sound.sampled.Line.Info>();

	for (i = 0; i < sourceLineInfo.length; i++) {
	if (info.matches(sourceLineInfo[i])) {
	infos.add(sourceLineInfo[i]);
	}
	}
	return infos.toArray(new Line.Info[infos.size()]);
	}

	public Line[] getSourceLines() {

	Line[] localLines;

	synchronized (control_mutex) {

	if (mainmixer == null)
	return new Line[0];
	SoftMixingDataLine[] sourceLines = mainmixer.getOpenLines();

	localLines = new Line[sourceLines.length];

	for (int i = 0; i < localLines.length; i++) {
	localLines[i] = sourceLines[i];
	}
	}

	return localLines;
	}

	public javax.sound.sampled.Line.Info[] getTargetLineInfo() {
	return new javax.sound.sampled.Line.Info[0];
	}

	public javax.sound.sampled.Line.Info[] getTargetLineInfo(
	javax.sound.sampled.Line.Info info) {
	return new javax.sound.sampled.Line.Info[0];
	}

	public Line[] getTargetLines() {
	return new Line[0];
	}

	public boolean isLineSupported(javax.sound.sampled.Line.Info info) {
	if (info != null) {
	for (int i = 0; i < sourceLineInfo.length; i++) {
	if (info.matches(sourceLineInfo[i])) {
	return true;
	}
	}
	}
	return false;
	}

	public boolean isSynchronizationSupported(Line[] lines, boolean maintainSync) {
	return false;
	}

	public void synchronize(Line[] lines, boolean maintainSync) {
	throw new IllegalArgumentException(
	"Synchronization not supported by this mixer.");
	}

	public void unsynchronize(Line[] lines) {
	throw new IllegalArgumentException(
	"Synchronization not supported by this mixer.");
	}

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

	private 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 void close() {
	if (!isOpen())
	return;

	sendEvent(new LineEvent(this, LineEvent.Type.CLOSE,
	AudioSystem.NOT_SPECIFIED));

	SoftAudioPusher pusher_to_be_closed = null;
	AudioInputStream pusher_stream_to_be_closed = null;
	synchronized (control_mutex) {
	if (pusher != null) {
	pusher_to_be_closed = pusher;
	pusher_stream_to_be_closed = pusher_stream;
	pusher = null;
	pusher_stream = null;
	}
	}

	if (pusher_to_be_closed != null) {
	// Pusher must not be closed synchronized against control_mutex
	// this may result in synchronized conflict between pusher and
	// current thread.
	pusher_to_be_closed.stop();

	try {
	pusher_stream_to_be_closed.close();
	} catch (IOException e) {
	e.printStackTrace();
	}
	}

	synchronized (control_mutex) {

	if (mainmixer != null)
	mainmixer.close();
	open = false;

	if (sourceDataLine != null) {
	sourceDataLine.drain();
	sourceDataLine.close();
	sourceDataLine = null;
	}

	}

	}

	public Control getControl(Type control) {
	throw new IllegalArgumentException("Unsupported control type : "
	+ control);
	}

	public Control[] getControls() {
	return new Control[0];
	}

	public javax.sound.sampled.Line.Info getLineInfo() {
	return new Line.Info(Mixer.class);
	}

	public boolean isControlSupported(Type control) {
	return false;
	}

	public boolean isOpen() {
	synchronized (control_mutex) {
	return open;
	}
	}

	public void open() throws LineUnavailableException {
	if (isOpen()) {
	implicitOpen = false;
	return;
	}
	open(null);
	}

	public void open(SourceDataLine line) throws LineUnavailableException {
	if (isOpen()) {
	implicitOpen = false;
	return;
	}
	synchronized (control_mutex) {

	try {

	if (line != null)
	format = line.getFormat();

	AudioInputStream ais = openStream(getFormat());

	if (line == null) {
	synchronized (SoftMixingMixerProvider.mutex) {
	SoftMixingMixerProvider.lockthread = Thread
	.currentThread();
	}

	try {
	Mixer defaultmixer = AudioSystem.getMixer(null);
	if (defaultmixer != null)
	{
	// Search for suitable line

	DataLine.Info idealinfo = null;
	AudioFormat idealformat = null;

	Line.Info[] lineinfos = defaultmixer.getSourceLineInfo();
	idealFound:
	for (int i = 0; i < lineinfos.length; i++) {
	if(lineinfos[i].getLineClass() == SourceDataLine.class)
	{
	DataLine.Info info = (DataLine.Info)lineinfos[i];
	AudioFormat[] formats = info.getFormats();
	for (int j = 0; j < formats.length; j++) {
	AudioFormat format = formats[j];
	if(format.getChannels() == 2 \|\|
	format.getChannels() == AudioSystem.NOT_SPECIFIED)
	if(format.getEncoding().equals(Encoding.PCM_SIGNED) \|\|
	format.getEncoding().equals(Encoding.PCM_UNSIGNED))
	if(format.getSampleRate() == AudioSystem.NOT_SPECIFIED \|\|
	format.getSampleRate() == 48000.0)
	if(format.getSampleSizeInBits() == AudioSystem.NOT_SPECIFIED \|\|
	format.getSampleSizeInBits() == 16)
	{
	idealinfo = info;
	int ideal_channels = format.getChannels();
	boolean ideal_signed = format.getEncoding().equals(Encoding.PCM_SIGNED);
	float ideal_rate = format.getSampleRate();
	boolean ideal_endian = format.isBigEndian();
	int ideal_bits = format.getSampleSizeInBits();
	if(ideal_bits == AudioSystem.NOT_SPECIFIED) ideal_bits = 16;
	if(ideal_channels == AudioSystem.NOT_SPECIFIED) ideal_channels = 2;
	if(ideal_rate == AudioSystem.NOT_SPECIFIED) ideal_rate = 48000;
	idealformat = new AudioFormat(ideal_rate, ideal_bits,
	ideal_channels, ideal_signed, ideal_endian);
	break idealFound;
	}
	}
	}
	}

	if(idealformat != null)
	{
	format = idealformat;
	line = (SourceDataLine) defaultmixer.getLine(idealinfo);
	}
	}

	if(line == null)
	line = AudioSystem.getSourceDataLine(format);
	} finally {
	synchronized (SoftMixingMixerProvider.mutex) {
	SoftMixingMixerProvider.lockthread = null;
	}
	}

	if (line == null)
	throw new IllegalArgumentException("No line matching "
	+ info.toString() + " is supported.");
	}

	double latency = this.latency;

	if (!line.isOpen()) {
	int bufferSize = getFormat().getFrameSize()
	* (int) (getFormat().getFrameRate() * (latency / 1000000f));
	line.open(getFormat(), bufferSize);

	// Remember that we opened that line
	// so we can close again in SoftSynthesizer.close()
	sourceDataLine = line;
	}
	if (!line.isActive())
	line.start();

	int controlbuffersize = 512;
	try {
	controlbuffersize = ais.available();
	} catch (IOException e) {
	}

	// Tell mixer not fill read buffers fully.
	// This lowers latency, and tells DataPusher
	// to read in smaller amounts.
	// mainmixer.readfully = false;
	// pusher = new DataPusher(line, ais);

	int buffersize = line.getBufferSize();
	buffersize -= buffersize % controlbuffersize;

	if (buffersize < 3 * controlbuffersize)
	buffersize = 3 * controlbuffersize;

	if (jitter_correction) {
	ais = new SoftJitterCorrector(ais, buffersize,
	controlbuffersize);
	}
	pusher = new SoftAudioPusher(line, ais, controlbuffersize);
	pusher_stream = ais;
	pusher.start();

	} catch (LineUnavailableException e) {
	if (isOpen())
	close();
	throw new LineUnavailableException(e.toString());
	}

	}
	}

	public AudioInputStream openStream(AudioFormat targetFormat)
	throws LineUnavailableException {

	if (isOpen())
	throw new LineUnavailableException("Mixer is already open");

	synchronized (control_mutex) {

	open = true;

	implicitOpen = false;

	if (targetFormat != null)
	format = targetFormat;

	mainmixer = new SoftMixingMainMixer(this);

	sendEvent(new LineEvent(this, LineEvent.Type.OPEN,
	AudioSystem.NOT_SPECIFIED));

	return mainmixer.getInputStream();

	}

	}

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

	public long getLatency() {
	synchronized (control_mutex) {
	return latency;
	}
	}

	public AudioFormat getFormat() {
	synchronized (control_mutex) {
	return format;
	}
	}

	float getControlRate() {
	return controlrate;
	}

	SoftMixingMainMixer getMainMixer() {
	if (!isOpen())
	return null;
	return mainmixer;
	}

	}

Back to index...