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.io.InputStream;
	import java.util.ArrayList;
	import java.util.Arrays;

	import javax.sound.sampled.AudioFormat;
	import javax.sound.sampled.AudioInputStream;
	import javax.sound.sampled.AudioSystem;
	import javax.sound.sampled.AudioFormat.Encoding;
	import javax.sound.sampled.spi.FormatConversionProvider;

	/**
	* This class is used to convert between 8,16,24,32 bit signed/unsigned
	* big/litle endian fixed/floating stereo/mono/multi-channel audio streams and
	* perform sample-rate conversion if needed.
	*
	* @author Karl Helgason
	*/
	public final class AudioFloatFormatConverter extends FormatConversionProvider {

	private static class AudioFloatFormatConverterInputStream extends
	InputStream {
	private final AudioFloatConverter converter;

	private final AudioFloatInputStream stream;

	private float[] readfloatbuffer;

	private final int fsize;

	AudioFloatFormatConverterInputStream(AudioFormat targetFormat,
	AudioFloatInputStream stream) {
	this.stream = stream;
	converter = AudioFloatConverter.getConverter(targetFormat);
	fsize = ((targetFormat.getSampleSizeInBits() + 7) / 8);
	}

	public int read() throws IOException {
	byte[] b = new byte[1];
	int ret = read(b);
	if (ret < 0)
	return ret;
	return b[0] & 0xFF;
	}

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

	int flen = len / fsize;
	if (readfloatbuffer == null \|\| readfloatbuffer.length < flen)
	readfloatbuffer = new float[flen];
	int ret = stream.read(readfloatbuffer, 0, flen);
	if (ret < 0)
	return ret;
	converter.toByteArray(readfloatbuffer, 0, ret, b, off);
	return ret * fsize;
	}

	public int available() throws IOException {
	int ret = stream.available();
	if (ret < 0)
	return ret;
	return ret * fsize;
	}

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

	public synchronized void mark(int readlimit) {
	stream.mark(readlimit * fsize);
	}

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

	public synchronized void reset() throws IOException {
	stream.reset();
	}

	public long skip(long n) throws IOException {
	long ret = stream.skip(n / fsize);
	if (ret < 0)
	return ret;
	return ret * fsize;
	}

	}

	private static class AudioFloatInputStreamChannelMixer extends
	AudioFloatInputStream {

	private final int targetChannels;

	private final int sourceChannels;

	private final AudioFloatInputStream ais;

	private final AudioFormat targetFormat;

	private float[] conversion_buffer;

	AudioFloatInputStreamChannelMixer(AudioFloatInputStream ais,
	int targetChannels) {
	this.sourceChannels = ais.getFormat().getChannels();
	this.targetChannels = targetChannels;
	this.ais = ais;
	AudioFormat format = ais.getFormat();
	targetFormat = new AudioFormat(format.getEncoding(), format
	.getSampleRate(), format.getSampleSizeInBits(),
	targetChannels, (format.getFrameSize() / sourceChannels)
	* targetChannels, format.getFrameRate(), format
	.isBigEndian());
	}

	public int available() throws IOException {
	return (ais.available() / sourceChannels) * targetChannels;
	}

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

	public AudioFormat getFormat() {
	return targetFormat;
	}

	public long getFrameLength() {
	return ais.getFrameLength();
	}

	public void mark(int readlimit) {
	ais.mark((readlimit / targetChannels) * sourceChannels);
	}

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

	public int read(float[] b, int off, int len) throws IOException {
	int len2 = (len / targetChannels) * sourceChannels;
	if (conversion_buffer == null \|\| conversion_buffer.length < len2)
	conversion_buffer = new float[len2];
	int ret = ais.read(conversion_buffer, 0, len2);
	if (ret < 0)
	return ret;
	if (sourceChannels == 1) {
	int cs = targetChannels;
	for (int c = 0; c < targetChannels; c++) {
	for (int i = 0, ix = off + c; i < len2; i++, ix += cs) {
	b[ix] = conversion_buffer[i];
	}
	}
	} else if (targetChannels == 1) {
	int cs = sourceChannels;
	for (int i = 0, ix = off; i < len2; i += cs, ix++) {
	b[ix] = conversion_buffer[i];
	}
	for (int c = 1; c < sourceChannels; c++) {
	for (int i = c, ix = off; i < len2; i += cs, ix++) {
	b[ix] += conversion_buffer[i];
	}
	}
	float vol = 1f / ((float) sourceChannels);
	for (int i = 0, ix = off; i < len2; i += cs, ix++) {
	b[ix] *= vol;
	}
	} else {
	int minChannels = Math.min(sourceChannels, targetChannels);
	int off_len = off + len;
	int ct = targetChannels;
	int cs = sourceChannels;
	for (int c = 0; c < minChannels; c++) {
	for (int i = off + c, ix = c; i < off_len; i += ct, ix += cs) {
	b[i] = conversion_buffer[ix];
	}
	}
	for (int c = minChannels; c < targetChannels; c++) {
	for (int i = off + c; i < off_len; i += ct) {
	b[i] = 0;
	}
	}
	}
	return (ret / sourceChannels) * targetChannels;
	}

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

	public long skip(long len) throws IOException {
	long ret = ais.skip((len / targetChannels) * sourceChannels);
	if (ret < 0)
	return ret;
	return (ret / sourceChannels) * targetChannels;
	}

	}

	private static 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 final int nrofchannels;

	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;

	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 offlen = off + len;
	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 + off; i < offlen; 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 Encoding[] formats = {Encoding.PCM_SIGNED,
	Encoding.PCM_UNSIGNED,
	Encoding.PCM_FLOAT};

	public AudioInputStream getAudioInputStream(Encoding targetEncoding,
	AudioInputStream sourceStream) {
	if (sourceStream.getFormat().getEncoding().equals(targetEncoding))
	return sourceStream;
	AudioFormat format = sourceStream.getFormat();
	int channels = format.getChannels();
	Encoding encoding = targetEncoding;
	float samplerate = format.getSampleRate();
	int bits = format.getSampleSizeInBits();
	boolean bigendian = format.isBigEndian();
	if (targetEncoding.equals(Encoding.PCM_FLOAT))
	bits = 32;
	AudioFormat targetFormat = new AudioFormat(encoding, samplerate, bits,
	channels, channels * bits / 8, samplerate, bigendian);
	return getAudioInputStream(targetFormat, sourceStream);
	}

	public AudioInputStream getAudioInputStream(AudioFormat targetFormat,
	AudioInputStream sourceStream) {
	if (!isConversionSupported(targetFormat, sourceStream.getFormat()))
	throw new IllegalArgumentException("Unsupported conversion: "
	+ sourceStream.getFormat().toString() + " to "
	+ targetFormat.toString());
	return getAudioInputStream(targetFormat, AudioFloatInputStream
	.getInputStream(sourceStream));
	}

	public AudioInputStream getAudioInputStream(AudioFormat targetFormat,
	AudioFloatInputStream sourceStream) {

	if (!isConversionSupported(targetFormat, sourceStream.getFormat()))
	throw new IllegalArgumentException("Unsupported conversion: "
	+ sourceStream.getFormat().toString() + " to "
	+ targetFormat.toString());
	if (targetFormat.getChannels() != sourceStream.getFormat()
	.getChannels())
	sourceStream = new AudioFloatInputStreamChannelMixer(sourceStream,
	targetFormat.getChannels());
	if (Math.abs(targetFormat.getSampleRate()
	- sourceStream.getFormat().getSampleRate()) > 0.000001)
	sourceStream = new AudioFloatInputStreamResampler(sourceStream,
	targetFormat);
	return new AudioInputStream(new AudioFloatFormatConverterInputStream(
	targetFormat, sourceStream), targetFormat, sourceStream
	.getFrameLength());
	}

	public Encoding[] getSourceEncodings() {
	return new Encoding[] { Encoding.PCM_SIGNED, Encoding.PCM_UNSIGNED,
	Encoding.PCM_FLOAT };
	}

	public Encoding[] getTargetEncodings() {
	return new Encoding[] { Encoding.PCM_SIGNED, Encoding.PCM_UNSIGNED,
	Encoding.PCM_FLOAT };
	}

	public Encoding[] getTargetEncodings(AudioFormat sourceFormat) {
	if (AudioFloatConverter.getConverter(sourceFormat) == null)
	return new Encoding[0];
	return new Encoding[] { Encoding.PCM_SIGNED, Encoding.PCM_UNSIGNED,
	Encoding.PCM_FLOAT };
	}

	public AudioFormat[] getTargetFormats(Encoding targetEncoding,
	AudioFormat sourceFormat) {
	if (AudioFloatConverter.getConverter(sourceFormat) == null)
	return new AudioFormat[0];
	int channels = sourceFormat.getChannels();

	ArrayList<AudioFormat> formats = new ArrayList<AudioFormat>();

	if (targetEncoding.equals(Encoding.PCM_SIGNED))
	formats.add(new AudioFormat(Encoding.PCM_SIGNED,
	AudioSystem.NOT_SPECIFIED, 8, channels, channels,
	AudioSystem.NOT_SPECIFIED, false));
	if (targetEncoding.equals(Encoding.PCM_UNSIGNED))
	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) {
	if (targetEncoding.equals(Encoding.PCM_SIGNED)) {
	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_SIGNED,
	AudioSystem.NOT_SPECIFIED, bits, channels, channels
	* bits / 8, AudioSystem.NOT_SPECIFIED, true));
	}
	if (targetEncoding.equals(Encoding.PCM_UNSIGNED)) {
	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_UNSIGNED,
	AudioSystem.NOT_SPECIFIED, bits, channels, channels
	* bits / 8, AudioSystem.NOT_SPECIFIED, false));
	}
	}

	if (targetEncoding.equals(Encoding.PCM_FLOAT)) {
	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));
	}

	return formats.toArray(new AudioFormat[formats.size()]);
	}

	public boolean isConversionSupported(AudioFormat targetFormat,
	AudioFormat sourceFormat) {
	if (AudioFloatConverter.getConverter(sourceFormat) == null)
	return false;
	if (AudioFloatConverter.getConverter(targetFormat) == null)
	return false;
	if (sourceFormat.getChannels() <= 0)
	return false;
	if (targetFormat.getChannels() <= 0)
	return false;
	return true;
	}

	public boolean isConversionSupported(Encoding targetEncoding,
	AudioFormat sourceFormat) {
	if (AudioFloatConverter.getConverter(sourceFormat) == null)
	return false;
	for (int i = 0; i < formats.length; i++) {
	if (targetEncoding.equals(formats[i]))
	return true;
	}
	return false;
	}

	}

Back to index...