package com.aurellem.capture.audio;

 

 import java.io.IOException;

 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 javax.sound.sampled.AudioFormat;

 

 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.aurellem.send.AudioSend;

 import com.jme3.audio.Listener;

 import com.jme3.audio.lwjgl.LwjglAudioRenderer;

 import com.jme3.math.Vector3f;

 import com.jme3.system.JmeSystem;

 import com.jme3.system.Natives;

 import com.jme3.util.BufferUtils;

 

 public class AudioSendRenderer 

 

     extends LwjglAudioRenderer implements MultiListener {

 

     private AudioSend audioSend;

     private AudioFormat outFormat;

 	

     /**

      * 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);

 	

     /**

      * 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();}

 	audioSend.addListener();

 	this.listeners.add(l);

 	l.setRenderer(this);

     }

 	

     /**

      * 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. Ig 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(AudioSendRenderer.class.getName());

 	

     /**

      * 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{

 	    switch (JmeSystem.getPlatform()){

 	    case Windows64:

 		Natives.extractNativeLib("windows/audioSend", 

 					 "OpenAL64", true, true);

 		break;

 	    case Windows32:

 		Natives.extractNativeLib("windows/audioSend", 

 					 "OpenAL32", true, true);	

 		break;

 	    case Linux64:

 		Natives.extractNativeLib("linux/audioSend", 

 					 "openal64", true, true);

 		break;

 	    case Linux32:

 		Natives.extractNativeLib("linux/audioSend", 

 					 "openal", true, true);

 		break;

 	    }

 	}

 	catch (IOException ex) {ex.printStackTrace();}

 

 	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();}

 		

 	this.audioSend = new AudioSend(this.deviceID);

 	this.outFormat = audioSend.getAudioFormat();

 	initBuffer();

 				

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

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

 	audioSend.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();

 		audioSend.setNthListener3f

 		    (AL10.AL_POSITION, 

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

 		audioSend.setNthListener3f

 		    (AL10.AL_VELOCITY, 

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

 		audioSend.setNthListener3f

 		    (AL10.AL_ORIENTATION,

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

 		audioSend.setNthListenerf(AL10.AL_GAIN, gain, i);

 	    }

 	}

     }

 

     private ByteBuffer buffer;;

 

     public static final int MIN_FRAMERATE = 10;

 	

     private void initBuffer(){

 	int bufferSize = 

 	    (int)(this.outFormat.getSampleRate() / 

 		  ((float)MIN_FRAMERATE)) *

 	    this.outFormat.getFrameSize();

 

 	this.buffer = BufferUtils.createByteBuffer(bufferSize);

     }

 

     public void dispatchAudio(float tpf){

 		

 	int samplesToGet = (int) (tpf * outFormat.getSampleRate());

 	try {latch.await();} 

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

 	audioSend.step(samplesToGet);

 	updateAllListeners();

 

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

 	    buffer.clear();

 	    audioSend.getSamples(buffer, samplesToGet, i);

 	    SoundProcessor sp = 

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

 	    if (null != sp){

 		sp.process 

 		    (buffer, 

 		     samplesToGet*outFormat.getFrameSize(), outFormat);}

 	}

     }

 		

     public void update(float tpf){

 	super.update(tpf);

         dispatchAudio(tpf);

     }

 }