|
|
@@ -0,0 +1,1423 @@
|
|
|
+/*
|
|
|
+ * Copyright (c) 2009-2012 jMonkeyEngine
|
|
|
+ * All rights reserved.
|
|
|
+ *
|
|
|
+ * Redistribution and use in source and binary forms, with or without
|
|
|
+ * modification, are permitted provided that the following conditions are
|
|
|
+ * met:
|
|
|
+ *
|
|
|
+ * * Redistributions of source code must retain the above copyright
|
|
|
+ * notice, this list of conditions and the following disclaimer.
|
|
|
+ *
|
|
|
+ * * 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.
|
|
|
+ *
|
|
|
+ * * Neither the name of 'jMonkeyEngine' nor the names of its contributors
|
|
|
+ * may be used to endorse or promote products derived from this software
|
|
|
+ * without specific prior written permission.
|
|
|
+ *
|
|
|
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
+ * "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 THE COPYRIGHT OWNER 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.
|
|
|
+ */
|
|
|
+package com.jme3.audio.android;
|
|
|
+
|
|
|
+import com.jme3.audio.*;
|
|
|
+import com.jme3.audio.AudioSource.Status;
|
|
|
+import com.jme3.math.Vector3f;
|
|
|
+import com.jme3.util.BufferUtils;
|
|
|
+import com.jme3.util.NativeObjectManager;
|
|
|
+import java.nio.ByteBuffer;
|
|
|
+import java.nio.FloatBuffer;
|
|
|
+import java.nio.IntBuffer;
|
|
|
+import java.util.ArrayList;
|
|
|
+import java.util.concurrent.atomic.AtomicBoolean;
|
|
|
+import java.util.logging.Level;
|
|
|
+import java.util.logging.Logger;
|
|
|
+
|
|
|
+public class AndroidOpenALSoftAudioRenderer implements AndroidAudioRenderer, Runnable {
|
|
|
+
|
|
|
+ private static final Logger logger = Logger.getLogger(AndroidOpenALSoftAudioRenderer.class.getName());
|
|
|
+ private final NativeObjectManager objManager = new NativeObjectManager();
|
|
|
+ // When multiplied by STREAMING_BUFFER_COUNT, will equal 44100 * 2 * 2
|
|
|
+ // which is exactly 1 second of audio.
|
|
|
+ private static final int BUFFER_SIZE = 35280;
|
|
|
+ private static final int STREAMING_BUFFER_COUNT = 5;
|
|
|
+ private final static int MAX_NUM_CHANNELS = 64;
|
|
|
+ private IntBuffer ib = BufferUtils.createIntBuffer(1);
|
|
|
+ private final FloatBuffer fb = BufferUtils.createVector3Buffer(2);
|
|
|
+ private final ByteBuffer nativeBuf = BufferUtils.createByteBuffer(BUFFER_SIZE);
|
|
|
+ private final byte[] arrayBuf = new byte[BUFFER_SIZE];
|
|
|
+ private int[] channels;
|
|
|
+ private AudioSource[] chanSrcs;
|
|
|
+ private int nextChan = 0;
|
|
|
+ private ArrayList<Integer> freeChans = new ArrayList<Integer>();
|
|
|
+ private Listener listener;
|
|
|
+ private boolean audioDisabled = false;
|
|
|
+ private boolean supportEfx = false;
|
|
|
+ private int auxSends = 0;
|
|
|
+ private int reverbFx = -1;
|
|
|
+ private int reverbFxSlot = -1;
|
|
|
+ // Update audio 20 times per second
|
|
|
+ private static final float UPDATE_RATE = 0.05f;
|
|
|
+ private final Thread audioThread = new Thread(this, "jME3 Audio Thread");
|
|
|
+ private final AtomicBoolean threadLock = new AtomicBoolean(false);
|
|
|
+ private boolean initialized = false;
|
|
|
+
|
|
|
+ public AndroidOpenALSoftAudioRenderer() {
|
|
|
+ }
|
|
|
+
|
|
|
+ public void initialize() {
|
|
|
+ if (!audioThread.isAlive()) {
|
|
|
+ audioThread.setDaemon(true);
|
|
|
+ audioThread.setPriority(Thread.NORM_PRIORITY + 1);
|
|
|
+ audioThread.start();
|
|
|
+ } else {
|
|
|
+ throw new IllegalStateException("Initialize already called");
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private void checkDead() {
|
|
|
+ if (audioThread.getState() == Thread.State.TERMINATED) {
|
|
|
+ throw new IllegalStateException("Audio thread is terminated");
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void run() {
|
|
|
+ initInThread();
|
|
|
+ synchronized (threadLock) {
|
|
|
+ threadLock.set(true);
|
|
|
+ threadLock.notifyAll();
|
|
|
+ }
|
|
|
+
|
|
|
+ initialized = true;
|
|
|
+
|
|
|
+ long updateRateNanos = (long) (UPDATE_RATE * 1000000000);
|
|
|
+ mainloop:
|
|
|
+ while (true) {
|
|
|
+ long startTime = System.nanoTime();
|
|
|
+
|
|
|
+ if (Thread.interrupted()) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ synchronized (threadLock) {
|
|
|
+ updateInThread(UPDATE_RATE);
|
|
|
+ }
|
|
|
+
|
|
|
+ long endTime = System.nanoTime();
|
|
|
+ long diffTime = endTime - startTime;
|
|
|
+
|
|
|
+ if (diffTime < updateRateNanos) {
|
|
|
+ long desiredEndTime = startTime + updateRateNanos;
|
|
|
+ while (System.nanoTime() < desiredEndTime) {
|
|
|
+ try {
|
|
|
+ Thread.sleep(1);
|
|
|
+ } catch (InterruptedException ex) {
|
|
|
+ break mainloop;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ initialized = false;
|
|
|
+
|
|
|
+ synchronized (threadLock) {
|
|
|
+ cleanupInThread();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void initInThread() {
|
|
|
+ try {
|
|
|
+ if (!alIsCreated()) {
|
|
|
+ //AL.create();
|
|
|
+ alCreate();
|
|
|
+ checkError(false);
|
|
|
+ }
|
|
|
+// } catch (OpenALException ex) {
|
|
|
+// logger.log(Level.SEVERE, "Failed to load audio library", ex);
|
|
|
+// audioDisabled = true;
|
|
|
+// return;
|
|
|
+// } catch (LWJGLException ex) {
|
|
|
+// logger.log(Level.SEVERE, "Failed to load audio library", ex);
|
|
|
+// audioDisabled = true;
|
|
|
+// return;
|
|
|
+ } catch (UnsatisfiedLinkError ex) {
|
|
|
+ logger.log(Level.SEVERE, "Failed to load audio library", ex);
|
|
|
+ audioDisabled = true;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ //ALCdevice device = AL.getDevice(); /* device maintained in jni */
|
|
|
+ //String deviceName = ALC10.alcGetString(device, ALC10.ALC_DEVICE_SPECIFIER);
|
|
|
+ String deviceName = alcGetString(AL.ALC_DEVICE_SPECIFIER);
|
|
|
+
|
|
|
+ logger.log(Level.INFO, "Audio Device: {0}", deviceName);
|
|
|
+ //logger.log(Level.INFO, "Audio Vendor: {0}", alGetString(AL_VENDOR));
|
|
|
+ //logger.log(Level.INFO, "Audio Renderer: {0}", alGetString(AL_RENDERER));
|
|
|
+ //logger.log(Level.INFO, "Audio Version: {0}", alGetString(AL_VERSION));
|
|
|
+ logger.log(Level.INFO, "Audio Vendor: {0}", alGetString(AL.AL_VENDOR));
|
|
|
+ logger.log(Level.INFO, "Audio Renderer: {0}", alGetString(AL.AL_RENDERER));
|
|
|
+ logger.log(Level.INFO, "Audio Version: {0}", alGetString(AL.AL_VERSION));
|
|
|
+
|
|
|
+ // Find maximum # of sources supported by this implementation
|
|
|
+ ArrayList<Integer> channelList = new ArrayList<Integer>();
|
|
|
+ for (int i = 0; i < MAX_NUM_CHANNELS; i++) {
|
|
|
+ int chan = alGenSources();
|
|
|
+ //if (alGetError() != 0) {
|
|
|
+ if (checkError(false) != 0) {
|
|
|
+ break;
|
|
|
+ } else {
|
|
|
+ channelList.add(chan);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ channels = new int[channelList.size()];
|
|
|
+ for (int i = 0; i < channels.length; i++) {
|
|
|
+ channels[i] = channelList.get(i);
|
|
|
+ }
|
|
|
+
|
|
|
+ ib = BufferUtils.createIntBuffer(channels.length);
|
|
|
+ chanSrcs = new AudioSource[channels.length];
|
|
|
+
|
|
|
+ logger.log(Level.INFO, "AudioRenderer supports {0} channels", channels.length);
|
|
|
+
|
|
|
+ //supportEfx = alcIsExtensionPresent(device, "ALC_EXT_EFX");
|
|
|
+ supportEfx = alcIsExtensionPresent(AL.ALC_EXT_EFX_NAME);
|
|
|
+
|
|
|
+ if (supportEfx) {
|
|
|
+ ib.position(0).limit(1);
|
|
|
+ //ALC10.alcGetInteger(device, EFX10.ALC_EFX_MAJOR_VERSION, ib);
|
|
|
+ alcGetInteger(AL.ALC_EFX_MAJOR_VERSION, ib, 1);
|
|
|
+ int major = ib.get(0);
|
|
|
+ ib.position(0).limit(1);
|
|
|
+ //ALC10.alcGetInteger(device, EFX10.ALC_EFX_MINOR_VERSION, ib);
|
|
|
+ alcGetInteger(AL.ALC_EFX_MINOR_VERSION, ib, 1);
|
|
|
+ int minor = ib.get(0);
|
|
|
+ logger.log(Level.INFO, "Audio effect extension version: {0}.{1}", new Object[]{major, minor});
|
|
|
+
|
|
|
+ //ALC10.alcGetInteger(device, EFX10.ALC_MAX_AUXILIARY_SENDS, ib);
|
|
|
+ alcGetInteger(AL.ALC_MAX_AUXILIARY_SENDS, ib, 1);
|
|
|
+ auxSends = ib.get(0);
|
|
|
+ logger.log(Level.INFO, "Audio max auxilary sends: {0}", auxSends);
|
|
|
+
|
|
|
+ // create slot
|
|
|
+ ib.position(0).limit(1);
|
|
|
+ //EFX10.alGenAuxiliaryEffectSlots(ib);
|
|
|
+ alGenAuxiliaryEffectSlots(1, ib);
|
|
|
+ reverbFxSlot = ib.get(0);
|
|
|
+
|
|
|
+ // create effect
|
|
|
+ ib.position(0).limit(1);
|
|
|
+ //EFX10.alGenEffects(ib);
|
|
|
+ alGenEffects(1, ib);
|
|
|
+ reverbFx = ib.get(0);
|
|
|
+ //EFX10.alEffecti(reverbFx, EFX10.AL_EFFECT_TYPE, EFX10.AL_EFFECT_REVERB);
|
|
|
+ alEffecti(reverbFx, AL.AL_EFFECT_TYPE, AL.AL_EFFECT_REVERB);
|
|
|
+
|
|
|
+ // attach reverb effect to effect slot
|
|
|
+ //EFX10.alAuxiliaryEffectSloti(reverbFxSlot, EFX10.AL_EFFECTSLOT_EFFECT, reverbFx);
|
|
|
+ alAuxiliaryEffectSloti(reverbFxSlot, AL.AL_EFFECTSLOT_EFFECT, reverbFx);
|
|
|
+ } else {
|
|
|
+ logger.log(Level.WARNING, "OpenAL EFX not available! Audio effects won't work.");
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void cleanupInThread() {
|
|
|
+ if (audioDisabled) {
|
|
|
+ //AL.destroy();
|
|
|
+ alDestroy();
|
|
|
+ checkError(true);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // stop any playing channels
|
|
|
+ for (int i = 0; i < chanSrcs.length; i++) {
|
|
|
+ if (chanSrcs[i] != null) {
|
|
|
+ clearChannel(i);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // delete channel-based sources
|
|
|
+ ib.clear();
|
|
|
+ ib.put(channels);
|
|
|
+ ib.flip();
|
|
|
+ //alDeleteSources(ib);
|
|
|
+ alDeleteSources(channels.length, ib);
|
|
|
+ checkError(true);
|
|
|
+
|
|
|
+ // delete audio buffers and filters
|
|
|
+ objManager.deleteAllObjects(this);
|
|
|
+
|
|
|
+ if (supportEfx) {
|
|
|
+ ib.position(0).limit(1);
|
|
|
+ ib.put(0, reverbFx);
|
|
|
+ //EFX10.alDeleteEffects(ib);
|
|
|
+ alDeleteEffects(1, ib);
|
|
|
+
|
|
|
+ // If this is not allocated, why is it deleted?
|
|
|
+ // Commented out to fix native crash in OpenAL.
|
|
|
+ ib.position(0).limit(1);
|
|
|
+ ib.put(0, reverbFxSlot);
|
|
|
+ //EFX10.alDeleteAuxiliaryEffectSlots(ib);
|
|
|
+ alDeleteAuxiliaryEffectSlots(1, ib);
|
|
|
+ }
|
|
|
+
|
|
|
+ //AL.destroy();
|
|
|
+ logger.log(Level.INFO, "Destroying OpenAL Soft Renderer");
|
|
|
+ alDestroy();
|
|
|
+ }
|
|
|
+
|
|
|
+ public void cleanup() {
|
|
|
+ // kill audio thread
|
|
|
+ if (audioThread.isAlive()) {
|
|
|
+ audioThread.interrupt();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private void updateFilter(Filter f) {
|
|
|
+ int id = f.getId();
|
|
|
+ if (id == -1) {
|
|
|
+ ib.position(0).limit(1);
|
|
|
+ //EFX10.alGenFilters(ib);
|
|
|
+ alGenFilters(1, ib);
|
|
|
+ id = ib.get(0);
|
|
|
+ f.setId(id);
|
|
|
+
|
|
|
+ objManager.registerObject(f);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (f instanceof LowPassFilter) {
|
|
|
+ LowPassFilter lpf = (LowPassFilter) f;
|
|
|
+ //EFX10.alFilteri(id, EFX10.AL_FILTER_TYPE, EFX10.AL_FILTER_LOWPASS);
|
|
|
+ alFilteri(id, AL.AL_FILTER_TYPE, AL.AL_FILTER_LOWPASS);
|
|
|
+ //EFX10.alFilterf(id, EFX10.AL_LOWPASS_GAIN, lpf.getVolume());
|
|
|
+ alFilterf(id, AL.AL_LOWPASS_GAIN, lpf.getVolume());
|
|
|
+ //EFX10.alFilterf(id, EFX10.AL_LOWPASS_GAINHF, lpf.getHighFreqVolume());
|
|
|
+ alFilterf(id, AL.AL_LOWPASS_GAINHF, lpf.getHighFreqVolume());
|
|
|
+ } else {
|
|
|
+ throw new UnsupportedOperationException("Filter type unsupported: "
|
|
|
+ + f.getClass().getName());
|
|
|
+ }
|
|
|
+
|
|
|
+ f.clearUpdateNeeded();
|
|
|
+ }
|
|
|
+
|
|
|
+ public void updateSourceParam(AudioSource src, AudioParam param) {
|
|
|
+ checkDead();
|
|
|
+ synchronized (threadLock) {
|
|
|
+ while (!threadLock.get()) {
|
|
|
+ try {
|
|
|
+ threadLock.wait();
|
|
|
+ } catch (InterruptedException ex) {
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (audioDisabled) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // There is a race condition in AudioSource that can
|
|
|
+ // cause this to be called for a node that has been
|
|
|
+ // detached from its channel. For example, setVolume()
|
|
|
+ // called from the render thread may see that that AudioSource
|
|
|
+ // still has a channel value but the audio thread may
|
|
|
+ // clear that channel before setVolume() gets to call
|
|
|
+ // updateSourceParam() (because the audio stopped playing
|
|
|
+ // on its own right as the volume was set). In this case,
|
|
|
+ // it should be safe to just ignore the update
|
|
|
+ if (src.getChannel() < 0) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ assert src.getChannel() >= 0;
|
|
|
+
|
|
|
+ int id = channels[src.getChannel()];
|
|
|
+ switch (param) {
|
|
|
+ case Position:
|
|
|
+ if (!src.isPositional()) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ Vector3f pos = src.getPosition();
|
|
|
+ //alSource3f(id, AL_POSITION, pos.x, pos.y, pos.z);
|
|
|
+ alSource3f(id, AL.AL_POSITION, pos.x, pos.y, pos.z);
|
|
|
+ checkError(true);
|
|
|
+ break;
|
|
|
+ case Velocity:
|
|
|
+ if (!src.isPositional()) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ Vector3f vel = src.getVelocity();
|
|
|
+ //alSource3f(id, AL_VELOCITY, vel.x, vel.y, vel.z);
|
|
|
+ alSource3f(id, AL.AL_VELOCITY, vel.x, vel.y, vel.z);
|
|
|
+ checkError(true);
|
|
|
+ break;
|
|
|
+ case MaxDistance:
|
|
|
+ if (!src.isPositional()) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ //alSourcef(id, AL_MAX_DISTANCE, src.getMaxDistance());
|
|
|
+ alSourcef(id, AL.AL_MAX_DISTANCE, src.getMaxDistance());
|
|
|
+ checkError(true);
|
|
|
+ break;
|
|
|
+ case RefDistance:
|
|
|
+ if (!src.isPositional()) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ //alSourcef(id, AL_REFERENCE_DISTANCE, src.getRefDistance());
|
|
|
+ alSourcef(id, AL.AL_REFERENCE_DISTANCE, src.getRefDistance());
|
|
|
+ checkError(true);
|
|
|
+ break;
|
|
|
+ case ReverbFilter:
|
|
|
+ if (!supportEfx || !src.isPositional() || !src.isReverbEnabled()) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ int filter = AL.AL_FILTER_NULL;
|
|
|
+ if (src.getReverbFilter() != null) {
|
|
|
+ Filter f = src.getReverbFilter();
|
|
|
+ if (f.isUpdateNeeded()) {
|
|
|
+ updateFilter(f);
|
|
|
+ }
|
|
|
+ filter = f.getId();
|
|
|
+ }
|
|
|
+ //AL11.alSource3i(id, EFX10.AL_AUXILIARY_SEND_FILTER, reverbFxSlot, 0, filter);
|
|
|
+ alSource3i(id, AL.AL_AUXILIARY_SEND_FILTER, reverbFxSlot, 0, filter);
|
|
|
+ break;
|
|
|
+ case ReverbEnabled:
|
|
|
+ if (!supportEfx || !src.isPositional()) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (src.isReverbEnabled()) {
|
|
|
+ updateSourceParam(src, AudioParam.ReverbFilter);
|
|
|
+ } else {
|
|
|
+ //AL11.alSource3i(id, EFX10.AL_AUXILIARY_SEND_FILTER, 0, 0, EFX10.AL_FILTER_NULL);
|
|
|
+ alSource3i(id, AL.AL_AUXILIARY_SEND_FILTER, 0, 0, AL.AL_FILTER_NULL);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case IsPositional:
|
|
|
+ if (!src.isPositional()) {
|
|
|
+ // Play in headspace
|
|
|
+ //alSourcei(id, AL_SOURCE_RELATIVE, AL_TRUE);
|
|
|
+ alSourcei(id, AL.AL_SOURCE_RELATIVE, AL.AL_TRUE);
|
|
|
+ checkError(true);
|
|
|
+ //alSource3f(id, AL_POSITION, 0, 0, 0);
|
|
|
+ alSource3f(id, AL.AL_POSITION, 0, 0, 0);
|
|
|
+ checkError(true);
|
|
|
+ //alSource3f(id, AL_VELOCITY, 0, 0, 0);
|
|
|
+ alSource3f(id, AL.AL_VELOCITY, 0, 0, 0);
|
|
|
+ checkError(true);
|
|
|
+
|
|
|
+ // Disable reverb
|
|
|
+ //AL11.alSource3i(id, EFX10.AL_AUXILIARY_SEND_FILTER, 0, 0, EFX10.AL_FILTER_NULL);
|
|
|
+ alSource3i(id, AL.AL_AUXILIARY_SEND_FILTER, 0, 0, AL.AL_FILTER_NULL);
|
|
|
+ } else {
|
|
|
+ //alSourcei(id, AL_SOURCE_RELATIVE, AL_FALSE);
|
|
|
+ alSourcei(id, AL.AL_SOURCE_RELATIVE, AL.AL_FALSE);
|
|
|
+ checkError(true);
|
|
|
+ updateSourceParam(src, AudioParam.Position);
|
|
|
+ updateSourceParam(src, AudioParam.Velocity);
|
|
|
+ updateSourceParam(src, AudioParam.MaxDistance);
|
|
|
+ updateSourceParam(src, AudioParam.RefDistance);
|
|
|
+ updateSourceParam(src, AudioParam.ReverbEnabled);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case Direction:
|
|
|
+ if (!src.isDirectional()) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ Vector3f dir = src.getDirection();
|
|
|
+ //alSource3f(id, AL_DIRECTION, dir.x, dir.y, dir.z);
|
|
|
+ alSource3f(id, AL.AL_DIRECTION, dir.x, dir.y, dir.z);
|
|
|
+ checkError(true);
|
|
|
+ break;
|
|
|
+ case InnerAngle:
|
|
|
+ if (!src.isDirectional()) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ //alSourcef(id, AL_CONE_INNER_ANGLE, src.getInnerAngle());
|
|
|
+ alSourcef(id, AL.AL_CONE_INNER_ANGLE, src.getInnerAngle());
|
|
|
+ checkError(true);
|
|
|
+ break;
|
|
|
+ case OuterAngle:
|
|
|
+ if (!src.isDirectional()) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ //alSourcef(id, AL_CONE_OUTER_ANGLE, src.getOuterAngle());
|
|
|
+ alSourcef(id, AL.AL_CONE_OUTER_ANGLE, src.getOuterAngle());
|
|
|
+ checkError(true);
|
|
|
+ break;
|
|
|
+ case IsDirectional:
|
|
|
+ if (src.isDirectional()) {
|
|
|
+ updateSourceParam(src, AudioParam.Direction);
|
|
|
+ updateSourceParam(src, AudioParam.InnerAngle);
|
|
|
+ updateSourceParam(src, AudioParam.OuterAngle);
|
|
|
+ //alSourcef(id, AL_CONE_OUTER_GAIN, 0);
|
|
|
+ alSourcef(id, AL.AL_CONE_OUTER_GAIN, 0);
|
|
|
+ checkError(true);
|
|
|
+ } else {
|
|
|
+ //alSourcef(id, AL_CONE_INNER_ANGLE, 360);
|
|
|
+ alSourcef(id, AL.AL_CONE_INNER_ANGLE, 360);
|
|
|
+ checkError(true);
|
|
|
+ //alSourcef(id, AL_CONE_OUTER_ANGLE, 360);
|
|
|
+ alSourcef(id, AL.AL_CONE_OUTER_ANGLE, 360);
|
|
|
+ checkError(true);
|
|
|
+ //alSourcef(id, AL_CONE_OUTER_GAIN, 1f);
|
|
|
+ alSourcef(id, AL.AL_CONE_OUTER_GAIN, 1f);
|
|
|
+ checkError(true);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case DryFilter:
|
|
|
+ if (!supportEfx) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (src.getDryFilter() != null) {
|
|
|
+ Filter f = src.getDryFilter();
|
|
|
+ if (f.isUpdateNeeded()) {
|
|
|
+ updateFilter(f);
|
|
|
+
|
|
|
+ // NOTE: must re-attach filter for changes to apply.
|
|
|
+ //alSourcei(id, EFX10.AL_DIRECT_FILTER, f.getId());
|
|
|
+ alSourcei(id, AL.AL_DIRECT_FILTER, f.getId());
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ //alSourcei(id, EFX10.AL_DIRECT_FILTER, EFX10.AL_FILTER_NULL);
|
|
|
+ alSourcei(id, AL.AL_DIRECT_FILTER, AL.AL_FILTER_NULL);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case Looping:
|
|
|
+ if (src.isLooping()) {
|
|
|
+ if (!(src.getAudioData() instanceof AudioStream)) {
|
|
|
+ //alSourcei(id, AL_LOOPING, AL_TRUE);
|
|
|
+ alSourcei(id, AL.AL_LOOPING, AL.AL_TRUE);
|
|
|
+ checkError(true);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ //alSourcei(id, AL_LOOPING, AL_FALSE);
|
|
|
+ alSourcei(id, AL.AL_LOOPING, AL.AL_FALSE);
|
|
|
+ checkError(true);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case Volume:
|
|
|
+ //alSourcef(id, AL_GAIN, src.getVolume());
|
|
|
+ alSourcef(id, AL.AL_GAIN, src.getVolume());
|
|
|
+ checkError(true);
|
|
|
+ break;
|
|
|
+ case Pitch:
|
|
|
+ //alSourcef(id, AL_PITCH, src.getPitch());
|
|
|
+ alSourcef(id, AL.AL_PITCH, src.getPitch());
|
|
|
+ checkError(true);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private void setSourceParams(int id, AudioSource src, boolean forceNonLoop) {
|
|
|
+ if (src.isPositional()) {
|
|
|
+ Vector3f pos = src.getPosition();
|
|
|
+ Vector3f vel = src.getVelocity();
|
|
|
+ //alSource3f(id, AL_POSITION, pos.x, pos.y, pos.z);
|
|
|
+ alSource3f(id, AL.AL_POSITION, pos.x, pos.y, pos.z);
|
|
|
+ checkError(true);
|
|
|
+ //alSource3f(id, AL_VELOCITY, vel.x, vel.y, vel.z);
|
|
|
+ alSource3f(id, AL.AL_VELOCITY, vel.x, vel.y, vel.z);
|
|
|
+ checkError(true);
|
|
|
+ //alSourcef(id, AL_MAX_DISTANCE, src.getMaxDistance());
|
|
|
+ alSourcef(id, AL.AL_MAX_DISTANCE, src.getMaxDistance());
|
|
|
+ checkError(true);
|
|
|
+ //alSourcef(id, AL_REFERENCE_DISTANCE, src.getRefDistance());
|
|
|
+ alSourcef(id, AL.AL_REFERENCE_DISTANCE, src.getRefDistance());
|
|
|
+ checkError(true);
|
|
|
+ //alSourcei(id, AL_SOURCE_RELATIVE, AL_FALSE);
|
|
|
+ alSourcei(id, AL.AL_SOURCE_RELATIVE, AL.AL_FALSE);
|
|
|
+ checkError(true);
|
|
|
+
|
|
|
+ if (src.isReverbEnabled() && supportEfx) {
|
|
|
+ //int filter = EFX10.AL_FILTER_NULL;
|
|
|
+ int filter = AL.AL_FILTER_NULL;
|
|
|
+ if (src.getReverbFilter() != null) {
|
|
|
+ Filter f = src.getReverbFilter();
|
|
|
+ if (f.isUpdateNeeded()) {
|
|
|
+ updateFilter(f);
|
|
|
+ }
|
|
|
+ filter = f.getId();
|
|
|
+ }
|
|
|
+ //AL11.alSource3i(id, EFX10.AL_AUXILIARY_SEND_FILTER, reverbFxSlot, 0, filter);
|
|
|
+ alSource3i(id, AL.AL_AUXILIARY_SEND_FILTER, reverbFxSlot, 0, filter);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ // play in headspace
|
|
|
+ //alSourcei(id, AL_SOURCE_RELATIVE, AL_TRUE);
|
|
|
+ alSourcei(id, AL.AL_SOURCE_RELATIVE, AL.AL_TRUE);
|
|
|
+ checkError(true);
|
|
|
+ //alSource3f(id, AL_POSITION, 0, 0, 0);
|
|
|
+ alSource3f(id, AL.AL_POSITION, 0, 0, 0);
|
|
|
+ checkError(true);
|
|
|
+ //alSource3f(id, AL_VELOCITY, 0, 0, 0);
|
|
|
+ alSource3f(id, AL.AL_VELOCITY, 0, 0, 0);
|
|
|
+ checkError(true);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (src.getDryFilter() != null && supportEfx) {
|
|
|
+ Filter f = src.getDryFilter();
|
|
|
+ if (f.isUpdateNeeded()) {
|
|
|
+ updateFilter(f);
|
|
|
+
|
|
|
+ // NOTE: must re-attach filter for changes to apply.
|
|
|
+ //alSourcei(id, EFX10.AL_DIRECT_FILTER, f.getId());
|
|
|
+ alSourcei(id, AL.AL_DIRECT_FILTER, f.getId());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (forceNonLoop) {
|
|
|
+ //alSourcei(id, AL_LOOPING, AL_FALSE);
|
|
|
+ alSourcei(id, AL.AL_LOOPING, AL.AL_FALSE);
|
|
|
+ checkError(true);
|
|
|
+ } else {
|
|
|
+ //alSourcei(id, AL_LOOPING, src.isLooping() ? AL_TRUE : AL_FALSE);
|
|
|
+ alSourcei(id, AL.AL_LOOPING, src.isLooping() ? AL.AL_TRUE : AL.AL_FALSE);
|
|
|
+ checkError(true);
|
|
|
+ }
|
|
|
+ //alSourcef(id, AL_GAIN, src.getVolume());
|
|
|
+ alSourcef(id, AL.AL_GAIN, src.getVolume());
|
|
|
+ checkError(true);
|
|
|
+ //alSourcef(id, AL_PITCH, src.getPitch());
|
|
|
+ alSourcef(id, AL.AL_PITCH, src.getPitch());
|
|
|
+ checkError(true);
|
|
|
+ //alSourcef(id, AL11.AL_SEC_OFFSET, src.getTimeOffset());
|
|
|
+ alSourcef(id, AL.AL_SEC_OFFSET, src.getTimeOffset());
|
|
|
+ checkError(true);
|
|
|
+
|
|
|
+ if (src.isDirectional()) {
|
|
|
+ Vector3f dir = src.getDirection();
|
|
|
+ //alSource3f(id, AL_DIRECTION, dir.x, dir.y, dir.z);
|
|
|
+ alSource3f(id, AL.AL_DIRECTION, dir.x, dir.y, dir.z);
|
|
|
+ checkError(true);
|
|
|
+ //alSourcef(id, AL_CONE_INNER_ANGLE, src.getInnerAngle());
|
|
|
+ alSourcef(id, AL.AL_CONE_INNER_ANGLE, src.getInnerAngle());
|
|
|
+ checkError(true);
|
|
|
+ //alSourcef(id, AL_CONE_OUTER_ANGLE, src.getOuterAngle());
|
|
|
+ alSourcef(id, AL.AL_CONE_OUTER_ANGLE, src.getOuterAngle());
|
|
|
+ checkError(true);
|
|
|
+ //alSourcef(id, AL_CONE_OUTER_GAIN, 0);
|
|
|
+ alSourcef(id, AL.AL_CONE_OUTER_GAIN, 0);
|
|
|
+ checkError(true);
|
|
|
+ } else {
|
|
|
+ //alSourcef(id, AL_CONE_INNER_ANGLE, 360);
|
|
|
+ alSourcef(id, AL.AL_CONE_INNER_ANGLE, 360);
|
|
|
+ checkError(true);
|
|
|
+ //alSourcef(id, AL_CONE_OUTER_ANGLE, 360);
|
|
|
+ alSourcef(id, AL.AL_CONE_OUTER_ANGLE, 360);
|
|
|
+ checkError(true);
|
|
|
+ //alSourcef(id, AL_CONE_OUTER_GAIN, 1f);
|
|
|
+ alSourcef(id, AL.AL_CONE_OUTER_GAIN, 1f);
|
|
|
+ checkError(true);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void updateListenerParam(Listener listener, ListenerParam param) {
|
|
|
+ checkDead();
|
|
|
+ synchronized (threadLock) {
|
|
|
+ while (!threadLock.get()) {
|
|
|
+ try {
|
|
|
+ threadLock.wait();
|
|
|
+ } catch (InterruptedException ex) {
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (audioDisabled) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ switch (param) {
|
|
|
+ case Position:
|
|
|
+ Vector3f pos = listener.getLocation();
|
|
|
+ //alListener3f(AL_POSITION, pos.x, pos.y, pos.z);
|
|
|
+ alListener3f(AL.AL_POSITION, pos.x, pos.y, pos.z);
|
|
|
+ checkError(true);
|
|
|
+ break;
|
|
|
+ case Rotation:
|
|
|
+ Vector3f dir = listener.getDirection();
|
|
|
+ Vector3f up = listener.getUp();
|
|
|
+ fb.rewind();
|
|
|
+ fb.put(dir.x).put(dir.y).put(dir.z);
|
|
|
+ fb.put(up.x).put(up.y).put(up.z);
|
|
|
+ fb.flip();
|
|
|
+ //alListener(AL_ORIENTATION, fb);
|
|
|
+ alListener(AL.AL_ORIENTATION, fb);
|
|
|
+ checkError(true);
|
|
|
+ break;
|
|
|
+ case Velocity:
|
|
|
+ Vector3f vel = listener.getVelocity();
|
|
|
+ //alListener3f(AL_VELOCITY, vel.x, vel.y, vel.z);
|
|
|
+ alListener3f(AL.AL_VELOCITY, vel.x, vel.y, vel.z);
|
|
|
+ checkError(true);
|
|
|
+ break;
|
|
|
+ case Volume:
|
|
|
+ //alListenerf(AL_GAIN, listener.getVolume());
|
|
|
+ alListenerf(AL.AL_GAIN, listener.getVolume());
|
|
|
+ checkError(true);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private void setListenerParams(Listener listener) {
|
|
|
+ Vector3f pos = listener.getLocation();
|
|
|
+ Vector3f vel = listener.getVelocity();
|
|
|
+ Vector3f dir = listener.getDirection();
|
|
|
+ Vector3f up = listener.getUp();
|
|
|
+
|
|
|
+ //alListener3f(AL_POSITION, pos.x, pos.y, pos.z);
|
|
|
+ alListener3f(AL.AL_POSITION, pos.x, pos.y, pos.z);
|
|
|
+ checkError(true);
|
|
|
+ //alListener3f(AL_VELOCITY, vel.x, vel.y, vel.z);
|
|
|
+ alListener3f(AL.AL_VELOCITY, vel.x, vel.y, vel.z);
|
|
|
+ checkError(true);
|
|
|
+ fb.rewind();
|
|
|
+ fb.put(dir.x).put(dir.y).put(dir.z);
|
|
|
+ fb.put(up.x).put(up.y).put(up.z);
|
|
|
+ fb.flip();
|
|
|
+ //alListener(AL_ORIENTATION, fb);
|
|
|
+ alListener(AL.AL_ORIENTATION, fb);
|
|
|
+ checkError(true);
|
|
|
+ //alListenerf(AL_GAIN, listener.getVolume());
|
|
|
+ alListenerf(AL.AL_GAIN, listener.getVolume());
|
|
|
+ checkError(true);
|
|
|
+ }
|
|
|
+
|
|
|
+ private int newChannel() {
|
|
|
+ if (freeChans.size() > 0) {
|
|
|
+ return freeChans.remove(0);
|
|
|
+ } else if (nextChan < channels.length) {
|
|
|
+ return nextChan++;
|
|
|
+ } else {
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private void freeChannel(int index) {
|
|
|
+ if (index == nextChan - 1) {
|
|
|
+ nextChan--;
|
|
|
+ } else {
|
|
|
+ freeChans.add(index);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void setEnvironment(Environment env) {
|
|
|
+ checkDead();
|
|
|
+ synchronized (threadLock) {
|
|
|
+ while (!threadLock.get()) {
|
|
|
+ try {
|
|
|
+ threadLock.wait();
|
|
|
+ } catch (InterruptedException ex) {
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (audioDisabled || !supportEfx) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ //EFX10.alEffectf(reverbFx, EFX10.AL_REVERB_DENSITY, env.getDensity());
|
|
|
+ alEffectf(reverbFx, AL.AL_REVERB_DENSITY, env.getDensity());
|
|
|
+ //EFX10.alEffectf(reverbFx, EFX10.AL_REVERB_DIFFUSION, env.getDiffusion());
|
|
|
+ alEffectf(reverbFx, AL.AL_REVERB_DIFFUSION, env.getDiffusion());
|
|
|
+ //EFX10.alEffectf(reverbFx, EFX10.AL_REVERB_GAIN, env.getGain());
|
|
|
+ alEffectf(reverbFx, AL.AL_REVERB_GAIN, env.getGain());
|
|
|
+ //EFX10.alEffectf(reverbFx, EFX10.AL_REVERB_GAINHF, env.getGainHf());
|
|
|
+ alEffectf(reverbFx, AL.AL_REVERB_GAINHF, env.getGainHf());
|
|
|
+ //EFX10.alEffectf(reverbFx, EFX10.AL_REVERB_DECAY_TIME, env.getDecayTime());
|
|
|
+ alEffectf(reverbFx, AL.AL_REVERB_DECAY_TIME, env.getDecayTime());
|
|
|
+ //EFX10.alEffectf(reverbFx, EFX10.AL_REVERB_DECAY_HFRATIO, env.getDecayHFRatio());
|
|
|
+ alEffectf(reverbFx, AL.AL_REVERB_DECAY_HFRATIO, env.getDecayHFRatio());
|
|
|
+ //EFX10.alEffectf(reverbFx, EFX10.AL_REVERB_REFLECTIONS_GAIN, env.getReflectGain());
|
|
|
+ alEffectf(reverbFx, AL.AL_REVERB_REFLECTIONS_GAIN, env.getReflectGain());
|
|
|
+ //EFX10.alEffectf(reverbFx, EFX10.AL_REVERB_REFLECTIONS_DELAY, env.getReflectDelay());
|
|
|
+ alEffectf(reverbFx, AL.AL_REVERB_REFLECTIONS_DELAY, env.getReflectDelay());
|
|
|
+ //EFX10.alEffectf(reverbFx, EFX10.AL_REVERB_LATE_REVERB_GAIN, env.getLateReverbGain());
|
|
|
+ alEffectf(reverbFx, AL.AL_REVERB_LATE_REVERB_GAIN, env.getLateReverbGain());
|
|
|
+ //EFX10.alEffectf(reverbFx, EFX10.AL_REVERB_LATE_REVERB_DELAY, env.getLateReverbDelay());
|
|
|
+ alEffectf(reverbFx, AL.AL_REVERB_LATE_REVERB_DELAY, env.getLateReverbDelay());
|
|
|
+ //EFX10.alEffectf(reverbFx, EFX10.AL_REVERB_AIR_ABSORPTION_GAINHF, env.getAirAbsorbGainHf());
|
|
|
+ alEffectf(reverbFx, AL.AL_REVERB_AIR_ABSORPTION_GAINHF, env.getAirAbsorbGainHf());
|
|
|
+ //EFX10.alEffectf(reverbFx, EFX10.AL_REVERB_ROOM_ROLLOFF_FACTOR, env.getRoomRolloffFactor());
|
|
|
+ alEffectf(reverbFx, AL.AL_REVERB_ROOM_ROLLOFF_FACTOR, env.getRoomRolloffFactor());
|
|
|
+
|
|
|
+ // attach effect to slot
|
|
|
+ //EFX10.alAuxiliaryEffectSloti(reverbFxSlot, EFX10.AL_EFFECTSLOT_EFFECT, reverbFx);
|
|
|
+ alAuxiliaryEffectSloti(reverbFxSlot, AL.AL_EFFECTSLOT_EFFECT, reverbFx);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private boolean fillBuffer(AudioStream stream, int id) {
|
|
|
+ int size = 0;
|
|
|
+ int result;
|
|
|
+
|
|
|
+ while (size < arrayBuf.length) {
|
|
|
+ result = stream.readSamples(arrayBuf, size, arrayBuf.length - size);
|
|
|
+
|
|
|
+ if (result > 0) {
|
|
|
+ size += result;
|
|
|
+ } else {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (size == 0) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ nativeBuf.clear();
|
|
|
+ nativeBuf.put(arrayBuf, 0, size);
|
|
|
+ nativeBuf.flip();
|
|
|
+
|
|
|
+ //alBufferData(id, convertFormat(stream), nativeBuf, stream.getSampleRate());
|
|
|
+ alBufferData(id, convertFormat(stream), nativeBuf, size, stream.getSampleRate());
|
|
|
+ checkError(true);
|
|
|
+
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ private boolean fillStreamingSource(int sourceId, AudioStream stream) {
|
|
|
+ if (!stream.isOpen()) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ boolean active = true;
|
|
|
+ //int processed = alGetSourcei(sourceId, AL_BUFFERS_PROCESSED);
|
|
|
+ int processed = alGetSourcei(sourceId, AL.AL_BUFFERS_PROCESSED);
|
|
|
+ checkError(true);
|
|
|
+
|
|
|
+ //while((processed--) != 0){
|
|
|
+ if (processed > 0) {
|
|
|
+ int buffer;
|
|
|
+
|
|
|
+ ib.position(0).limit(1);
|
|
|
+ //alSourceUnqueueBuffers(sourceId, ib);
|
|
|
+ alSourceUnqueueBuffers(sourceId, 1, ib);
|
|
|
+ checkError(true);
|
|
|
+ buffer = ib.get(0);
|
|
|
+
|
|
|
+ active = fillBuffer(stream, buffer);
|
|
|
+
|
|
|
+ ib.position(0).limit(1);
|
|
|
+ ib.put(0, buffer);
|
|
|
+ //alSourceQueueBuffers(sourceId, ib);
|
|
|
+ alSourceQueueBuffers(sourceId, 1, ib);
|
|
|
+ checkError(true);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!active && stream.isOpen()) {
|
|
|
+ stream.close();
|
|
|
+ }
|
|
|
+
|
|
|
+ return active;
|
|
|
+ }
|
|
|
+
|
|
|
+ private boolean attachStreamToSource(int sourceId, AudioStream stream) {
|
|
|
+ boolean active = true;
|
|
|
+ int activeBufferCount = 0;
|
|
|
+ for (int id : stream.getIds()) {
|
|
|
+ active = fillBuffer(stream, id);
|
|
|
+ ib.position(0).limit(1);
|
|
|
+ ib.put(id).flip();
|
|
|
+ //alSourceQueueBuffers(sourceId, ib);
|
|
|
+ // OpenAL Soft does not like 0 size buffer data in alSourceQueueBuffers
|
|
|
+ // Produces error code 40964 (0xA004) = AL_INVALID_OPERATION and
|
|
|
+ // does not return (crashes) so that the error code can be checked.
|
|
|
+ // active is FALSE when the data size is 0
|
|
|
+ if (active) {
|
|
|
+ alSourceQueueBuffers(sourceId, 1, ib);
|
|
|
+ checkError(true);
|
|
|
+ activeBufferCount++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // adjust the steam id array if the audio data is smaller than STREAMING_BUFFER_COUNT
|
|
|
+ // this is to avoid an error with OpenAL Soft when alSourceUnenqueueBuffers
|
|
|
+ // is called with more buffers than were originally used with alSourceQueueBuffers
|
|
|
+ if (activeBufferCount < STREAMING_BUFFER_COUNT) {
|
|
|
+ int[] newIds = new int[activeBufferCount];
|
|
|
+ for (int i=0; i<STREAMING_BUFFER_COUNT; i++) {
|
|
|
+ if (i < activeBufferCount) {
|
|
|
+ newIds[i] = stream.getIds()[i];
|
|
|
+ } else {
|
|
|
+ ib.clear();
|
|
|
+ ib.put(stream.getIds()[i]).limit(1).flip();
|
|
|
+ alDeleteBuffers(1, ib);
|
|
|
+ checkError(true);
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+ stream.setIds(newIds);
|
|
|
+ }
|
|
|
+
|
|
|
+ return active;
|
|
|
+ }
|
|
|
+
|
|
|
+ private boolean attachBufferToSource(int sourceId, AudioBuffer buffer) {
|
|
|
+ //alSourcei(sourceId, AL_BUFFER, buffer.getId());
|
|
|
+ alSourcei(sourceId, AL.AL_BUFFER, buffer.getId());
|
|
|
+ checkError(true);
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ private boolean attachAudioToSource(int sourceId, AudioData data) {
|
|
|
+ if (data instanceof AudioBuffer) {
|
|
|
+ return attachBufferToSource(sourceId, (AudioBuffer) data);
|
|
|
+ } else if (data instanceof AudioStream) {
|
|
|
+ return attachStreamToSource(sourceId, (AudioStream) data);
|
|
|
+ }
|
|
|
+ throw new UnsupportedOperationException();
|
|
|
+ }
|
|
|
+
|
|
|
+ private void clearChannel(int index) {
|
|
|
+ // make room at this channel
|
|
|
+ if (chanSrcs[index] != null) {
|
|
|
+ AudioSource src = chanSrcs[index];
|
|
|
+
|
|
|
+ int sourceId = channels[index];
|
|
|
+ alSourceStop(sourceId);
|
|
|
+
|
|
|
+ if (src.getAudioData() instanceof AudioStream) {
|
|
|
+ AudioStream str = (AudioStream) src.getAudioData();
|
|
|
+ for (int i=0; i<str.getIds().length; i++) {
|
|
|
+ }
|
|
|
+ //ib.position(0).limit(STREAMING_BUFFER_COUNT);
|
|
|
+ ib.position(0).limit(str.getIds().length);
|
|
|
+ ib.put(str.getIds()).flip();
|
|
|
+ int processed = alGetSourcei(sourceId, AL.AL_BUFFERS_PROCESSED);
|
|
|
+ //alSourceUnqueueBuffers(sourceId, ib);
|
|
|
+ alSourceUnqueueBuffers(sourceId, processed, ib);
|
|
|
+ checkError(true);
|
|
|
+ } else if (src.getAudioData() instanceof AudioBuffer) {
|
|
|
+ //alSourcei(sourceId, AL_BUFFER, 0);
|
|
|
+ alSourcei(sourceId, AL.AL_BUFFER, 0);
|
|
|
+ checkError(true);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (src.getDryFilter() != null && supportEfx) {
|
|
|
+ // detach filter
|
|
|
+ //alSourcei(sourceId, EFX10.AL_DIRECT_FILTER, EFX10.AL_FILTER_NULL);
|
|
|
+ alSourcei(sourceId, AL.AL_DIRECT_FILTER, AL.AL_FILTER_NULL);
|
|
|
+ }
|
|
|
+ if (src.isPositional()) {
|
|
|
+ AudioSource pas = (AudioSource) src;
|
|
|
+ if (pas.isReverbEnabled() && supportEfx) {
|
|
|
+ //AL11.alSource3i(sourceId, EFX10.AL_AUXILIARY_SEND_FILTER, 0, 0, EFX10.AL_FILTER_NULL);
|
|
|
+ alSource3i(sourceId, AL.AL_AUXILIARY_SEND_FILTER, 0, 0, AL.AL_FILTER_NULL);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ chanSrcs[index] = null;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void update(float tpf) {
|
|
|
+ // does nothing
|
|
|
+ }
|
|
|
+
|
|
|
+ public void updateInThread(float tpf) {
|
|
|
+ if (audioDisabled) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (int i = 0; i < channels.length; i++) {
|
|
|
+ AudioSource src = chanSrcs[i];
|
|
|
+ if (src == null) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ int sourceId = channels[i];
|
|
|
+
|
|
|
+ // is the source bound to this channel
|
|
|
+ // if false, it's an instanced playback
|
|
|
+ boolean boundSource = i == src.getChannel();
|
|
|
+
|
|
|
+ // source's data is streaming
|
|
|
+ boolean streaming = src.getAudioData() instanceof AudioStream;
|
|
|
+
|
|
|
+ // only buffered sources can be bound
|
|
|
+ assert (boundSource && streaming) || (!streaming);
|
|
|
+
|
|
|
+ //int state = alGetSourcei(sourceId, AL_SOURCE_STATE);
|
|
|
+ int state = alGetSourcei(sourceId, AL.AL_SOURCE_STATE);
|
|
|
+ checkError(true);
|
|
|
+ boolean wantPlaying = src.getStatus() == Status.Playing;
|
|
|
+ //boolean stopped = state == AL_STOPPED;
|
|
|
+ boolean stopped = state == AL.AL_STOPPED;
|
|
|
+
|
|
|
+ if (streaming && wantPlaying) {
|
|
|
+ AudioStream stream = (AudioStream) src.getAudioData();
|
|
|
+ if (stream.isOpen()) {
|
|
|
+ fillStreamingSource(sourceId, stream);
|
|
|
+ if (stopped) {
|
|
|
+ alSourcePlay(sourceId);
|
|
|
+ checkError(true);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if (stopped) {
|
|
|
+ // became inactive
|
|
|
+ src.setStatus(Status.Stopped);
|
|
|
+ src.setChannel(-1);
|
|
|
+ clearChannel(i);
|
|
|
+ freeChannel(i);
|
|
|
+
|
|
|
+ // And free the audio since it cannot be
|
|
|
+ // played again anyway.
|
|
|
+ deleteAudioData(stream);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else if (!streaming) {
|
|
|
+ //boolean paused = state == AL_PAUSED;
|
|
|
+ boolean paused = state == AL.AL_PAUSED;
|
|
|
+
|
|
|
+ // make sure OAL pause state & source state coincide
|
|
|
+ assert (src.getStatus() == Status.Paused && paused) || (!paused);
|
|
|
+
|
|
|
+ if (stopped) {
|
|
|
+ if (boundSource) {
|
|
|
+ src.setStatus(Status.Stopped);
|
|
|
+ src.setChannel(-1);
|
|
|
+ }
|
|
|
+ clearChannel(i);
|
|
|
+ freeChannel(i);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Delete any unused objects.
|
|
|
+ objManager.deleteUnused(this);
|
|
|
+ }
|
|
|
+
|
|
|
+ public void setListener(Listener listener) {
|
|
|
+ checkDead();
|
|
|
+ synchronized (threadLock) {
|
|
|
+ while (!threadLock.get()) {
|
|
|
+ try {
|
|
|
+ threadLock.wait();
|
|
|
+ } catch (InterruptedException ex) {
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (audioDisabled) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (this.listener != null) {
|
|
|
+ // previous listener no longer associated with current
|
|
|
+ // renderer
|
|
|
+ this.listener.setRenderer(null);
|
|
|
+ }
|
|
|
+
|
|
|
+ this.listener = listener;
|
|
|
+ this.listener.setRenderer(this);
|
|
|
+ setListenerParams(listener);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void playSourceInstance(AudioSource src) {
|
|
|
+ checkDead();
|
|
|
+ synchronized (threadLock) {
|
|
|
+ while (!threadLock.get()) {
|
|
|
+ try {
|
|
|
+ threadLock.wait();
|
|
|
+ } catch (InterruptedException ex) {
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (audioDisabled) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (src.getAudioData() instanceof AudioStream) {
|
|
|
+ throw new UnsupportedOperationException(
|
|
|
+ "Cannot play instances "
|
|
|
+ + "of audio streams. Use playSource() instead.");
|
|
|
+ }
|
|
|
+
|
|
|
+ if (src.getAudioData().isUpdateNeeded()) {
|
|
|
+ updateAudioData(src.getAudioData());
|
|
|
+ }
|
|
|
+
|
|
|
+ // create a new index for an audio-channel
|
|
|
+ int index = newChannel();
|
|
|
+ if (index == -1) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ int sourceId = channels[index];
|
|
|
+
|
|
|
+ clearChannel(index);
|
|
|
+
|
|
|
+ // set parameters, like position and max distance
|
|
|
+ setSourceParams(sourceId, src, true);
|
|
|
+ attachAudioToSource(sourceId, src.getAudioData());
|
|
|
+ chanSrcs[index] = src;
|
|
|
+
|
|
|
+ // play the channel
|
|
|
+ alSourcePlay(sourceId);
|
|
|
+ checkError(true);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void playSource(AudioSource src) {
|
|
|
+ checkDead();
|
|
|
+ synchronized (threadLock) {
|
|
|
+ while (!threadLock.get()) {
|
|
|
+ try {
|
|
|
+ threadLock.wait();
|
|
|
+ } catch (InterruptedException ex) {
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (audioDisabled) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ //assert src.getStatus() == Status.Stopped || src.getChannel() == -1;
|
|
|
+
|
|
|
+ if (src.getStatus() == Status.Playing) {
|
|
|
+ return;
|
|
|
+ } else if (src.getStatus() == Status.Stopped) {
|
|
|
+
|
|
|
+ // allocate channel to this source
|
|
|
+ int index = newChannel();
|
|
|
+ if (index == -1) {
|
|
|
+ logger.log(Level.WARNING, "No channel available to play {0}", src);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ clearChannel(index);
|
|
|
+ src.setChannel(index);
|
|
|
+
|
|
|
+ AudioData data = src.getAudioData();
|
|
|
+ if (data.isUpdateNeeded()) {
|
|
|
+ updateAudioData(data);
|
|
|
+ }
|
|
|
+
|
|
|
+ chanSrcs[index] = src;
|
|
|
+ setSourceParams(channels[index], src, false);
|
|
|
+ attachAudioToSource(channels[index], data);
|
|
|
+ }
|
|
|
+
|
|
|
+ alSourcePlay(channels[src.getChannel()]);
|
|
|
+ checkError(true);
|
|
|
+ src.setStatus(Status.Playing);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void pauseSource(AudioSource src) {
|
|
|
+ checkDead();
|
|
|
+ synchronized (threadLock) {
|
|
|
+ while (!threadLock.get()) {
|
|
|
+ try {
|
|
|
+ threadLock.wait();
|
|
|
+ } catch (InterruptedException ex) {
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (audioDisabled) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (src.getStatus() == Status.Playing) {
|
|
|
+ assert src.getChannel() != -1;
|
|
|
+
|
|
|
+ alSourcePause(channels[src.getChannel()]);
|
|
|
+ checkError(true);
|
|
|
+ src.setStatus(Status.Paused);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void stopSource(AudioSource src) {
|
|
|
+ synchronized (threadLock) {
|
|
|
+ while (!threadLock.get()) {
|
|
|
+ try {
|
|
|
+ threadLock.wait();
|
|
|
+ } catch (InterruptedException ex) {
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (audioDisabled) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (src.getStatus() != Status.Stopped) {
|
|
|
+ int chan = src.getChannel();
|
|
|
+ assert chan != -1; // if it's not stopped, must have id
|
|
|
+
|
|
|
+ src.setStatus(Status.Stopped);
|
|
|
+ src.setChannel(-1);
|
|
|
+ clearChannel(chan);
|
|
|
+ freeChannel(chan);
|
|
|
+
|
|
|
+ if (src.getAudioData() instanceof AudioStream) {
|
|
|
+ AudioStream stream = (AudioStream) src.getAudioData();
|
|
|
+ if (stream.isOpen()) {
|
|
|
+ stream.close();
|
|
|
+ }
|
|
|
+
|
|
|
+ // And free the audio since it cannot be
|
|
|
+ // played again anyway.
|
|
|
+ deleteAudioData(src.getAudioData());
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private int convertFormat(AudioData ad) {
|
|
|
+ switch (ad.getBitsPerSample()) {
|
|
|
+ case 8:
|
|
|
+ if (ad.getChannels() == 1) {
|
|
|
+ //return AL_FORMAT_MONO8;
|
|
|
+ return AL.AL_FORMAT_MONO8;
|
|
|
+ } else if (ad.getChannels() == 2) {
|
|
|
+ //return AL_FORMAT_STEREO8;
|
|
|
+ return AL.AL_FORMAT_STEREO8;
|
|
|
+ }
|
|
|
+
|
|
|
+ break;
|
|
|
+ case 16:
|
|
|
+ if (ad.getChannels() == 1) {
|
|
|
+ //return AL_FORMAT_MONO16;
|
|
|
+ return AL.AL_FORMAT_MONO16;
|
|
|
+ } else {
|
|
|
+ //return AL_FORMAT_STEREO16;
|
|
|
+ return AL.AL_FORMAT_STEREO16;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ throw new UnsupportedOperationException("Unsupported channels/bits combination: "
|
|
|
+ + "bits=" + ad.getBitsPerSample() + ", channels=" + ad.getChannels());
|
|
|
+ }
|
|
|
+
|
|
|
+ private void updateAudioBuffer(AudioBuffer ab) {
|
|
|
+ int id = ab.getId();
|
|
|
+ if (ab.getId() == -1) {
|
|
|
+ ib.position(0).limit(1);
|
|
|
+ alGenBuffers(1, ib);
|
|
|
+ checkError(true);
|
|
|
+ id = ib.get(0);
|
|
|
+ ab.setId(id);
|
|
|
+
|
|
|
+ objManager.registerObject(ab);
|
|
|
+ }
|
|
|
+
|
|
|
+ ab.getData().clear();
|
|
|
+ //alBufferData(id, convertFormat(ab), ab.getData(), ab.getSampleRate());
|
|
|
+ alBufferData(id, convertFormat(ab), ab.getData(), ab.getData().limit(), ab.getSampleRate());
|
|
|
+ checkError(true);
|
|
|
+ ab.clearUpdateNeeded();
|
|
|
+ }
|
|
|
+
|
|
|
+ private void updateAudioStream(AudioStream as) {
|
|
|
+ if (as.getIds() != null) {
|
|
|
+ deleteAudioData(as);
|
|
|
+ }
|
|
|
+
|
|
|
+ int[] ids = new int[STREAMING_BUFFER_COUNT];
|
|
|
+ ib.position(0).limit(STREAMING_BUFFER_COUNT);
|
|
|
+ //alGenBuffers(ib);
|
|
|
+ alGenBuffers(STREAMING_BUFFER_COUNT, ib);
|
|
|
+ checkError(true);
|
|
|
+ ib.position(0).limit(STREAMING_BUFFER_COUNT);
|
|
|
+ ib.get(ids);
|
|
|
+
|
|
|
+ // Not registered with object manager.
|
|
|
+ // AudioStreams can be handled without object manager
|
|
|
+ // since their lifecycle is known to the audio renderer.
|
|
|
+
|
|
|
+ as.setIds(ids);
|
|
|
+ as.clearUpdateNeeded();
|
|
|
+ }
|
|
|
+
|
|
|
+ private void updateAudioData(AudioData ad) {
|
|
|
+ if (ad instanceof AudioBuffer) {
|
|
|
+ updateAudioBuffer((AudioBuffer) ad);
|
|
|
+ } else if (ad instanceof AudioStream) {
|
|
|
+ updateAudioStream((AudioStream) ad);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void deleteFilter(Filter filter) {
|
|
|
+ int id = filter.getId();
|
|
|
+ if (id != -1) {
|
|
|
+ //EFX10.alDeleteFilters(id);
|
|
|
+ ib.put(0, id);
|
|
|
+ ib.position(0).limit(1);
|
|
|
+ alDeleteFilters(1, ib);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void deleteAudioData(AudioData ad) {
|
|
|
+ synchronized (threadLock) {
|
|
|
+ while (!threadLock.get()) {
|
|
|
+ try {
|
|
|
+ threadLock.wait();
|
|
|
+ } catch (InterruptedException ex) {
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (audioDisabled) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (ad instanceof AudioBuffer) {
|
|
|
+ AudioBuffer ab = (AudioBuffer) ad;
|
|
|
+ int id = ab.getId();
|
|
|
+ if (id != -1) {
|
|
|
+ ib.put(0, id);
|
|
|
+ ib.position(0).limit(1);
|
|
|
+ //alDeleteBuffers(ib);
|
|
|
+ alDeleteBuffers(1, ib);
|
|
|
+ checkError(true);
|
|
|
+ ab.resetObject();
|
|
|
+ }
|
|
|
+ } else if (ad instanceof AudioStream) {
|
|
|
+ AudioStream as = (AudioStream) ad;
|
|
|
+ int[] ids = as.getIds();
|
|
|
+ if (ids != null) {
|
|
|
+ ib.clear();
|
|
|
+ ib.put(ids).flip();
|
|
|
+ //alDeleteBuffers(ib);
|
|
|
+ alDeleteBuffers(ids.length, ib);
|
|
|
+ checkError(true);
|
|
|
+ as.resetObject();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void pauseAll() {
|
|
|
+ // don't try to pause all audio (mainly from Android activity) if
|
|
|
+ // the renderer is already closed down
|
|
|
+ if (!initialized) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ checkDead();
|
|
|
+ synchronized (threadLock) {
|
|
|
+ while (!threadLock.get()) {
|
|
|
+ try {
|
|
|
+ threadLock.wait();
|
|
|
+ } catch (InterruptedException ex) {
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (audioDisabled) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (int i = 0; i < channels.length; i++) {
|
|
|
+ AudioSource src = chanSrcs[i];
|
|
|
+ if (src == null) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (src.getStatus() == Status.Playing) {
|
|
|
+ assert src.getChannel() != -1;
|
|
|
+
|
|
|
+ logger.log(Level.FINE, "Pausing Source: {0}", src.getChannel());
|
|
|
+ alSourcePause(channels[src.getChannel()]);
|
|
|
+ checkError(true);
|
|
|
+ src.setStatus(Status.Paused);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void resumeAll() {
|
|
|
+ checkDead();
|
|
|
+ synchronized (threadLock) {
|
|
|
+ while (!threadLock.get()) {
|
|
|
+ try {
|
|
|
+ threadLock.wait();
|
|
|
+ } catch (InterruptedException ex) {
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (audioDisabled) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (int i = 0; i < channels.length; i++) {
|
|
|
+ AudioSource src = chanSrcs[i];
|
|
|
+ if (src == null) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (src.getStatus() == Status.Paused) {
|
|
|
+ assert src.getChannel() != -1;
|
|
|
+
|
|
|
+ logger.log(Level.FINE, "Playing/Resuming Source: {0}", src.getChannel());
|
|
|
+ alSourcePlay(channels[src.getChannel()]);
|
|
|
+ checkError(true);
|
|
|
+ src.setStatus(Status.Playing);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private int checkError(boolean stopOnError) {
|
|
|
+ int errorCode = alGetError();
|
|
|
+ String errorText = AL.GetALErrorMsg(errorCode);
|
|
|
+
|
|
|
+ if (errorCode != AL.AL_NO_ERROR && stopOnError) {
|
|
|
+ throw new IllegalStateException("AL Error Detected. Error Code: " + errorCode + ": " + errorText);
|
|
|
+ }
|
|
|
+
|
|
|
+ return errorCode;
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Native methods, implemented in jni folder */
|
|
|
+ public static native boolean alIsCreated();
|
|
|
+ public static native boolean alCreate();
|
|
|
+ public static native boolean alDestroy();
|
|
|
+ public static native String alcGetString(int parameter);
|
|
|
+ public static native String alGetString(int parameter);
|
|
|
+ public static native int alGenSources();
|
|
|
+ public static native int alGetError();
|
|
|
+ public static native void alDeleteSources(int numSources, IntBuffer sources);
|
|
|
+ public static native void alGenBuffers(int numBuffers, IntBuffer buffers);
|
|
|
+ public static native void alDeleteBuffers(int numBuffers, IntBuffer buffers);
|
|
|
+ public static native void alSourceStop(int source);
|
|
|
+ public static native void alSourcei(int source, int param, int value);
|
|
|
+ public static native void alBufferData(int buffer, int format, ByteBuffer data, int size, int frequency);
|
|
|
+ public static native void alSourcePlay(int source);
|
|
|
+ public static native void alSourcePause(int source);
|
|
|
+ public static native void alSourcef(int source, int param, float value);
|
|
|
+ public static native void alSource3f(int source, int param, float value1, float value2, float value3);
|
|
|
+ public static native int alGetSourcei(int source, int param);
|
|
|
+ public static native void alSourceUnqueueBuffers(int source, int numBuffers, IntBuffer buffers);
|
|
|
+ public static native void alSourceQueueBuffers(int source, int numBuffers, IntBuffer buffers);
|
|
|
+ public static native void alListener(int param, FloatBuffer data);
|
|
|
+ public static native void alListenerf(int param, float value);
|
|
|
+ public static native void alListener3f(int param, float value1, float value2, float value3);
|
|
|
+ public static native boolean alcIsExtensionPresent(String extension);
|
|
|
+ public static native void alcGetInteger(int param, IntBuffer buffer, int size);
|
|
|
+ public static native void alGenAuxiliaryEffectSlots(int numSlots, IntBuffer buffers);
|
|
|
+ public static native void alGenEffects(int numEffects, IntBuffer buffers);
|
|
|
+ public static native void alEffecti(int effect, int param, int value);
|
|
|
+ public static native void alAuxiliaryEffectSloti(int effectSlot, int param, int value);
|
|
|
+ public static native void alDeleteEffects(int numEffects, IntBuffer buffers);
|
|
|
+ public static native void alDeleteAuxiliaryEffectSlots(int numEffectSlots, IntBuffer buffers);
|
|
|
+ public static native void alGenFilters(int numFilters, IntBuffer buffers);
|
|
|
+ public static native void alFilteri(int filter, int param, int value);
|
|
|
+ public static native void alFilterf(int filter, int param, float value);
|
|
|
+ public static native void alSource3i(int source, int param, int value1, int value2, int value3);
|
|
|
+ public static native void alDeleteFilters(int numFilters, IntBuffer buffers);
|
|
|
+ public static native void alEffectf(int effect, int param, float value);
|
|
|
+
|
|
|
+ /** Load jni .so on initialization */
|
|
|
+ static {
|
|
|
+// System.loadLibrary("openalsoftjme");
|
|
|
+ }
|
|
|
+
|
|
|
+}
|
nor..67