| /* |
| * 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.ByteArrayOutputStream; |
| 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.Clip; |
| import javax.sound.sampled.DataLine; |
| import javax.sound.sampled.LineEvent; |
| import javax.sound.sampled.LineUnavailableException; |
| |
| /** |
| * Clip implementation for the SoftMixingMixer. |
| * |
| * @author Karl Helgason |
| */ |
| public final class SoftMixingClip extends SoftMixingDataLine implements Clip { |
| |
| private AudioFormat format; |
| |
| private int framesize; |
| |
| private byte[] data; |
| |
| private final InputStream datastream = 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 read(byte[] b, int off, int len) throws IOException { |
| |
| if (_loopcount != 0) { |
| int bloopend = _loopend * framesize; |
| int bloopstart = _loopstart * framesize; |
| int pos = _frameposition * framesize; |
| |
| if (pos + len >= bloopend) |
| if (pos < bloopend) { |
| int offend = off + len; |
| int o = off; |
| while (off != offend) { |
| if (pos == bloopend) { |
| if (_loopcount == 0) |
| break; |
| pos = bloopstart; |
| if (_loopcount != LOOP_CONTINUOUSLY) |
| _loopcount--; |
| } |
| len = offend - off; |
| int left = bloopend - pos; |
| if (len > left) |
| len = left; |
| System.arraycopy(data, pos, b, off, len); |
| off += len; |
| } |
| if (_loopcount == 0) { |
| len = offend - off; |
| int left = bloopend - pos; |
| if (len > left) |
| len = left; |
| System.arraycopy(data, pos, b, off, len); |
| off += len; |
| } |
| _frameposition = pos / framesize; |
| return o - off; |
| } |
| } |
| |
| int pos = _frameposition * framesize; |
| int left = bufferSize - pos; |
| if (left == 0) |
| return -1; |
| if (len > left) |
| len = left; |
| System.arraycopy(data, pos, b, off, len); |
| _frameposition += len / framesize; |
| return len; |
| } |
| |
| }; |
| |
| private int offset; |
| |
| private int bufferSize; |
| |
| private float[] readbuffer; |
| |
| private boolean open = false; |
| |
| private AudioFormat outputformat; |
| |
| private int out_nrofchannels; |
| |
| private int in_nrofchannels; |
| |
| private int frameposition = 0; |
| |
| private boolean frameposition_sg = false; |
| |
| private boolean active_sg = false; |
| |
| private int loopstart = 0; |
| |
| private int loopend = -1; |
| |
| private boolean active = false; |
| |
| private int loopcount = 0; |
| |
| private boolean _active = false; |
| |
| private int _frameposition = 0; |
| |
| private boolean loop_sg = false; |
| |
| private int _loopcount = 0; |
| |
| private int _loopstart = 0; |
| |
| private int _loopend = -1; |
| |
| private float _rightgain; |
| |
| private float _leftgain; |
| |
| private float _eff1gain; |
| |
| private float _eff2gain; |
| |
| private AudioFloatInputStream afis; |
| |
| SoftMixingClip(SoftMixingMixer mixer, DataLine.Info info) { |
| super(mixer, info); |
| } |
| |
| protected void processControlLogic() { |
| |
| _rightgain = rightgain; |
| _leftgain = leftgain; |
| _eff1gain = eff1gain; |
| _eff2gain = eff2gain; |
| |
| if (active_sg) { |
| _active = active; |
| active_sg = false; |
| } else { |
| active = _active; |
| } |
| |
| if (frameposition_sg) { |
| _frameposition = frameposition; |
| frameposition_sg = false; |
| afis = null; |
| } else { |
| frameposition = _frameposition; |
| } |
| if (loop_sg) { |
| _loopcount = loopcount; |
| _loopstart = loopstart; |
| _loopend = loopend; |
| } |
| |
| if (afis == null) { |
| afis = AudioFloatInputStream.getInputStream(new AudioInputStream( |
| datastream, format, AudioSystem.NOT_SPECIFIED)); |
| |
| if (Math.abs(format.getSampleRate() - outputformat.getSampleRate()) > 0.000001) |
| afis = new AudioFloatInputStreamResampler(afis, outputformat); |
| } |
| |
| } |
| |
| 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 == -1) { |
| _active = false; |
| return; |
| } |
| 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.0002) { |
| |
| 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.0002) { |
| 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 int getFrameLength() { |
| return bufferSize / format.getFrameSize(); |
| } |
| |
| public long getMicrosecondLength() { |
| return (long) (getFrameLength() * (1000000.0 / (double) getFormat() |
| .getSampleRate())); |
| } |
| |
| public void loop(int count) { |
| LineEvent event = null; |
| |
| synchronized (control_mutex) { |
| if (isOpen()) { |
| if (active) |
| return; |
| active = true; |
| active_sg = true; |
| loopcount = count; |
| event = new LineEvent(this, LineEvent.Type.START, |
| getLongFramePosition()); |
| } |
| } |
| |
| if (event != null) |
| sendEvent(event); |
| |
| } |
| |
| public void open(AudioInputStream stream) throws LineUnavailableException, |
| IOException { |
| if (isOpen()) { |
| throw new IllegalStateException("Clip is already open with format " |
| + getFormat() + " and frame lengh of " + getFrameLength()); |
| } |
| if (AudioFloatConverter.getConverter(stream.getFormat()) == null) |
| throw new IllegalArgumentException("Invalid format : " |
| + stream.getFormat().toString()); |
| |
| if (stream.getFrameLength() != AudioSystem.NOT_SPECIFIED) { |
| byte[] data = new byte[(int) stream.getFrameLength() |
| * stream.getFormat().getFrameSize()]; |
| int readsize = 512 * stream.getFormat().getFrameSize(); |
| int len = 0; |
| while (len != data.length) { |
| if (readsize > data.length - len) |
| readsize = data.length - len; |
| int ret = stream.read(data, len, readsize); |
| if (ret == -1) |
| break; |
| if (ret == 0) |
| Thread.yield(); |
| len += ret; |
| } |
| open(stream.getFormat(), data, 0, len); |
| } else { |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| byte[] b = new byte[512 * stream.getFormat().getFrameSize()]; |
| int r = 0; |
| while ((r = stream.read(b)) != -1) { |
| if (r == 0) |
| Thread.yield(); |
| baos.write(b, 0, r); |
| } |
| open(stream.getFormat(), baos.toByteArray(), 0, baos.size()); |
| } |
| |
| } |
| |
| public void open(AudioFormat format, byte[] data, int offset, int bufferSize) |
| throws LineUnavailableException { |
| synchronized (control_mutex) { |
| if (isOpen()) { |
| throw new IllegalStateException( |
| "Clip is already open with format " + getFormat() |
| + " and frame lengh of " + getFrameLength()); |
| } |
| if (AudioFloatConverter.getConverter(format) == null) |
| throw new IllegalArgumentException("Invalid format : " |
| + format.toString()); |
| if (bufferSize % format.getFrameSize() != 0) |
| throw new IllegalArgumentException( |
| "Buffer size does not represent an integral number of sample frames!"); |
| |
| if (data != null) { |
| this.data = Arrays.copyOf(data, data.length); |
| } |
| this.offset = offset; |
| this.bufferSize = bufferSize; |
| this.format = format; |
| this.framesize = format.getFrameSize(); |
| |
| loopstart = 0; |
| loopend = -1; |
| loop_sg = true; |
| |
| if (!mixer.isOpen()) { |
| mixer.open(); |
| mixer.implicitOpen = true; |
| } |
| |
| outputformat = mixer.getFormat(); |
| out_nrofchannels = outputformat.getChannels(); |
| in_nrofchannels = format.getChannels(); |
| |
| open = true; |
| |
| mixer.getMainMixer().openLine(this); |
| } |
| |
| } |
| |
| public void setFramePosition(int frames) { |
| synchronized (control_mutex) { |
| frameposition_sg = true; |
| frameposition = frames; |
| } |
| } |
| |
| public void setLoopPoints(int start, int end) { |
| synchronized (control_mutex) { |
| if (end != -1) { |
| if (end < start) |
| throw new IllegalArgumentException("Invalid loop points : " |
| + start + " - " + end); |
| if (end * framesize > bufferSize) |
| throw new IllegalArgumentException("Invalid loop points : " |
| + start + " - " + end); |
| } |
| if (start * framesize > bufferSize) |
| throw new IllegalArgumentException("Invalid loop points : " |
| + start + " - " + end); |
| if (0 < start) |
| throw new IllegalArgumentException("Invalid loop points : " |
| + start + " - " + end); |
| loopstart = start; |
| loopend = end; |
| loop_sg = true; |
| } |
| } |
| |
| public void setMicrosecondPosition(long microseconds) { |
| setFramePosition((int) (microseconds * (((double) getFormat() |
| .getSampleRate()) / 1000000.0))); |
| } |
| |
| public int available() { |
| return 0; |
| } |
| |
| public void drain() { |
| } |
| |
| public void flush() { |
| } |
| |
| public int getBufferSize() { |
| return bufferSize; |
| } |
| |
| public AudioFormat getFormat() { |
| return format; |
| } |
| |
| public int getFramePosition() { |
| synchronized (control_mutex) { |
| return frameposition; |
| } |
| } |
| |
| public float getLevel() { |
| return AudioSystem.NOT_SPECIFIED; |
| } |
| |
| public long getLongFramePosition() { |
| return getFramePosition(); |
| } |
| |
| public long getMicrosecondPosition() { |
| return (long) (getFramePosition() * (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; |
| active_sg = true; |
| loopcount = 0; |
| 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; |
| active_sg = true; |
| 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() { |
| return open; |
| } |
| |
| public void open() throws LineUnavailableException { |
| if (data == null) { |
| throw new IllegalArgumentException( |
| "Illegal call to open() in interface Clip"); |
| } |
| open(format, data, offset, bufferSize); |
| } |
| |
| } |