diff options
Diffstat (limited to 'src/java/jogamp/openal')
| -rw-r--r-- | src/java/jogamp/openal/util/ALAudioSink.java | 1013 |
1 files changed, 1013 insertions, 0 deletions
diff --git a/src/java/jogamp/openal/util/ALAudioSink.java b/src/java/jogamp/openal/util/ALAudioSink.java new file mode 100644 index 0000000..d2e5e39 --- /dev/null +++ b/src/java/jogamp/openal/util/ALAudioSink.java @@ -0,0 +1,1013 @@ +/** + * Copyright 2013-2023 JogAmp Community. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of JogAmp Community. + */ +package jogamp.openal.util; + + +import java.nio.ByteBuffer; +import java.util.Arrays; + +import jogamp.openal.Debug; + +import com.jogamp.common.ExceptionUtils; +import com.jogamp.common.av.AudioSink; +import com.jogamp.common.util.LFRingbuffer; +import com.jogamp.common.util.PropertyAccess; +import com.jogamp.common.util.Ringbuffer; +import com.jogamp.common.util.locks.LockFactory; +import com.jogamp.common.util.locks.RecursiveLock; +import com.jogamp.openal.AL; +import com.jogamp.openal.ALC; +import com.jogamp.openal.ALCConstants; +import com.jogamp.openal.ALCcontext; +import com.jogamp.openal.ALCdevice; +import com.jogamp.openal.ALConstants; +import com.jogamp.openal.ALExt; +import com.jogamp.openal.ALFactory; +import com.jogamp.openal.util.ALHelpers; + +/*** + * OpenAL Audio Sink + */ +public class ALAudioSink implements AudioSink { + + private static final String AL_SOFT_buffer_samples = "AL_SOFT_buffer_samples"; + private static final String ALC_EXT_thread_local_context = "ALC_EXT_thread_local_context"; + private static final boolean DEBUG_TRACE; + private static final ALC alc; + private static final AL al; + private static final ALExt alExt; + private static final boolean staticAvailable; + + private String deviceSpecifier; + private ALCdevice device; + private boolean hasSOFTBufferSamples; + private boolean hasALC_thread_local_context; + private int preferredSampleRate; + private AudioFormat preferredAudioFormat; + private ALCcontext context; + private final RecursiveLock lock = LockFactory.createRecursiveLock(); + + /** Playback speed, range [0.5 - 2.0], default 1.0. */ + private float playSpeed; + private float volume = 1.0f; + + static class ALAudioFrame extends AudioFrame { + private final int alBuffer; + + ALAudioFrame(final int alBuffer) { + this.alBuffer = alBuffer; + } + public ALAudioFrame(final int alBuffer, final int pts, final int duration, final int dataSize) { + super(pts, duration, dataSize); + this.alBuffer = alBuffer; + } + + /** Get this frame's OpenAL buffer name */ + public final int getALBuffer() { return alBuffer; } + + @Override + public String toString() { + return "ALAudioFrame[pts " + pts + " ms, l " + duration + " ms, " + byteSize + " bytes, buffer "+alBuffer+"]"; + } + } + + // private ALAudioFrame[] alFrames = null; + private int[] alBufferNames = null; + private int frameGrowAmount = 0; + private int frameLimit = 0; + + private Ringbuffer<ALAudioFrame> alFramesAvail = null; + private Ringbuffer<ALAudioFrame> alFramesPlaying = null; + private volatile int alBufferBytesQueued = 0; + private volatile int playingPTS = AudioFrame.INVALID_PTS; + private volatile int enqueuedFrameCount; + + private int[] alSource = null; + private AudioFormat chosenFormat; + private int alChannelLayout; + private int alSampleType; + private int alFormat; + private boolean available; + + private volatile boolean playRequested = false; + + static { + Debug.initSingleton(); + DEBUG_TRACE = PropertyAccess.isPropertyDefined("joal.debug.AudioSink.trace", true); + + ALC _alc = null; + AL _al = null; + ALExt _alExt = null; + try { + _alc = ALFactory.getALC(); + _al = ALFactory.getAL(); + _alExt = ALFactory.getALExt(); + } catch(final Throwable t) { + if( DEBUG ) { + System.err.println("ALAudioSink: Caught "+t.getClass().getName()+": "+t.getMessage()); + t.printStackTrace(); + } + } + alc = _alc; + al = _al; + alExt = _alExt; + staticAvailable = null != alc && null != al && null != alExt; + } + + private void clearPreALError(final String prefix) { + checkALError(prefix); + } + private boolean checkALError(final String prefix) { + final int alcErr = alc.alcGetError(device); + final int alErr = al.alGetError(); + final boolean ok = ALCConstants.ALC_NO_ERROR == alcErr && ALConstants.AL_NO_ERROR == alErr; + if( DEBUG ) { + System.err.println("ALAudioSink."+prefix+": ok "+ok+", err [alc "+toHexString(alcErr)+", al "+toHexString(alErr)+"]"); + } + return ok; + } + + public ALAudioSink() { + available = false; + chosenFormat = null; + + if( !staticAvailable ) { + return; + } + synchronized(ALAudioSink.class) { + try { + // Get handle to default device. + device = alc.alcOpenDevice(null); + if (device == null) { + throw new RuntimeException(getThreadName()+": ALAudioSink: Error opening default OpenAL device"); + } + int checkErrIter = 1; + + clearPreALError("init."+checkErrIter++); + + // Get the device specifier. + deviceSpecifier = alc.alcGetString(device, ALCConstants.ALC_DEVICE_SPECIFIER); + if (deviceSpecifier == null) { + throw new RuntimeException(getThreadName()+": ALAudioSink: Error getting specifier for default OpenAL device"); + } + + // Create audio context. + // final int[] attrs = new int[] { ALC.ALC_FREQUENCY, DefaultFormat.sampleRate, 0 }; + // context = alc.alcCreateContext(device, attrs, 0); + context = alc.alcCreateContext(device, null); + if (context == null) { + throw new RuntimeException(getThreadName()+": ALAudioSink: Error creating OpenAL context for "+deviceSpecifier); + } + + lockContext(); + try { + // Check for an error. + if ( alc.alcGetError(device) != ALCConstants.ALC_NO_ERROR ) { + throw new RuntimeException(getThreadName()+": ALAudioSink: Error making OpenAL context current"); + } + + hasSOFTBufferSamples = al.alIsExtensionPresent(AL_SOFT_buffer_samples); + hasALC_thread_local_context = alc.alcIsExtensionPresent(null, ALC_EXT_thread_local_context) || + alc.alcIsExtensionPresent(device, ALC_EXT_thread_local_context) ; + clearPreALError("init."+checkErrIter++); + preferredSampleRate = querySampleRate(); + preferredAudioFormat = new AudioFormat(preferredSampleRate, DefaultFormat.sampleSize, DefaultFormat.channelCount, DefaultFormat.signed, DefaultFormat.fixedP, DefaultFormat.planar, DefaultFormat.littleEndian); + if( DEBUG ) { + final int[] alcvers = { 0, 0 }; + System.out.println("ALAudioSink: OpenAL Version: "+al.alGetString(ALConstants.AL_VERSION)); + System.out.println("ALAudioSink: OpenAL Extensions: "+al.alGetString(ALConstants.AL_EXTENSIONS)); + clearPreALError("init."+checkErrIter++); + System.out.println("ALAudioSink: Null device OpenALC:"); + alc.alcGetIntegerv(null, ALCConstants.ALC_MAJOR_VERSION, 1, alcvers, 0); + alc.alcGetIntegerv(null, ALCConstants.ALC_MINOR_VERSION, 1, alcvers, 1); + System.out.println(" Version: "+alcvers[0]+"."+alcvers[1]); + System.out.println(" Extensions: "+alc.alcGetString(null, ALCConstants.ALC_EXTENSIONS)); + clearPreALError("init."+checkErrIter++); + System.out.println("ALAudioSink: Device "+deviceSpecifier+" OpenALC:"); + alc.alcGetIntegerv(device, ALCConstants.ALC_MAJOR_VERSION, 1, alcvers, 0); + alc.alcGetIntegerv(device, ALCConstants.ALC_MINOR_VERSION, 1, alcvers, 1); + System.out.println(" Version: "+alcvers[0]+"."+alcvers[1]); + System.out.println(" Extensions: "+alc.alcGetString(device, ALCConstants.ALC_EXTENSIONS)); + System.out.println("ALAudioSink: hasSOFTBufferSamples "+hasSOFTBufferSamples); + System.out.println("ALAudioSink: hasALC_thread_local_context "+hasALC_thread_local_context); + System.out.println("ALAudioSink: preferredAudioFormat "+preferredAudioFormat); + clearPreALError("init."+checkErrIter++); + } + + // Create source + { + alSource = new int[1]; + al.alGenSources(1, alSource, 0); + final int err = al.alGetError(); + if( ALConstants.AL_NO_ERROR != err ) { + alSource = null; + throw new RuntimeException(getThreadName()+": ALAudioSink: Error generating Source: 0x"+Integer.toHexString(err)); + } + } + + if( DEBUG ) { + System.err.println("ALAudioSink: Using device: " + deviceSpecifier); + } + available = true; + } finally { + unlockContext(); + } + return; + } catch ( final Exception e ) { + if( DEBUG ) { + System.err.println(e.getMessage()); + e.printStackTrace(); + } + destroy(); + } + } + } + + private final int querySampleRate() { + final int sampleRate; + final int[] value = new int[1]; + alc.alcGetIntegerv(device, ALCConstants.ALC_FREQUENCY, 1, value, 0); + final int alcErr = alc.alcGetError(device); + final int alErr = al.alGetError(); + if ( ALCConstants.ALC_NO_ERROR == alcErr && ALConstants.AL_NO_ERROR == alErr && 0 != value[0] ) { + sampleRate = value[0]; + } else { + sampleRate = DefaultFormat.sampleRate; + } + if( DEBUG ) { + System.err.println("ALAudioSink.querySampleRate: err [alc "+toHexString(alcErr)+", al "+toHexString(alErr)+"], freq: "+value[0]+" -> "+sampleRate); + } + return sampleRate; + } + + private final void lockContext() { + lock.lock(); + if( hasALC_thread_local_context ) { + alExt.alcSetThreadContext(context); + } else { + alc.alcMakeContextCurrent(context); + } + final int alcErr = alc.alcGetError(null); + if( ALCConstants.ALC_NO_ERROR != alcErr ) { + final String err = getThreadName()+": ALCError "+toHexString(alcErr)+" while makeCurrent. "+this; + System.err.println(err); + ExceptionUtils.dumpStack(System.err); + lock.unlock(); + throw new RuntimeException(err); + } + final int alErr = al.alGetError(); + if( ALCConstants.ALC_NO_ERROR != alErr ) { + if( DEBUG ) { + System.err.println(getThreadName()+": Prev - ALError "+toHexString(alErr)+" @ makeCurrent. "+this); + ExceptionUtils.dumpStack(System.err); + } + } + } + private final void unlockContext() { + if( hasALC_thread_local_context ) { + alExt.alcSetThreadContext(null); + } else { + alc.alcMakeContextCurrent(null); + } + lock.unlock(); + } + private final void destroyContext() { + lock.lock(); + try { + if( null != context ) { + try { + alc.alcDestroyContext(context); + } catch (final Throwable t) { + if( DEBUG ) { + ExceptionUtils.dumpThrowable("", t); + } + } + context = null; + } + // unroll lock ! + while(lock.getHoldCount() > 1) { + lock.unlock(); + } + } finally { + lock.unlock(); + } + } + + @Override + public final String toString() { + final int alSrcName = null != alSource ? alSource[0] : 0; + final int alBuffersLen = null != alBufferNames ? alBufferNames.length : 0; + final int ctxHash = context != null ? context.hashCode() : 0; + final int alFramesAvailSize = alFramesAvail != null ? alFramesAvail.size() : 0; + final int alFramesPlayingSize = alFramesPlaying != null ? alFramesPlaying.size() : 0; + return "ALAudioSink[avail "+available+", playRequested "+playRequested+", device "+deviceSpecifier+", ctx "+toHexString(ctxHash)+", alSource "+alSrcName+ + ", chosen "+chosenFormat+ + ", al[chan "+ALHelpers.alChannelLayoutName(alChannelLayout)+", type "+ALHelpers.alSampleTypeName(alSampleType)+ + ", fmt "+toHexString(alFormat)+", soft "+hasSOFTBufferSamples+ + "], playSpeed "+playSpeed+", buffers[total "+alBuffersLen+", avail "+alFramesAvailSize+", "+ + "queued["+alFramesPlayingSize+", apts "+getPTS()+", "+getQueuedTime() + " ms, " + alBufferBytesQueued+" bytes], "+ + "queue[g "+frameGrowAmount+", l "+frameLimit+"]"; + } + + private final String shortString() { + final int alSrcName = null != alSource ? alSource[0] : 0; + final int ctxHash = context != null ? context.hashCode() : 0; + return "[ctx "+toHexString(ctxHash)+", playReq "+playRequested+", alSrc "+alSrcName+ + ", queued["+alFramesPlaying.size()+", " + alBufferBytesQueued+" bytes], "+ + "queue[g "+frameGrowAmount+", l "+frameLimit+"]"; + } + + public final String getPerfString() { + final int alBuffersLen = null != alBufferNames ? alBufferNames.length : 0; + return "Play [buffer "+alFramesPlaying.size()+"/"+alBuffersLen+", apts "+getPTS()+", "+getQueuedTime() + " ms, " + alBufferBytesQueued+" bytes]"; + } + + @Override + public int getPreferredSampleRate() { + return preferredSampleRate; + } + + @Override + public final AudioFormat getPreferredFormat() { + if( !staticAvailable ) { + return null; + } + return preferredAudioFormat; + } + + @Override + public final int getMaxSupportedChannels() { + if( !staticAvailable ) { + return 0; + } + return hasSOFTBufferSamples ? 8 : 2; + } + + @Override + public final boolean isSupported(final AudioFormat format) { + if( !staticAvailable ) { + return false; + } + if( format.planar || !format.littleEndian ) { + // FIXME big-endian supported w/ SOFT where it's native format! + return false; + } + final int alChannelLayout = ALHelpers.getDefaultALChannelLayout(format.channelCount); + if( ALConstants.AL_NONE != alChannelLayout ) { + final int alSampleType = ALHelpers.getALSampleType(format.sampleSize, format.signed, format.fixedP); + if( ALConstants.AL_NONE != alSampleType ) { + lockContext(); + try { + final int alFormat = ALHelpers.getALFormat(alChannelLayout, alSampleType, hasSOFTBufferSamples, al, alExt); + return ALConstants.AL_NONE != alFormat; + } finally { + unlockContext(); + } + } + } + return false; + } + + @Override + public final boolean init(final AudioFormat requestedFormat, final float frameDuration, final int initialQueueSize, final int queueGrowAmount, final int queueLimit) { + if( !staticAvailable ) { + return false; + } + alChannelLayout = ALHelpers.getDefaultALChannelLayout(requestedFormat.channelCount); + alSampleType = ALHelpers.getALSampleType(requestedFormat.sampleSize, requestedFormat.signed, requestedFormat.fixedP); + lockContext(); + try { + if( ALConstants.AL_NONE != alChannelLayout && ALConstants.AL_NONE != alSampleType ) { + alFormat = ALHelpers.getALFormat(alChannelLayout, alSampleType, hasSOFTBufferSamples, al, alExt); + } else { + alFormat = ALConstants.AL_NONE; + } + if( ALConstants.AL_NONE == alFormat ) { + // not supported + return false; + } + // Allocate buffers + destroyBuffers(); + { + final float useFrameDuration = frameDuration > 1f ? frameDuration : AudioSink.DefaultFrameDuration; + final int initialFrameCount = requestedFormat.getFrameCount( + initialQueueSize > 0 ? initialQueueSize : AudioSink.DefaultInitialQueueSize, useFrameDuration); + // frameDuration, int initialQueueSize, int queueGrowAmount, int queueLimit) { + alBufferNames = new int[initialFrameCount]; + al.alGenBuffers(initialFrameCount, alBufferNames, 0); + final int err = al.alGetError(); + if( ALConstants.AL_NO_ERROR != err ) { + alBufferNames = null; + throw new RuntimeException(getThreadName()+": ALAudioSink: Error generating Buffers: 0x"+Integer.toHexString(err)); + } + final ALAudioFrame[] alFrames = new ALAudioFrame[initialFrameCount]; + for(int i=0; i<initialFrameCount; i++) { + alFrames[i] = new ALAudioFrame(alBufferNames[i]); + } + + alFramesAvail = new LFRingbuffer<ALAudioFrame>(alFrames); + alFramesPlaying = new LFRingbuffer<ALAudioFrame>(ALAudioFrame[].class, initialFrameCount); + this.frameGrowAmount = requestedFormat.getFrameCount( + queueGrowAmount > 0 ? queueGrowAmount : AudioSink.DefaultQueueGrowAmount, useFrameDuration); + this.frameLimit = requestedFormat.getFrameCount( + queueLimit > 0 ? queueLimit : AudioSink.DefaultQueueLimitWithVideo, useFrameDuration); + if( DEBUG_TRACE ) { + alFramesAvail.dump(System.err, "Avail-init"); + alFramesPlaying.dump(System.err, "Playi-init"); + } + } + } finally { + unlockContext(); + } + + chosenFormat = requestedFormat; + return true; + } + + @Override + public final AudioFormat getChosenFormat() { + return chosenFormat; + } + + private static int[] concat(final int[] first, final int[] second) { + final int[] result = Arrays.copyOf(first, first.length + second.length); + System.arraycopy(second, 0, result, first.length, second.length); + return result; + } + /** + private static <T> T[] concat(T[] first, T[] second) { + final T[] result = Arrays.copyOf(first, first.length + second.length); + System.arraycopy(second, 0, result, first.length, second.length); + return result; + } */ + + private boolean growBuffers() { + if( !alFramesAvail.isEmpty() || !alFramesPlaying.isFull() ) { + throw new InternalError("Buffers: Avail is !empty "+alFramesAvail+" or Playing is !full "+alFramesPlaying); + } + if( alFramesAvail.capacity() >= frameLimit || alFramesPlaying.capacity() >= frameLimit ) { + if( DEBUG ) { + System.err.println(getThreadName()+": ALAudioSink.growBuffers: Frame limit "+frameLimit+" reached: Avail "+alFramesAvail+", Playing "+alFramesPlaying); + } + return false; + } + + final int[] newALBufferNames = new int[frameGrowAmount]; + al.alGenBuffers(frameGrowAmount, newALBufferNames, 0); + final int err = al.alGetError(); + if( ALConstants.AL_NO_ERROR != err ) { + if( DEBUG ) { + System.err.println(getThreadName()+": ALAudioSink.growBuffers: Error generating "+frameGrowAmount+" new Buffers: 0x"+Integer.toHexString(err)); + } + return false; + } + alBufferNames = concat(alBufferNames, newALBufferNames); + + final ALAudioFrame[] newALBuffers = new ALAudioFrame[frameGrowAmount]; + for(int i=0; i<frameGrowAmount; i++) { + newALBuffers[i] = new ALAudioFrame(newALBufferNames[i]); + } + // alFrames = concat(alFrames , newALBuffers); + + alFramesAvail.growEmptyBuffer(newALBuffers); + alFramesPlaying.growFullBuffer(frameGrowAmount); + if( alFramesAvail.isEmpty() || alFramesPlaying.isFull() ) { + throw new InternalError("Buffers: Avail is empty "+alFramesAvail+" or Playing is full "+alFramesPlaying); + } + if( DEBUG ) { + System.err.println(getThreadName()+": ALAudioSink: Buffer grown "+frameGrowAmount+": Avail "+alFramesAvail+", playing "+alFramesPlaying); + } + if( DEBUG_TRACE ) { + alFramesAvail.dump(System.err, "Avail-grow"); + alFramesPlaying.dump(System.err, "Playi-grow"); + } + return true; + } + + private void destroyBuffers() { + if( !staticAvailable ) { + return; + } + if( null != alBufferNames ) { + try { + al.alDeleteBuffers(alBufferNames.length, alBufferNames, 0); + } catch (final Throwable t) { + if( DEBUG ) { + System.err.println("Caught "+t.getClass().getName()+": "+t.getMessage()); + t.printStackTrace(); + } + } + alFramesAvail.clear(); + alFramesAvail = null; + alFramesPlaying.clear(); + alFramesPlaying = null; + alBufferBytesQueued = 0; + // alFrames = null; + alBufferNames = null; + } + } + + @Override + public final void destroy() { + available = false; + if( !staticAvailable ) { + return; + } + if( null != context ) { + lockContext(); + } + try { + stopImpl(true); + if( null != alSource ) { + try { + al.alDeleteSources(1, alSource, 0); + } catch (final Throwable t) { + if( DEBUG ) { + System.err.println("Caught "+t.getClass().getName()+": "+t.getMessage()); + t.printStackTrace(); + } + } + alSource = null; + } + + destroyBuffers(); + } finally { + destroyContext(); + } + if( null != device ) { + try { + alc.alcCloseDevice(device); + } catch (final Throwable t) { + if( DEBUG ) { + System.err.println("Caught "+t.getClass().getName()+": "+t.getMessage()); + t.printStackTrace(); + } + } + device = null; + } + chosenFormat = null; + } + + @Override + public final boolean isAvailable() { + return available; + } + + /** + * Dequeuing playing audio frames. + * @param wait if true, waiting for completion of audio buffers + * @param ignoreBufferInconsistency + * @return dequeued buffer count + */ + private final int dequeueBuffer(final boolean wait, final boolean ignoreBufferInconsistency) { + int alErr = ALConstants.AL_NO_ERROR; + final int releaseBufferCount; + if( alBufferBytesQueued > 0 ) { + final int releaseBufferLimes = Math.max(1, alFramesPlaying.size() / 4 ); + final int[] val=new int[1]; + int i=0; + do { + al.alGetSourcei(alSource[0], ALConstants.AL_BUFFERS_PROCESSED, val, 0); + alErr = al.alGetError(); + if( ALConstants.AL_NO_ERROR != alErr ) { + throw new RuntimeException(getThreadName()+": ALError "+toHexString(alErr)+" while quering processed buffers at source. "+this); + } + if( wait && val[0] < releaseBufferLimes ) { + i++; + // clip wait at [2 .. 100] ms + final int avgBufferDura = chosenFormat.getBytesDuration( alBufferBytesQueued / alFramesPlaying.size() ); + final int sleep = Math.max(2, Math.min(100, releaseBufferLimes * avgBufferDura)); + if( DEBUG ) { + System.err.println(getThreadName()+": ALAudioSink: Dequeue.wait["+i+"]: avgBufferDura "+avgBufferDura+", releaseBufferLimes "+releaseBufferLimes+", sleep "+sleep+" ms, playImpl "+(ALConstants.AL_PLAYING == getSourceState(false))+", processed "+val[0]+", "+this); + } + unlockContext(); + try { + Thread.sleep( sleep - 1 ); + } catch (final InterruptedException e) { + } finally { + lockContext(); + } + } + } while ( wait && val[0] < releaseBufferLimes && alBufferBytesQueued > 0 ); + releaseBufferCount = val[0]; + } else { + releaseBufferCount = 0; + } + + if( releaseBufferCount > 0 ) { + final int[] buffers = new int[releaseBufferCount]; + al.alSourceUnqueueBuffers(alSource[0], releaseBufferCount, buffers, 0); + alErr = al.alGetError(); + if( ALConstants.AL_NO_ERROR != alErr ) { + throw new RuntimeException(getThreadName()+": ALError "+toHexString(alErr)+" while dequeueing "+releaseBufferCount+" buffers. "+this); + } + for ( int i=0; i<releaseBufferCount; i++ ) { + final ALAudioFrame releasedBuffer = alFramesPlaying.get(); + if( null == releasedBuffer ) { + if( !ignoreBufferInconsistency ) { + throw new InternalError("Internal Error: "+this); + } + } else { + if(DEBUG_TRACE) { + System.err.println("< [al "+buffers[i]+", q "+releasedBuffer.alBuffer+"] <- "+shortString()+" @ "+getThreadName()); + } + if( releasedBuffer.alBuffer != buffers[i] ) { + if( !ignoreBufferInconsistency ) { + alFramesAvail.dump(System.err, "Avail-deq02-post"); + alFramesPlaying.dump(System.err, "Playi-deq02-post"); + throw new InternalError("Buffer name mismatch: dequeued: "+buffers[i]+", released "+releasedBuffer+", "+this); + } + } + alBufferBytesQueued -= releasedBuffer.getByteSize(); + if( !alFramesAvail.put(releasedBuffer) ) { + throw new InternalError("Internal Error: "+this); + } + if(DEBUG_TRACE) { + System.err.println("<< [al "+buffers[i]+", q "+releasedBuffer.alBuffer+"] <- "+shortString()+" @ "+getThreadName()); + } + } + } + } + return releaseBufferCount; + } + private final void dequeueForceAll() { + if(DEBUG_TRACE) { + System.err.println("< _FLUSH_ <- "+shortString()+" @ "+getThreadName()); + } + final int[] val=new int[1]; + al.alSourcei(alSource[0], ALConstants.AL_BUFFER, 0); // explicit force zero buffer! + if(DEBUG_TRACE) { + al.alGetSourcei(alSource[0], ALConstants.AL_BUFFERS_PROCESSED, val, 0); + } + final int alErr = al.alGetError(); + while ( !alFramesPlaying.isEmpty() ) { + final ALAudioFrame releasedBuffer = alFramesPlaying.get(); + if( null == releasedBuffer ) { + throw new InternalError("Internal Error: "+this); + } + alBufferBytesQueued -= releasedBuffer.getByteSize(); + if( !alFramesAvail.put(releasedBuffer) ) { + throw new InternalError("Internal Error: "+this); + } + } + alBufferBytesQueued = 0; + if(DEBUG_TRACE) { + System.err.println("<< _FLUSH_ [al "+val[0]+", err "+toHexString(alErr)+"] <- "+shortString()+" @ "+getThreadName()); + ExceptionUtils.dumpStack(System.err); + } + } + + /** + * Dequeuing playing audio frames. + * @param wait if true, waiting for completion of audio buffers + * @param inPTS + * @param inDuration + * @return dequeued buffer count + */ + private final int dequeueBuffer(final boolean wait, final int inPTS, final int inDuration) { + final int dequeuedBufferCount = dequeueBuffer( wait, false /* ignoreBufferInconsistency */ ); + final ALAudioFrame currentBuffer = alFramesPlaying.peek(); + if( null != currentBuffer ) { + playingPTS = currentBuffer.getPTS(); + } else { + playingPTS = inPTS; + } + if( DEBUG ) { + if( dequeuedBufferCount > 0 ) { + System.err.println(getThreadName()+": ALAudioSink: Write "+inPTS+", "+inDuration+" ms, dequeued "+dequeuedBufferCount+", wait "+wait+", "+getPerfString()); + } + } + return dequeuedBufferCount; + } + + @Override + public final AudioFrame enqueueData(final int pts, final ByteBuffer bytes, final int byteCount) { + if( !available || null == chosenFormat ) { + return null; + } + final ALAudioFrame alFrame; + + // OpenAL consumes buffers in the background + // we first need to initialize the OpenAL buffers then + // start continuous playback. + lockContext(); + try { + final int duration = chosenFormat.getBytesDuration(byteCount); + final boolean dequeueDone; + if( alFramesAvail.isEmpty() ) { + // try to dequeue w/o waiting first + dequeueDone = dequeueBuffer(false, pts, duration) > 0; + if( alFramesAvail.isEmpty() ) { + // try to grow + growBuffers(); + } + } else { + dequeueDone = false; + } + if( !dequeueDone && alFramesPlaying.size() > 0 ) { // dequeue only possible if playing .. + final boolean wait = isPlayingImpl0() && alFramesAvail.isEmpty(); // possible if grow failed or already exceeds it's limit! + dequeueBuffer(wait, pts, duration); + } + + alFrame = alFramesAvail.get(); + if( null == alFrame ) { + alFramesAvail.dump(System.err, "Avail"); + throw new InternalError("Internal Error: avail.get null "+alFramesAvail+", "+this); + } + alFrame.setPTS(pts); + alFrame.setDuration(duration); + alFrame.setByteSize(byteCount); + if( !alFramesPlaying.put( alFrame ) ) { + throw new InternalError("Internal Error: "+this); + } + final int[] alBufferNames = new int[] { alFrame.alBuffer }; + if( hasSOFTBufferSamples ) { + final int samplesPerChannel = chosenFormat.getBytesSampleCount(byteCount) / chosenFormat.channelCount; + // final int samplesPerChannel = ALHelpers.bytesToSampleCount(byteCount, alChannelLayout, alSampleType); + alExt.alBufferSamplesSOFT(alFrame.alBuffer, chosenFormat.sampleRate, alFormat, + samplesPerChannel, alChannelLayout, alSampleType, bytes); + } else { + al.alBufferData(alFrame.alBuffer, alFormat, bytes, byteCount, chosenFormat.sampleRate); + } + + if(DEBUG_TRACE) { + System.err.println("> "+alFrame.alBuffer+" -> "+shortString()+" @ "+getThreadName()); + } + + al.alSourceQueueBuffers(alSource[0], 1, alBufferNames, 0); + final int alErr = al.alGetError(); + if( ALConstants.AL_NO_ERROR != alErr ) { + throw new RuntimeException(getThreadName()+": ALError "+toHexString(alErr)+" while queueing buffer "+toHexString(alBufferNames[0])+". "+this); + } + alBufferBytesQueued += byteCount; + enqueuedFrameCount++; // safe: only written-to while locked! + + if(DEBUG_TRACE) { + System.err.println(">> "+alFrame.alBuffer+" -> "+shortString()+" @ "+getThreadName()); + } + + playImpl(); // continue playing, fixes issue where we ran out of enqueued data! + } finally { + unlockContext(); + } + return alFrame; + } + + @Override + public final boolean isPlaying() { + if( !available || null == chosenFormat ) { + return false; + } + if( playRequested ) { + lockContext(); + try { + return isPlayingImpl0(); + } finally { + unlockContext(); + } + } else { + return false; + } + } + private final boolean isPlayingImpl0() { + if( playRequested ) { + return ALConstants.AL_PLAYING == getSourceState(false); + } else { + return false; + } + } + private final int getSourceState(final boolean ignoreError) { + final int[] val = new int[1]; + al.alGetSourcei(alSource[0], ALConstants.AL_SOURCE_STATE, val, 0); + final int alErr = al.alGetError(); + if( ALConstants.AL_NO_ERROR != alErr ) { + final String msg = getThreadName()+": ALError "+toHexString(alErr)+" while querying SOURCE_STATE. "+this; + if( ignoreError ) { + if( DEBUG ) { + System.err.println(msg); + } + } else { + throw new RuntimeException(msg); + } + } + return val[0]; + } + + @Override + public final void play() { + if( !available || null == chosenFormat ) { + return; + } + playRequested = true; + lockContext(); + try { + playImpl(); + if( DEBUG ) { + System.err.println(getThreadName()+": ALAudioSink: PLAY playImpl "+(ALConstants.AL_PLAYING == getSourceState(false))+", "+this); + } + } finally { + unlockContext(); + } + } + private final void playImpl() { + if( playRequested && ALConstants.AL_PLAYING != getSourceState(false) ) { + al.alSourcePlay(alSource[0]); + final int alErr = al.alGetError(); + if( ALConstants.AL_NO_ERROR != alErr ) { + throw new RuntimeException(getThreadName()+": ALError "+toHexString(alErr)+" while start playing. "+this); + } + } + } + + @Override + public final void pause() { + if( !available || null == chosenFormat ) { + return; + } + if( playRequested ) { + lockContext(); + try { + pauseImpl(); + if( DEBUG ) { + System.err.println(getThreadName()+": ALAudioSink: PAUSE playImpl "+(ALConstants.AL_PLAYING == getSourceState(false))+", "+this); + } + } finally { + unlockContext(); + } + } + } + private final void pauseImpl() { + if( isPlayingImpl0() ) { + playRequested = false; + al.alSourcePause(alSource[0]); + final int alErr = al.alGetError(); + if( ALConstants.AL_NO_ERROR != alErr ) { + throw new RuntimeException(getThreadName()+": ALError "+toHexString(alErr)+" while pausing. "+this); + } + } + } + private final void stopImpl(final boolean ignoreError) { + if( ALConstants.AL_STOPPED != getSourceState(ignoreError) ) { + playRequested = false; + al.alSourceStop(alSource[0]); + final int alErr = al.alGetError(); + if( ALConstants.AL_NO_ERROR != alErr ) { + final String msg = "ALError "+toHexString(alErr)+" while stopping. "+this; + if( ignoreError ) { + if( DEBUG ) { + System.err.println(getThreadName()+": "+msg); + } + } else { + throw new RuntimeException(getThreadName()+": ALError "+toHexString(alErr)+" while stopping. "+this); + } + } + } + } + + @Override + public final float getPlaySpeed() { return playSpeed; } + + @Override + public final boolean setPlaySpeed(float rate) { + if( !available || null == chosenFormat ) { + return false; + } + lockContext(); + try { + if( Math.abs(1.0f - rate) < 0.01f ) { + rate = 1.0f; + } + if( 0.5f <= rate && rate <= 2.0f ) { // OpenAL limits + playSpeed = rate; + al.alSourcef(alSource[0], ALConstants.AL_PITCH, playSpeed); + return true; + } + } finally { + unlockContext(); + } + return false; + } + + @Override + public final float getVolume() { + return volume; + } + + @Override + public final boolean setVolume(float v) { + if( !available || null == chosenFormat ) { + return false; + } + lockContext(); + try { + if( Math.abs(v) < 0.01f ) { + v = 0.0f; + } else if( Math.abs(1.0f - v) < 0.01f ) { + v = 1.0f; + } + if( 0.0f <= v && v <= 1.0f ) { // OpenAL limits + volume = v; + al.alSourcef(alSource[0], ALConstants.AL_GAIN, v); + return true; + } + } finally { + unlockContext(); + } + return false; + } + + @Override + public final void flush() { + if( !available || null == chosenFormat ) { + return; + } + lockContext(); + try { + // pauseImpl(); + stopImpl(false); + // Redundant: dequeueBuffer( false /* wait */, true /* ignoreBufferInconsistency */); + dequeueForceAll(); + if( alBufferNames.length != alFramesAvail.size() || alFramesPlaying.size() != 0 ) { + throw new InternalError("XXX: "+this); + } + if( DEBUG ) { + System.err.println(getThreadName()+": ALAudioSink: FLUSH playImpl "+(ALConstants.AL_PLAYING == getSourceState(false))+", "+this); + } + } finally { + unlockContext(); + } + } + + @Override + public final int getEnqueuedFrameCount() { + return enqueuedFrameCount; + } + + @Override + public final int getFrameCount() { + return null != alBufferNames ? alBufferNames.length : 0; + } + + @Override + public final int getQueuedFrameCount() { + if( !available || null == chosenFormat ) { + return 0; + } + return alFramesPlaying.size(); + } + + @Override + public final int getFreeFrameCount() { + if( !available || null == chosenFormat ) { + return 0; + } + return alFramesAvail.size(); + } + + @Override + public final int getQueuedByteCount() { + if( !available || null == chosenFormat ) { + return 0; + } + return alBufferBytesQueued; + } + + @Override + public final int getQueuedTime() { + if( !available || null == chosenFormat ) { + return 0; + } + return chosenFormat.getBytesDuration(alBufferBytesQueued); + } + + @Override + public final int getPTS() { return playingPTS; } + + private static final String toHexString(final int v) { return "0x"+Integer.toHexString(v); } + private static final String getThreadName() { return Thread.currentThread().getName(); } +} |