package com.aurellem.capture;

 

 import java.lang.reflect.Field;

 import java.nio.ByteBuffer;

 import java.util.HashMap;

 import java.util.Vector;

 import java.util.concurrent.CountDownLatch;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 

 import org.lwjgl.LWJGLException;

 import org.lwjgl.openal.AL;

 import org.lwjgl.openal.AL10;

 import org.lwjgl.openal.ALCdevice;

 import org.lwjgl.openal.OpenALException;

 

 import com.jme3.audio.Listener;

 import com.jme3.audio.lwjgl.LwjglAudioRenderer;

 import com.jme3.math.Vector3f;

 import com.jme3.util.BufferUtils;

 

 public class AudioSend 

 	extends LwjglAudioRenderer implements MultiListener {

 

 	/**

 	 * Keeps track of all the listeners which have been registered so far.

 	 * The first element is <code>null</code>, which represents the zeroth 

 	 * LWJGL listener which is created automatically.

 	 */

 	public Vector<Listener> listeners = new Vector<Listener>();

 	

 	public void initialize(){

 		super.initialize();

 		listeners.add(null);

 	}

 	

 	/**

 	 * This is to call the native methods which require the OpenAL device ID.

 	 * currently it is obtained through reflection.

 	 */

 	private long deviceID;

 	

 	/**

 	 * To ensure that <code>deviceID<code> and <code>listeners<code> are 

 	 * properly initialized before any additional listeners are added.

 	 */

 	private CountDownLatch latch  = new CountDownLatch(1);

 	

 	private void waitForInit(){

 		try {latch.await();} 

 		catch (InterruptedException e) {e.printStackTrace();}

 	}

 	

 	/**

 	 * Each listener (including the main LWJGL listener) can be registered

 	 * with a <code>SoundProcessor</code>, which this Renderer will call whenever 

 	 * there is new audio data to be processed.

 	 */

 	public HashMap<Listener, SoundProcessor> soundProcessorMap =

 		new HashMap<Listener, SoundProcessor>();

 	

 		

 	/**

 	 * Create a new slave context on the recorder device which will render all the 

 	 * sounds in the main LWJGL context with respect to this listener.

 	 */

 	public void addListener(Listener l) {

 		try {this.latch.await();} 

 		catch (InterruptedException e) {e.printStackTrace();}

 		this.addListener();

 		this.listeners.add(l);

 	}

 	

 	/**

 	 * Whenever new data is rendered in the perspective of this listener, 

 	 * this Renderer will send that data to the SoundProcessor of your choosing.

 	 */

 	public void registerSoundProcessor(Listener l, SoundProcessor sp) {

 		this.soundProcessorMap.put(l, sp);

 	}

 	

 	/**

 	 * Registers a SoundProcessor for the main LWJGL context. IF all you want to 

 	 * do is record the sound you would normally hear in your application, then 

 	 * this is the only method you have to worry about.

 	 */

 	public void registerSoundProcessor(SoundProcessor sp){

 		// register a sound processor for the default listener.

 		this.soundProcessorMap.put(null, sp);		

 	}

 		

 	private static final Logger logger = 

 		Logger.getLogger(AudioSend.class.getName());

 

 	

 	////////////   Native Methods

 	

 	/** This establishes the LWJGL context as the context which will be copies to all 

 	 *  other contexts.  It must be called before any calls to <code>addListener();</code>

 	 */

 	public void initDevice(){

 		ninitDevice(this.deviceID);}

 	public static native void ninitDevice(long device);

 	

 	/**

 	 * The send device does not automatically process sound.  This step function will cause 

 	 * the desired number of samples to be processed for each listener.  The results will then 

 	 * be available via calls to <code>getSamples()</code> for each listener.

 	 * @param samples

 	 */

 	public void step(int samples){

 		nstep(this.deviceID, samples);}

 	public static native void nstep(long device, int samples);

 

 	/**

 	 * Retrieve the final rendered sound for a particular listener.  <code>contextNum == 0</code>

 	 * is the main LWJGL context.

 	 * @param buffer

 	 * @param samples

 	 * @param contextNum

 	 */

 	public void getSamples(ByteBuffer buffer, int samples, int contextNum){

 		ngetSamples(this.deviceID, buffer, buffer.position(), samples, contextNum);}

 	public static native void ngetSamples(

 			long device, ByteBuffer buffer, int position, int samples, int contextNum);

 	

 	/**

 	 * Create an additional listener on the recorder device.  The device itself will manage 

 	 * this listener and synchronize it with the main LWJGL context. Processed sound samples

 	 * for this listener will be available via a call to <code>getSamples()</code> with 

 	 * <code>contextNum</code> equal to the number of times this method has been called. 

 	 */

 	public void addListener(){naddListener(this.deviceID);}

 	public static native void naddListener(long device);

 	

 	/**

 	 * This will internally call <code>alListener3f<code> in the appropriate slave context and update

 	 * that context's listener's parameters. Calling this for a number greater than the current 

 	 * number of slave contexts will have no effect.

 	 * @param pname

 	 * @param v1

 	 * @param v2

 	 * @param v3

 	 * @param contextNum

 	 */

 	public void setNthListener3f(int pname, float v1, float v2, float v3, int contextNum){

 		nsetNthListener3f(pname, v1, v2, v3, this.deviceID, contextNum);}

 	public static native void 

 	nsetNthListener3f(int pname, float v1, float v2, float v3, long device, int contextNum);

 	

 	/**

 	 * This will internally call <code>alListenerf<code> in the appropriate slave context and update

 	 * that context's listener's parameters. Calling this for a number greater than the current 

 	 * number of slave contexts will have no effect.

 	 * @param pname

 	 * @param v1

 	 * @param contextNum

 	 */

 	public void setNthListenerf(int pname, float v1, int contextNum){

 		nsetNthListenerf(pname, v1, this.deviceID, contextNum);}

 	public static native void nsetNthListenerf(int pname, float v1, long device, int contextNum);

 	

 	/**

 	 * Instead of taking whatever device is available on the system, this call 

 	 * creates the "Multiple Audio Send" device, which supports multiple listeners in a limited

 	 * capacity.  For each listener, the device renders it not to the sound device, but

 	 * instead to buffers which it makes available via JNI.

 	 */

 	public void initInThread(){

 		try{

             if (!AL.isCreated()){

                 AL.create("Multiple Audio Send", 44100, 60, false);

             }

         }catch (OpenALException ex){

             logger.log(Level.SEVERE, "Failed to load audio library", ex);

             System.exit(1);

             return;

         }catch (LWJGLException ex){

             logger.log(Level.SEVERE, "Failed to load audio library", ex);

             System.exit(1);

             return;

         }

 		super.initInThread();

 

 		ALCdevice device = AL.getDevice();

 

 		// RLM: use reflection to grab the ID of our device for use later.

 		try {

 			Field deviceIDField;

 			deviceIDField = ALCdevice.class.getDeclaredField("device");

 			deviceIDField.setAccessible(true);

 			try {deviceID = (Long)deviceIDField.get(device);} 

 			catch (IllegalArgumentException e) {e.printStackTrace();} 

 			catch (IllegalAccessException e) {e.printStackTrace();}

 			deviceIDField.setAccessible(false);} 

 		catch (SecurityException e) {e.printStackTrace();} 

 		catch (NoSuchFieldException e) {e.printStackTrace();}

 		

 		// the LWJGL context must be established as the master context before 

 		// any other listeners can be created on this device.

 		initDevice();

 		// Now, everything is initialized, and it is safe to add more listeners.

 		latch.countDown();

 	}

 

 	

 	public void cleanup(){

 		for(SoundProcessor sp : this.soundProcessorMap.values()){

 			sp.cleanup();

 		}

 		super.cleanup();

 	}

 	

 	public void updateAllListeners(){

 		for (int i = 0; i < this.listeners.size(); i++){

 			Listener lis = this.listeners.get(i);

 			if (null != lis){

 				Vector3f location = lis.getLocation();

 				Vector3f velocity = lis.getVelocity();

 				Vector3f orientation = lis.getUp();

 				float gain = lis.getVolume();

 				setNthListener3f(AL10.AL_POSITION, 

 						location.x, location.y, location.z, i);

 				setNthListener3f(AL10.AL_VELOCITY, 

 						velocity.x, velocity.y, velocity.z, i);

 				setNthListener3f(AL10.AL_ORIENTATION,

 						orientation.x, orientation.y, orientation.z, i);

 				setNthListenerf(AL10.AL_GAIN, gain, i);

 			}

 		}

 	}

 	

 	

 	public final static int BYTES_PER_SAMPLE = 4;

 	private ByteBuffer buffer = BufferUtils.createByteBuffer(4096); 

 	

 	public void dispatchAudio(float tpf){

 		int samplesToGet = (int) (tpf * 44100);

 		try {latch.await();} 

 		catch (InterruptedException e) {e.printStackTrace();}

 		step(samplesToGet);

 		updateAllListeners();

 		

 		for (int i = 0; i < this.listeners.size(); i++){		

 			buffer.clear();

 			this.getSamples(buffer, samplesToGet, i);

 			SoundProcessor sp = 

 			this.soundProcessorMap.get(this.listeners.get(i));

 			if (null != sp){sp.process(buffer, samplesToGet*BYTES_PER_SAMPLE);}

 		}

 		

 	}

 		

 	public void update(float tpf){

 		super.update(tpf);

         dispatchAudio(tpf);

 	}

 	

 }