/**

  * OpenAL cross platform audio library

  * Copyright (C) 2010 by Chris Robinson

  * This library is free software; you can redistribute it and/or

  *  modify it under the terms of the GNU Library General Public

  *  License as published by the Free Software Foundation; either

  *  version 2 of the License, or (at your option) any later version.

  *

  * This library is distributed in the hope that it will be useful,

  *  but WITHOUT ANY WARRANTY; without even the implied warranty of

  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  *  Library General Public License for more details.

  *

  * You should have received a copy of the GNU Library General Public

  *  License along with this library; if not, write to the

  *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,

  *  Boston, MA  02111-1307, USA.

  * Or go to http://www.gnu.org/copyleft/lgpl.html

  */

 

 #include "config.h"

 #include <stdlib.h>

 #include "alMain.h"

 #include "AL/al.h"

 #include "AL/alc.h"

 #include "alSource.h"

 #include <jni.h>

 

 

 typedef struct record_data {

   volatile int killNow;

   ALvoid *thread;

   ALuint robert;

   

   ALvoid *mainBuffer;

   ALvoid *auxBuffer;

   ALuint size;

   

   ALuint *unPauseIDs;

   int    unPauseCount;

   ALboolean mainFull;

   ALboolean auxFull;

   ALboolean auxReady;

   ALboolean mainReady;

 

 } record_data;

 

 

 

 

 #define UNUSED(x)  (void)(x)

 #define RUNONLY(n)				\

   {static int __runonce = n;			\

     if (__runonce-- <= 0){return;}}

 

 #define RUNAT(n)				\

   {static int __runat = n;			\

     if (0 != __runat--){return;}}

 

 /// al error handling code prototypes

 

 char* GetALErrorString(ALenum err);

 char* GetALCErrorString(ALenum err);

 void printError(void);

 void init(ALCdevice *);

 void init2(ALCdevice *);

 void later(ALCdevice *);

 void every(ALCdevice *);

 void every2(ALCdevice *);

 void step(ALCdevice *);

 

 

 //synchronization

 struct record_data;

 void syncContexts(ALCcontext *, ALCcontext *);

 void syncSources(ALsource *, ALsource *, ALCcontext *, ALCcontext *);

 void pauseMainContext(struct record_data *);

 void unPauseMainContext(struct record_data *);

 void pauseAllSources(ALCcontext *);

 static void saveAux(ALCdevice *);

 static void swapInAux(ALCdevice *);

 static void saveMain(ALCdevice *);

 static void swapInMain(ALCdevice *);

 void aux_alListenerf(ALenum param, ALfloat value);

 void aux_alListener3f(ALenum param, ALfloat v1, ALfloat v2, ALfloat v3);

 

 

 //////////////

 

 

 

 // remove all the sources from all the auxContexts

 // take the mainContext and for each context, COPY

 // the sources from the main context.

 

 // render each context and make their data available.

 

 // =alGenSources= (and =alGetError=)

 // attach each source to the shared buffer using =alSourcei=

 

 

 // need to make sure in the AudioRender class that we don't do

 // anything to sources while the audio is being rendered, so make sure

 // to maintain an "isDone" state as well.

 

 // Special device which allows simulation of multiple listeners 

 // hearing the same set of sources.  Provides access to the rendered

 // data for each listener.  Designed to work with LWJGL.

 

 // first, the mainContext is the only context that is controlled by

 // LWJGL.

 

 // One context will be created for each listener that we want.

 

 // Then, at the start of each render loop, first PAUSE the sources on

 // all other contexts except the mainContext (this takes care of

 // sources in the mainContext being shut down.)

 // we will iterate through all

 // the active sources in our mainContext (the one which is controlled

 // through LWJGL), and take their sourceIDs.  For each of these IDs

 // and for each other context, we'll check some internal structure to

 // see if we've already created a corresponding source.  If that

 // source exits, we will SYNCH it with the source which belongs to the

 // mainContext. If it DOESN'T exist, we will CLONE the source from the

 // main context and establish it in the other context.

 

 // Each render loop consists of noting all of the active sources in

 // the mainContext and storing their IDs.  Then, for each context,

 // the correspondig sources to the active sources in the mainContext

 // will be set to PLAY, and all sources in all other contexts will be

 // set to PAUSE. aluMixData will be called for each context in this

 // way.

 

 // approved by KittyCat

 

 

 // CAN get id appropiate for us in the sorce-repated openal functions

 // by quering *source->source

 

 // first, do it with only two listeners, two contexts, automatically

 // created.

 

 static ALCcontext* mainContext = NULL;

 static ALCcontext* auxContext  = NULL;

 

 

 void aux_alListenerf(ALenum param, ALfloat value){

   ALCcontext *current = alcGetCurrentContext();

   alcMakeContextCurrent(auxContext);

   alListenerf(param, value);

   alcMakeContextCurrent(current);

 }

 

 void aux_alListener3f(ALenum param, ALfloat v1, ALfloat v2, ALfloat v3){

   ALCcontext *current = alcGetCurrentContext();

   alcMakeContextCurrent(auxContext);

   alListener3f(param, v1, v2, v3);

   alcMakeContextCurrent(current);

 }

 

 

 

 void pauseAllSources(ALCcontext *ctx){

   ALCcontext *current = alcGetCurrentContext();

   alcMakeContextCurrent(ctx);

   ALsource **src, **src_end;

   src     = ctx->ActiveSources;

   src_end = src + ctx->ActiveSourceCount;

   while(src != src_end){

     if (AL_PLAYING == (*src)->state){

     //if (AL_TRUE){

       ALuint source_id = (*src)->source;

       //printf("pausing ONE source\n");

       alSourcePause(source_id);

     }

     src++;

   }

   alcMakeContextCurrent(current);

 }

 

 

 void init2(ALCdevice *Device){

   UNUSED(Device);

   RUNONLY(1)

   // the mainContext only ever has a FIXED number of sources!

   // duplicate them ALL into auxContext!

   alcMakeContextCurrent(auxContext);{

     UIntMap source_map= mainContext->SourceMap;

     ALuint num_sources = source_map.size;

     ALuint newSources[num_sources];

     alGenSources(num_sources, newSources);}

   alcMakeContextCurrent(mainContext);

 

 

 }

 

 

 

   /*

 void syncSourcei(ALuint sourceID1, ALuint sourceID2, 

 		 ALCcontext *ctx1, ALCcontext *ctx2,

 		 int numParams, ALenum *params){

   ALint values[numParams];

   ALCcontext current = alcGetCurrentContext();

   // get values

   printf("getting values from source1\n");

   alcMakeContextCurrent(ctx1);

   int i;

   for(i=0; i<numParams; i++){

     alGetSourcei(sourceID1, params[i], values+i);

     printf("value is %d\n", values[i]);

     printError();

   }

   // set values

   printf("setting values of source2\n");

   alcMakeContextCurrent(ctx2);

   for (i=0; i<numParams; i++){

     alSourcei(sourceID2, params[i], values[i]);

     printError();

   }

   alcMakeContextCurrent(current);

   printError();

 }

   */

 

 

 #define _MAKE_SYNC(NAME, INIT_EXPR, GET_EXPR, SET_EXPR)	\

   void NAME (ALuint sourceID1, ALuint sourceID2,	\

 	     ALCcontext *ctx1, ALCcontext *ctx2,	\

 	     ALenum param){				\

     INIT_EXPR;						\

     ALCcontext *current = alcGetCurrentContext();	\

     alcMakeContextCurrent(ctx1);			\

     GET_EXPR;						\

     /*printError();*/					\

     alcMakeContextCurrent(ctx2);			\

     SET_EXPR;						\

     /*printError();*/					\

     alcMakeContextCurrent(current);			\

   }

   

 #define MAKE_SYNC(NAME, TYPE, GET, SET)			\

   _MAKE_SYNC(NAME,					\

 	     TYPE value,				\

              GET(sourceID1, param, &value),		\

              SET(sourceID2, param, value))

   

 #define MAKE_SYNC3(NAME, TYPE, GET, SET)				\

   _MAKE_SYNC(NAME,							\

 	     TYPE value1; TYPE value2; TYPE value3;,			\

 	     GET(sourceID1, param, &value1, &value2, &value3),		\

 	     SET(sourceID2, param,  value1,  value2,  value3))

 

 MAKE_SYNC( syncSourcei,  ALint,   alGetSourcei,  alSourcei);

 MAKE_SYNC( syncSourcef,  ALfloat, alGetSourcef,  alSourcef);

 MAKE_SYNC3(syncSource3i, ALint,   alGetSource3i, alSource3i);

 MAKE_SYNC3(syncSource3f, ALfloat, alGetSource3f, alSource3f);

   

 

 

 

   

 

 #define DsyncSourcei(sourceID1, sourceID2, ctx1, ctx2, param)	\

   {/*printf("synci : " #param "\n");*/				\

     syncSourcei(sourceID1, sourceID2, ctx1, ctx2, param);}

 

 #define DsyncSourcef(sourceID1, sourceID2, ctx1, ctx2, param)	\

   {/*printf("syncf : " #param "\n");*/				\

     syncSourcef(sourceID1, sourceID2, ctx1, ctx2, param);}

 

 #define DsyncSource3i(sourceID1, sourceID2, ctx1, ctx2, param)	\

   {/*printf("sync3i : " #param "\n");*/				\

     syncSource3i(sourceID1, sourceID2, ctx1, ctx2, param);}

 

 #define DsyncSource3f(sourceID1, sourceID2, ctx1, ctx2, param)	\

   {/*printf("sync3f : " #param "\n");*/				\

     syncSource3f(sourceID1, sourceID2, ctx1, ctx2, param);}

 

 void printValid(ALuint sourceID){

   alcMakeContextCurrent(auxContext);

   printf("source%d : %s\n", sourceID, alIsSource(sourceID) ? "VALID" : "INVALID");

   alcMakeContextCurrent(mainContext);

 }

 

 

 

 void syncSources(ALsource *source1, ALsource *source2, 

 		 ALCcontext *ctx1, ALCcontext *ctx2){

 

   ALuint ID1 = source1->source;

   ALuint ID2 = source2->source;

   ALCcontext *current = alcGetCurrentContext();

   //printf("***************\n");

   //printf("SYNCHING source %d with source %d\n", ID1, ID2);

   

   DsyncSourcef(ID1,ID2,ctx1,ctx2,AL_PITCH);

   DsyncSourcef(ID1,ID2,ctx1,ctx2,AL_GAIN);

   DsyncSourcef(ID1,ID2,ctx1,ctx2,AL_MAX_DISTANCE);

   DsyncSourcef(ID1,ID2,ctx1,ctx2,AL_ROLLOFF_FACTOR);

   DsyncSourcef(ID1,ID2,ctx1,ctx2,AL_REFERENCE_DISTANCE);

   DsyncSourcef(ID1,ID2,ctx1,ctx2,AL_MIN_GAIN);

   DsyncSourcef(ID1,ID2,ctx1,ctx2,AL_MAX_GAIN);

   DsyncSourcef(ID1,ID2,ctx1,ctx2,AL_CONE_OUTER_GAIN);

   DsyncSourcef(ID1,ID2,ctx1,ctx2,AL_CONE_INNER_ANGLE);

   DsyncSourcef(ID1,ID2,ctx1,ctx2,AL_CONE_OUTER_ANGLE);

   DsyncSourcef(ID1,ID2,ctx1,ctx2,AL_SEC_OFFSET);

   DsyncSourcef(ID1,ID2,ctx1,ctx2,AL_SAMPLE_OFFSET);

   DsyncSourcef(ID1,ID2,ctx1,ctx2,AL_BYTE_OFFSET);

     

   DsyncSource3f(ID1,ID2,ctx1,ctx2,AL_POSITION);

   DsyncSource3f(ID1,ID2,ctx1,ctx2,AL_VELOCITY);

   DsyncSource3f(ID1,ID2,ctx1,ctx2,AL_DIRECTION);

   

   DsyncSourcei(ID1,ID2,ctx1,ctx2,AL_SOURCE_RELATIVE);

   DsyncSourcei(ID1,ID2,ctx1,ctx2,AL_LOOPING);

 

 

 

 

 

   // first, copy buffer patterns over.

 

   //source2->lSourceType = source1->lSourceType;

   //source2->NumChannels = source1->NumChannels;

   //source2->SampleSize = source1->SampleSize;

   //source2->Buffer = source1->Buffer;

   // source2->queue  = source1->queue;

   // source2->BuffersInQueue = source1-> BuffersInQueue;

   // source2->BuffersPlayed = source1 -> BuffersPlayed;

 

   // then, duplicate the state.

 

   // handle static sources

   //printf("handling Buffers\n");

   alcMakeContextCurrent(ctx1);

   ALint source_type;

   alGetSourcei(ID1, AL_SOURCE_TYPE, &source_type);

   //printError();

   

   if (AL_STATIC == source_type){

     //printf("setting STATIC source\n");

     ALint buffer_id1;

     ALint buffer_id2;

     alGetSourcei(ID1, AL_BUFFER, &buffer_id1);

     alcMakeContextCurrent(ctx2);

     alGetSourcei(ID2, AL_BUFFER, &buffer_id2);

     if (buffer_id1 != buffer_id2){

       //printf("setting source2's buffer from %d to %d\n", buffer_id2, buffer_id1);

       alSourcei(ID2, AL_BUFFER, buffer_id1);

       //printError();

     }

     else {

       //printf("Buffers are already the same, doing nothing.\n");

     }

   }

   else {

     // printf("not a static source!\n");

   }

     

 

 

 

 

 

   alcMakeContextCurrent(ctx2);

   

   

 

 

   //printf("setting STATE\n");

   alcMakeContextCurrent(ctx1);

   ALint state1;

   alGetSourcei(ID1, AL_SOURCE_STATE, &state1);

   //printError();

 

   alcMakeContextCurrent(ctx2);

   ALint state2;

   alGetSourcei(ID2, AL_SOURCE_STATE, &state2);

   //printError();

   if (state1 != state2){

     switch (state1){

     case AL_INITIAL : /*printf("INITIAL\n")*/;alSourceRewind(ID2);break;

     case AL_PLAYING : /*printf("PLAYING\n")*/;alSourcePlay(ID2);break;

     case AL_PAUSED  : /*printf("PAUSED\n")*/;alSourcePause(ID2);break;

     case AL_STOPPED : /*printf("STOPPED\n")*/;alSourceStop(ID2);break;

     }

   }

   //printError();

   

   

 

   alcMakeContextCurrent(current);

 

 }

 

 

 void syncContexts(ALCcontext *ctx1, ALCcontext *ctx2){

   // if there aren't sufficient sources in ctx2 to mirror the sources

   // in ctx1, create them.

   ALCcontext *current = alcGetCurrentContext();

 

   UIntMap *sourceMap1 = &(ctx1->SourceMap);

   UIntMap *sourceMap2 = &(ctx2->SourceMap);

 

 

   ALuint sources1 = sourceMap1->size;

   ALuint sources2 = sourceMap2->size;

 

   //printf("ctx1 has %d sources; ctx2 has %d sources\n", sources1, sources2);

   

   alcMakeContextCurrent(ctx2);

   if (sources2 < sources1){

     ALuint numSources = sources1 - sources2;

     ALuint newSources[numSources];

     alGenSources(numSources, newSources);

     printf("adjusting...\n");

     printf("now ctx1 has %d sources; ctx2 has %d sources\n", 

 	   sourceMap1->size, sourceMap2->size);

   }

   //printError();

   

 

   alcMakeContextCurrent(current);

   

   

   // after this, ctx2 is gauranteed to have at least as many sources

   // as ctx1.  Now, sync each source from ctx1 to the corresponding

   // source in ctx2.

 

   int i;

 

 

   

   for(i = 0; i < sourceMap1->size; i++){

     syncSources((ALsource*)sourceMap1->array[i].value,

 		(ALsource*)sourceMap2->array[i].value,

 		ctx1, ctx2);

   }

   

 

   

  

 

 }

 

 

 

 void pauseMainContext(record_data *data){

   //printf("pausing MainContext\n");

   data->unPauseCount = 0;

   data->unPauseIDs = 

     (ALuint*)realloc(data->unPauseIDs, 

 		     sizeof(ALuint) * mainContext->ActiveSourceCount);

 

   ALsource **src, **src_end;

   src     = mainContext->ActiveSources;

   src_end = src + mainContext->ActiveSourceCount;

   

   while(src != src_end){

     

     if (AL_PLAYING == (*src)->state){

       ALuint source_id = (*src)->source;

       data->unPauseIDs[data->unPauseCount++] = source_id;

       alSourcePause(source_id);

     }

     src++; 

   }

 }

 

 

 

 

 void unPauseMainContext(record_data *data){

   int i;

   for(i=0;i<data->unPauseCount;i++){

     alSourcePlay(data->unPauseIDs[i]);

   }

 }

 

 

 // a device brings along with it multiple pieces of state

 // which have to be swapped in and out with each context.

 

 //static ALfloat DryBufferMain[BUFFERSIZE][MAXCHANNELS];

 //static ALfloat DryBufferAux[BUFFERSIZE][MAXCHANNELS];

 //static ALfloat PanningLUTMain[LUT_NUM][MAXCHANNELS];

 //static ALfloat PanningLUTAux[LUT_NUM][MAXCHANNELS];

 static ALfloat ClickRemovalMain[MAXCHANNELS];

 static ALfloat ClickRemovalAux[MAXCHANNELS];

 static ALfloat PendingClicksMain[MAXCHANNELS];

 static ALfloat PendingClicksAux[MAXCHANNELS];

 

 

 

 static void saveAux(ALCdevice *Device){

   //memcpy(DryBufferAux, Device->DryBuffer, sizeof(ALfloat)*BUFFERSIZE*MAXCHANNELS);

   //memcpy(PanningLUTAux, Device->PanningLUT, sizeof(ALfloat)*LUT_NUM*MAXCHANNELS);

   memcpy(ClickRemovalAux, Device->ClickRemoval, sizeof(ALfloat)*MAXCHANNELS);

   memcpy(PendingClicksAux, Device->PendingClicks, sizeof(ALfloat)*MAXCHANNELS);

 }

 static void swapInAux(ALCdevice *Device){

   //memcpy(Device->DryBuffer, DryBufferAux, sizeof(ALfloat)*BUFFERSIZE*MAXCHANNELS);

   //memcpy(Device->PanningLUT, PanningLUTAux, sizeof(ALfloat)*LUT_NUM*MAXCHANNELS);

   memcpy(Device->ClickRemoval, ClickRemovalAux, sizeof(ALfloat)*MAXCHANNELS);

   memcpy(Device->PendingClicks, PendingClicksAux, sizeof(ALfloat)*MAXCHANNELS);

 }

 

 

 static void saveMain(ALCdevice *Device){

   //memcpy(DryBufferMain, Device->DryBuffer, sizeof(ALfloat)*BUFFERSIZE*MAXCHANNELS);

   //memcpy(PanningLUTMain, Device->PanningLUT, sizeof(ALfloat)*LUT_NUM*MAXCHANNELS);

   memcpy(ClickRemovalMain, Device->ClickRemoval, sizeof(ALfloat)*MAXCHANNELS);

   memcpy(PendingClicksMain, Device->PendingClicks, sizeof(ALfloat)*MAXCHANNELS);

 }

 static void swapInMain(ALCdevice *Device){

   //memcpy(Device->DryBuffer, DryBufferMain, sizeof(ALfloat)*BUFFERSIZE*MAXCHANNELS);

   //memcpy(Device->PanningLUT, PanningLUTMain, sizeof(ALfloat)*LUT_NUM*MAXCHANNELS);

   memcpy(Device->ClickRemoval, ClickRemovalMain, sizeof(ALfloat)*MAXCHANNELS);

   memcpy(Device->PendingClicks, PendingClicksMain, sizeof(ALfloat)*MAXCHANNELS);

 }

 

 

 static ALCcontext **currentContext;

 static ALuint currentNumContext;

 static void unLimitContext(ALCdevice *Device){

   Device->Contexts = currentContext;

   Device->NumContexts = currentNumContext;

 }

 

 static void limitContext(ALCdevice *Device, ALCcontext *ctx){

   currentContext  = Device->Contexts;

   currentNumContext  = Device->NumContexts;

   Device->Contexts = &ctx;

   Device->NumContexts = 1;

 }

 

 

 void every2(ALCdevice *Device){

 

   record_data *data = (record_data*)Device->ExtraData;

 

   if (data->mainFull){

     printf("data has not yet been extracted!\n");

     return;

   }

 

   

   syncContexts(mainContext , auxContext);

 

   alcMakeContextCurrent(auxContext);

   limitContext(Device, auxContext);

   swapInAux(Device);

   aluMixData(Device, data->auxBuffer, Device->UpdateSize);

   saveAux(Device);

   unLimitContext(Device);

   

 

   alcMakeContextCurrent(mainContext);

   limitContext(Device, mainContext);

   swapInMain(Device);

   aluMixData(Device, data->mainBuffer, Device->UpdateSize);

   saveMain(Device);

   unLimitContext(Device);

     

   data->mainFull = AL_TRUE;

   data->auxFull = AL_TRUE;

 

 }

 

 

 

 

 

 

 void every(ALCdevice *Device){

   UNUSED(Device);

   // by the time every() is called, mainContext and auxContext will

   // have been initiliazed.

   printf("+++++++\nevery is called\n");

   // print sourceid for all sources.

   ALsource **src, **src_end;

   //  LockDevice(Device);

   //  pauseAllSources(auxContext);

   src     = mainContext->ActiveSources;

   src_end = src + mainContext->ActiveSourceCount;

   UIntMap source_map ;

   int i;

 

   source_map= mainContext->SourceMap;

   printf("max sources in the mainContext is %d\n", source_map.maxsize);

   printf("current sources: %d\n", source_map.size);

 

   printf("their ID's are:\n");

   for(i = 0; i < source_map.size; i++){

     printf("%d, ",source_map.array[i].key);

   }

   printf("\n");

   source_map= auxContext->SourceMap;

   printf("max sources in the auxContext is %d\n", source_map.maxsize);

   printf("current sources: %d\n", source_map.size);

  

   printf("their ID's are:\n");

   for(i = 0; i < source_map.size; i++){

     printf("%d, ",source_map.array[i].key);

   }

   printf("\n");

 

   while(src != src_end){

     

     if (AL_PLAYING == (*src)->state){

       ALuint source_id = (*src)->source;

       printf("source %d is AL_PLAYING\n",source_id);      

     }

     src++;

 

   }

 

 

   //  UnlockDevice(Device);

 }

 

 

 

 

 

 

 

 // debug printing

 

 #define DEBUG 0

 

 #define dprintf(expr) {if (DEBUG) {printf(expr);}}

 

 

 

 

 static const ALCchar recordDevice[] = "Aurellem";

 

 

 

 

 

 

 struct ALsource * cloneSource(struct ALsource *source);

 

 //struct ALsource * cloneSource(struct ALsource *source){

 //  ALuint[1] sourceID;

   

 

 //}

 

 int lock = 0;

 

 /*

 static ALuint RecordProc()

 {

   if (0 == lock){return 0;}

   ALCdevice *Device = deviceInstance;

   dprintf("RLM: recordProc is begun!!\n");

   printError();

   static int MixCount = 0 ;

   if (Device->Connected)

     {

       // the device does not seem to be "ready" until this point.

       init(Device);

       //init2(Device);

       printf("\nMix Cycle %d\n", MixCount++);

       every(Device);

       every2(Device);

       //aluMixData(Device, NULL, Device->UpdateSize);

     }

   lock = 1;

   return 0;

 }

 */

 

 

  /*

 static ALuint RecordProc(ALvoid *ptr)

 {

   

   printf("RLM: recordProc is begun!!\n");

   ALCdevice *Device = (ALCdevice*)ptr;

   //printError();

   record_data *data = (record_data*)Device->ExtraData;

   ALuint now, start;

   ALuint64 avail, done;

   const ALuint restTime = (ALuint64)Device->UpdateSize * 1000 /

     Device->Frequency / 2;

 

   done = 0;

   start = timeGetTime();

   //static int MixCount = 0 ;

 

 

   if(!data->killNow && Device->Connected)

     {

       printf("sext level breakfast manuever!\n");

       now = timeGetTime();

 	

       avail = (ALuint64)(now-start) * Device->Frequency / 1000;

       if(avail < done)

         {

 	 

 	  avail += (ALuint64)0xFFFFFFFFu*Device->Frequency/1000 - done;

 	  done = 0;

         }

       if(avail-done < Device->UpdateSize)

         {

 	  //Sleep(restTime); 

 	  //continue;

         }

 

       while(avail-done >= Device->UpdateSize)

         {

 	  // the device does not seem to be "ready" until this point.

 	  init(Device);

 	  //init2(Device);

 	  //printf("\nMix Cycle %d\n", MixCount++);

 	  //every(Device);

 	  every2(Device);

 	  //later(Device);

 	  //printError();

 	  //aluMixData(Device, NULL, Device->UpdateSize);

 	  //Sleep(3000);

 	  done += Device->UpdateSize;

         }

     }

   else {

     printf("WARNGING\n");

   }

 

   return 0;

 }

 */

 

 

 

 static ALuint RecordProc(ALCdevice *Device)

 {

   

   //printf("RLM: recordProc is begun!!\n");

   //  ALCdevice *Device = (ALCdevice*)ptr;

 

   record_data *data = (record_data*)Device->ExtraData;

 

   if(!data->killNow && Device->Connected)

     {

       

       if (AL_TRUE)

         {

 	  // the device does not seem to be "ready" until this point.

 	  init(Device);

 	  //init2(Device);

 	  //printf("\nMix Cycle %d\n", MixCount++);

 	  //every(Device);

 	  every2(Device);

 	  //later(Device);

 	  //printError();

 	  //aluMixData(Device, NULL, Device->UpdateSize);

 	  //Sleep(3000);

         }

     }

   else {

     printf("WARNGING\n");

   }

   

   return 0;

 }

 

 

 void init(ALCdevice *Device){

   RUNONLY(1);

   printf("one time init\n");

   printError();

   printf("auxContext  : %p\n", auxContext);

   auxContext = alcCreateContext(Device,NULL);

   printf("auxContext  : %p\n", auxContext);

   printError();

   printf("mainContext : %p\n", mainContext);

   mainContext = alcGetCurrentContext();

   printf("mainContext : %p\n", mainContext);

   printError();

   printf("setting listener properties\n");

   alcMakeContextCurrent(auxContext);

   ALfloat val1;

   ALfloat val2;

   ALfloat val3;

   alGetListener3f(AL_POSITION, &val1, &val2, &val3);

   printf("location is [%f,%f,%f]\n", val1,val2,val3);

   alGetListener3f(AL_VELOCITY, &val1, &val2, &val3);

   printf("velocity is [%f,%f,%f]\n", val1,val2,val3);

   saveAux(Device);

   saveMain(Device);

 }

 

 void later(ALCdevice *Device){

   // run only the third time it is called

   UNUSED(Device);

   RUNAT(3);

   printf("Suspending main Context....\n");

   alcSuspendContext(mainContext);

   printError();

   printf("Switching to aux Context...\n");

   alcMakeContextCurrent(auxContext);

   printError();

 }

 

 

 

 static ALCboolean record_open_playback(ALCdevice *device, const ALCchar *deviceName)

 {

   record_data *data;

   // stop any buffering for stdout, so that I can 

   // see the damm printf statements in my terminal immediatley

   setbuf(stdout, NULL);

 

   dprintf("open_playback is called.\n");

   if(!deviceName)

     deviceName = recordDevice;

   else if(strcmp(deviceName, recordDevice) != 0)

     return ALC_FALSE;

 

   data = (record_data*)calloc(1, sizeof(*data));

     

   device->szDeviceName = strdup(deviceName);

   data->robert = 5;

   device->ExtraData = data;

     

   return ALC_TRUE;

 }

 

 static void record_close_playback(ALCdevice *device)

 {

   record_data *data = (record_data*)device->ExtraData;

   dprintf("RLM: close playback called\n");

   free(data);

   device->ExtraData = NULL;

 }

 

 

 

 

 

 static ALCboolean record_reset_playback(ALCdevice *device)

 {

   record_data *data = (record_data*)device->ExtraData;

   dprintf("RLM: reset playback called\n");

 

   ALuint channels=0, bits=0;

 

   

 

   switch(device->FmtType)

     {

     case DevFmtByte:

       device->FmtType = DevFmtUByte;

       break;

     case DevFmtUShort:

       device->FmtType = DevFmtShort;

       break;

     case DevFmtUByte:

     case DevFmtShort:

     case DevFmtFloat:

       break;

     }

   bits = BytesFromDevFmt(device->FmtType) * 8;

   channels = ChannelsFromDevFmt(device->FmtChans);

   data->size = device->UpdateSize * channels * bits / 8;

   data->auxBuffer = malloc(data->size);

   data->mainBuffer = malloc(data->size);

   data->mainFull = AL_FALSE;

   data->auxFull = AL_FALSE;

   data->mainReady = AL_TRUE;

   data->auxReady = AL_TRUE;

     

   if(!data->mainBuffer || !data->auxBuffer)

     {

       ERR("Buffer malloc failed\n");

       return ALC_FALSE;

     }

 

   //data->thread = StartThread(RecordProc, device);

   //data->thread = StartThread(noop, device);

   

   //TODO: shoudl free everything somewhere else!

 

   /*

   if(data->thread == NULL)

     {

       free(data->mainBuffer);

       free(data->auxBuffer);

       free(data->unPauseIDs);

       data->auxBuffer = NULL;

       data->mainBuffer = NULL;

 

       return ALC_FALSE;

     }

   */

   return ALC_TRUE;

 }

 

 

 

 static void record_stop_playback(ALCdevice *device)

 {

   record_data *data = (record_data*)device->ExtraData;

   dprintf("RLM: stop playback called\n");

   printf("szName is %s \n", device->szDeviceName);

   printf("robert is %d \n", data->robert);

 

 

   if(!data->thread)

     return;

 

   data->killNow = 1;

   StopThread(data->thread);

   data->thread = NULL;

 

   data->killNow = 0;

 }

 

 

 static const BackendFuncs record_funcs = {

   record_open_playback,

   record_close_playback,

   record_reset_playback,

   record_stop_playback,

   NULL,

   NULL,  /* These would be filled with functions to */

   NULL,  /* handle capturing audio if we did that. */

   NULL,

   NULL,

   NULL

 };

 

 ALCboolean alc_record_init(BackendFuncs *func_list)

 {

   dprintf("RECORD: I'm InIT111\n");

   *func_list = record_funcs;

   return ALC_TRUE;

 }

 

 void alc_record_deinit(void)

 {

 }

 

 void alc_record_probe(enum DevProbe type)

 {

   dprintf("RECORD: I'm being probed! :/\n");

 

   switch(type)

     {

     case DEVICE_PROBE:

       AppendDeviceList(recordDevice);

       break;

     case ALL_DEVICE_PROBE:

       AppendAllDeviceList(recordDevice);

       break;

     case CAPTURE_DEVICE_PROBE:

       break;

     }

 }

 

 

 

 

 void printError(void){

   ALenum error = alGetError();

   printf("%s\n", GetALCErrorString(error));

   printf("%s\n", GetALErrorString(error));

 }

 

 

 

 char* GetALCErrorString(ALenum err)

 {

   switch(err)

     {

     case ALC_NO_ERROR:

       return "AL_NO_ERROR";

       break;

 

     case ALC_INVALID_DEVICE:

       return "ALC_INVALID_DEVICE";

       break;

 

     case ALC_INVALID_CONTEXT:

       return "ALC_INVALID_CONTEXT";

       break;

 

     case ALC_INVALID_ENUM:

       return "ALC_INVALID_ENUM";

       break;

 

     case ALC_INVALID_VALUE:

       return "ALC_INVALID_VALUE";

       break;

 

     case ALC_OUT_OF_MEMORY:

       return "ALC_OUT_OF_MEMORY";

       break;

     };

   return "UNknown error.";

 }

 

 

 

 

 

 

 

 char* GetALErrorString(ALenum err)

 {

   switch(err)

     {

     case AL_NO_ERROR:

       return "AL_NO_ERROR";

       break;

 

     case AL_INVALID_NAME:

       return "AL_INVALID_NAME";

       break;

 

     case AL_INVALID_ENUM:

       return "AL_INVALID_ENUM";

       break;

 

     case AL_INVALID_VALUE:

       return "AL_INVALID_VALUE";

       break;

 

     case AL_INVALID_OPERATION:

       return "AL_INVALID_OPERATION";

       break;

 

     case AL_OUT_OF_MEMORY:

       return "AL_OUT_OF_MEMORY";

       break;

     };

   return "UNknown error.";

 }

 

 

 

 

 

 

 

 #include "com_aurellem_audioPlay_TestCall.h"

 

 JNIEXPORT void JNICALL Java_com_aurellem_audioPlay_TestCall_nprintGarbage

 (JNIEnv *env, jclass clazz){

   UNUSED(env);UNUSED(clazz);

   printf("Native! method* zzz\n");

   return;

 }

 

 #include "com_aurellem_audioPlay_WavCaptureMaybe.h"

 

 JNIEXPORT void JNICALL Java_com_aurellem_audioPlay_WavCaptureMaybe_nrecord_1whatever

 (JNIEnv *env, jclass clazz){

   UNUSED(env);UNUSED(clazz);

   printf("record_aurellem_whatever!");

 }

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 //////////////////////////// Real JNI stuff ////////////////////////////////

 void getMainSamples(ALCvoid *buffer){

   UNUSED(buffer);

   //  memcpy(mainBuffer, (ALubyte*) buffer, samples);

 }

 

 void getAuxSamples(ALCvoid *buffer){

   UNUSED(buffer);

   //  memcpy(auxBuffer, (ALubyte*) buffer, samples);

 }

 

 #include "com_jme3_capture_RecordAudioRenderer.h"

 

 /*

  * Class:     com_jme3_capture_RecordAudioRenderer

  * Method:    helloEveryone

  * Signature: ()V

  */

 JNIEXPORT void JNICALL Java_com_jme3_capture_RecordAudioRenderer_helloEveryone

 (JNIEnv *env, jclass clazz){

   UNUSED(env);UNUSED(clazz);

   printf("\n**************\nC from Java: I'm audioRecorder :)\n***********\n");

 }

 

 

 /*

  * Class:     com_jme3_capture_RecordAudioRenderer

  * Method:    nstep

  * Signature: ()V

  */

 JNIEXPORT void JNICALL Java_com_jme3_capture_RecordAudioRenderer_nstep

 (JNIEnv *env, jclass clazz, jlong device){

   UNUSED(env);UNUSED(clazz);UNUSED(device);

   //printf("C from Java: I'm audioRecorder -- nstep :)\n");

   RecordProc((ALCdevice*)((intptr_t)device));

 }

 

 /*

  * Class:     com_jme3_capture_RecordAudioRenderer

  * Method:    ngetMainSamples

  * Signature: (JLjava/nio/ByteBuffer;I)V

  */

 JNIEXPORT void JNICALL Java_com_jme3_capture_RecordAudioRenderer_ngetMainSamples

 (JNIEnv *env, jclass clazz, jlong device, jobject buffer, jint position){

   UNUSED(clazz);

   

   ALvoid *buffer_address = 

     ((ALbyte *)(((char*)(*env)->GetDirectBufferAddress(env, buffer)) + position));

   ALCdevice *recorder = (ALCdevice*) ((intptr_t)device);

   //printf("getMainSamples: device is %p\n", recorder);

   record_data *data = (record_data*)recorder->ExtraData;

   if (!data->mainFull){

     printf("data is not ready!\n"); 

     return;

   }

   memcpy(buffer_address, data->mainBuffer, data->size);

   data->mainFull = AL_FALSE;

 }

 

 /*

  * Class:     com_jme3_capture_RecordAudioRenderer

  * Method:    ngetAuxSamples

  * Signature: (JLjava/nio/ByteBuffer;I)V

  */

 JNIEXPORT void JNICALL Java_com_jme3_capture_RecordAudioRenderer_ngetAuxSamples

   (JNIEnv *env, jclass clazz, jlong device, jobject buffer, jint position){

   UNUSED(clazz);

   

   ALvoid *buffer_address = 

     ((ALbyte *)(((char*)(*env)->GetDirectBufferAddress(env, buffer)) + position));

   ALCdevice *recorder = (ALCdevice*) ((intptr_t)device);

   //printf("getMainSamples: device is %p\n", recorder);

   record_data *data = (record_data*)recorder->ExtraData;

   

   memcpy(buffer_address, data->auxBuffer, data->size);

   

 }

 

 

 /*

  * Class:     com_jme3_capture_RecordAudioRenderer

  * Method:    nsetAuxListener3f

  * Signature: (IFFF)V

  */

 JNIEXPORT void JNICALL Java_com_jme3_capture_RecordAudioRenderer_nsetAuxListener3f

 (JNIEnv *env, jclass clazz, jint pname, jfloat v1, jfloat v2, jfloat v3){

   UNUSED(env);UNUSED(clazz);

   aux_alListener3f(pname, v1, v2, v3);

 }

 

 /*

  * Class:     com_jme3_capture_RecordAudioRenderer

  * Method:    nsetAuxListenerf

  * Signature: (IF)V

  */

 JNIEXPORT void JNICALL Java_com_jme3_capture_RecordAudioRenderer_nsetAuxListenerf

 (JNIEnv *env, jclass clazz, jint pname, jfloat v1){

   UNUSED(env);UNUSED(clazz);

   aux_alListenerf(pname, v1);

 }

 

 

 

 /*

 static void JNICALL Java_org_lwjgl_openal_ALC11_nalcCaptureSamples

 (JNIEnv *env, jclass clazz, jlong device, jobject buffer, jint position, jint samples) {

   ALvoid *buffer_address = 

     ((ALbyte *)(((char*)(*env)->GetDirectBufferAddress(env, buffer)) + position));

   alcCaptureSamples((ALCdevice*) ((intptr_t)device), buffer_address, samples);

 }

 */