/*
* Copyright (c) 2008, 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.Arrays;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.LineEvent;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.SourceDataLine;
/**
* SourceDataLine implemention for the SoftMixingMixer.
*
* @author Karl Helgason
*/
public class SoftMixingSourceDataLine extends SoftMixingDataLine implements
SourceDataLine {
private boolean open = false;
private AudioFormat format = new AudioFormat(44100.0f, 16, 2, true, false);
private int framesize;
private int bufferSize = -1;
private float[] readbuffer;
private boolean active = false;
private byte[] cycling_buffer;
private int cycling_read_pos = 0;
private int cycling_write_pos = 0;
private int cycling_avail = 0;
private long cycling_framepos = 0;
private AudioFloatInputStream afis;
private static class NonBlockingFloatInputStream extends
AudioFloatInputStream {
AudioFloatInputStream ais;
public NonBlockingFloatInputStream(AudioFloatInputStream ais) {
this.ais = ais;
}
public int available() throws IOException {
return ais.available();
}
public void close() throws IOException {
ais.close();
}
public AudioFormat getFormat() {
return ais.getFormat();
}
public long getFrameLength() {
return ais.getFrameLength();
}
public void mark(int readlimit) {
ais.mark(readlimit);
}
public boolean markSupported() {
return ais.markSupported();
}
public int read(float[] b, int off, int len) throws IOException {
int avail = available();
if (len > avail) {
int ret = ais.read(b, off, avail);
Arrays.fill(b, off + ret, off + len, 0);
return len;
}
return ais.read(b, off, len);
}
public void reset() throws IOException {
ais.reset();
}
public long skip(long len) throws IOException {
return ais.skip(len);
}
}
protected SoftMixingSourceDataLine(SoftMixingMixer mixer, DataLine.Info info) {
super(mixer, info);
}
public int write(byte[] b, int off, int len) {
if (!isOpen())
return 0;
if (len % framesize != 0)
throw new IllegalArgumentException(
"Number of bytes does not represent an integral number of sample frames.");
byte[] buff = cycling_buffer;
int buff_len = cycling_buffer.length;
int l = 0;
while (l != len) {
int avail;
synchronized (cycling_buffer) {
int pos = cycling_write_pos;
avail = cycling_avail;
while (l != len) {
if (avail == buff_len)
break;
buff[pos++] = b[off++];
l++;
avail++;
if (pos == buff_len)
pos = 0;
}
cycling_avail = avail;
cycling_write_pos = pos;
if (l == len)
return l;
}
if (avail == buff_len) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
return l;
}
if (!isRunning())
return l;
}
}
return l;
}
//
// BooleanControl.Type.APPLY_REVERB
// BooleanControl.Type.MUTE
// EnumControl.Type.REVERB
//
// FloatControl.Type.SAMPLE_RATE
// FloatControl.Type.REVERB_SEND
// FloatControl.Type.VOLUME
// FloatControl.Type.PAN
// FloatControl.Type.MASTER_GAIN
// FloatControl.Type.BALANCE
private boolean _active = false;
private AudioFormat outputformat;
private int out_nrofchannels;
private int in_nrofchannels;
private float _rightgain;
private float _leftgain;
private float _eff1gain;
private float _eff2gain;
protected void processControlLogic() {
_active = active;
_rightgain = rightgain;
_leftgain = leftgain;
_eff1gain = eff1gain;
_eff2gain = eff2gain;
}
protected void processAudioLogic(SoftAudioBuffer[] buffers) {
if (_active) {
float[] left = buffers[SoftMixingMainMixer.CHANNEL_LEFT].array();
float[] right = buffers[SoftMixingMainMixer.CHANNEL_RIGHT].array();
int bufferlen = buffers[SoftMixingMainMixer.CHANNEL_LEFT].getSize();
int readlen = bufferlen * in_nrofchannels;
if (readbuffer == null || readbuffer.length < readlen) {
readbuffer = new float[readlen];
}
int ret = 0;
try {
ret = afis.read(readbuffer);
if (ret != in_nrofchannels)
Arrays.fill(readbuffer, ret, readlen, 0);
} catch (IOException e) {
}
int in_c = in_nrofchannels;
for (int i = 0, ix = 0; i < bufferlen; i++, ix += in_c) {
left[i] += readbuffer[ix] * _leftgain;
}
if (out_nrofchannels != 1) {
if (in_nrofchannels == 1) {
for (int i = 0, ix = 0; i < bufferlen; i++, ix += in_c) {
right[i] += readbuffer[ix] * _rightgain;
}
} else {
for (int i = 0, ix = 1; i < bufferlen; i++, ix += in_c) {
right[i] += readbuffer[ix] * _rightgain;
}
}
}
if (_eff1gain > 0.0001) {
float[] eff1 = buffers[SoftMixingMainMixer.CHANNEL_EFFECT1]
.array();
for (int i = 0, ix = 0; i < bufferlen; i++, ix += in_c) {
eff1[i] += readbuffer[ix] * _eff1gain;
}
if (in_nrofchannels == 2) {
for (int i = 0, ix = 1; i < bufferlen; i++, ix += in_c) {
eff1[i] += readbuffer[ix] * _eff1gain;
}
}
}
if (_eff2gain > 0.0001) {
float[] eff2 = buffers[SoftMixingMainMixer.CHANNEL_EFFECT2]
.array();
for (int i = 0, ix = 0; i < bufferlen; i++, ix += in_c) {
eff2[i] += readbuffer[ix] * _eff2gain;
}
if (in_nrofchannels == 2) {
for (int i = 0, ix = 1; i < bufferlen; i++, ix += in_c) {
eff2[i] += readbuffer[ix] * _eff2gain;
}
}
}
}
}
public void open() throws LineUnavailableException {
open(format);
}
public void open(AudioFormat format) throws LineUnavailableException {
if (bufferSize == -1)
bufferSize = ((int) (format.getFrameRate() / 2))
* format.getFrameSize();
open(format, bufferSize);
}
public void open(AudioFormat format, int bufferSize)
throws LineUnavailableException {
LineEvent event = null;
if (bufferSize < format.getFrameSize() * 32)
bufferSize = format.getFrameSize() * 32;
synchronized (control_mutex) {
if (!isOpen()) {
if (!mixer.isOpen()) {
mixer.open();
mixer.implicitOpen = true;
}
event = new LineEvent(this, LineEvent.Type.OPEN, 0);
this.bufferSize = bufferSize - bufferSize
% format.getFrameSize();
this.format = format;
this.framesize = format.getFrameSize();
this.outputformat = mixer.getFormat();
out_nrofchannels = outputformat.getChannels();
in_nrofchannels = format.getChannels();
open = true;
mixer.getMainMixer().openLine(this);
cycling_buffer = new byte[framesize * bufferSize];
cycling_read_pos = 0;
cycling_write_pos = 0;
cycling_avail = 0;
cycling_framepos = 0;
InputStream cycling_inputstream = new InputStream() {
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 available() throws IOException {
synchronized (cycling_buffer) {
return cycling_avail;
}
}
public int read(byte[] b, int off, int len)
throws IOException {
synchronized (cycling_buffer) {
if (len > cycling_avail)
len = cycling_avail;
int pos = cycling_read_pos;
byte[] buff = cycling_buffer;
int buff_len = buff.length;
for (int i = 0; i < len; i++) {
b[off++] = buff[pos];
pos++;
if (pos == buff_len)
pos = 0;
}
cycling_read_pos = pos;
cycling_avail -= len;
cycling_framepos += len / framesize;
}
return len;
}
};
afis = AudioFloatInputStream
.getInputStream(new AudioInputStream(
cycling_inputstream, format,
AudioSystem.NOT_SPECIFIED));
afis = new NonBlockingFloatInputStream(afis);
if (Math.abs(format.getSampleRate()
- outputformat.getSampleRate()) > 0.000001)
afis = new AudioFloatInputStreamResampler(afis,
outputformat);
} else {
if (!format.matches(getFormat())) {
throw new IllegalStateException(
"Line is already open with format " + getFormat()
+ " and bufferSize " + getBufferSize());
}
}
}
if (event != null)
sendEvent(event);
}
public int available() {
synchronized (cycling_buffer) {
return cycling_buffer.length - cycling_avail;
}
}
public void drain() {
while (true) {
int avail;
synchronized (cycling_buffer) {
avail = cycling_avail;
}
if (avail != 0)
return;
try {
Thread.sleep(1);
} catch (InterruptedException e) {
return;
}
}
}
public void flush() {
synchronized (cycling_buffer) {
cycling_read_pos = 0;
cycling_write_pos = 0;
cycling_avail = 0;
}
}
public int getBufferSize() {
synchronized (control_mutex) {
return bufferSize;
}
}
public AudioFormat getFormat() {
synchronized (control_mutex) {
return format;
}
}
public int getFramePosition() {
return (int) getLongFramePosition();
}
public float getLevel() {
return AudioSystem.NOT_SPECIFIED;
}
public long getLongFramePosition() {
synchronized (cycling_buffer) {
return cycling_framepos;
}
}
public long getMicrosecondPosition() {
return (long) (getLongFramePosition() * (1000000.0 / (double) getFormat()
.getSampleRate()));
}
public boolean isActive() {
synchronized (control_mutex) {
return active;
}
}
public boolean isRunning() {
synchronized (control_mutex) {
return active;
}
}
public void start() {
LineEvent event = null;
synchronized (control_mutex) {
if (isOpen()) {
if (active)
return;
active = true;
event = new LineEvent(this, LineEvent.Type.START,
getLongFramePosition());
}
}
if (event != null)
sendEvent(event);
}
public void stop() {
LineEvent event = null;
synchronized (control_mutex) {
if (isOpen()) {
if (!active)
return;
active = false;
event = new LineEvent(this, LineEvent.Type.STOP,
getLongFramePosition());
}
}
if (event != null)
sendEvent(event);
}
public void close() {
LineEvent event = null;
synchronized (control_mutex) {
if (!isOpen())
return;
stop();
event = new LineEvent(this, LineEvent.Type.CLOSE,
getLongFramePosition());
open = false;
mixer.getMainMixer().closeLine(this);
}
if (event != null)
sendEvent(event);
}
public boolean isOpen() {
synchronized (control_mutex) {
return open;
}
}
}