Index: sound.c
===================================================================
--- sound.c	(revision 300)
+++ sound.c	(revision 301)
@@ -1,7 +1,7 @@
 /*
-    Raydium - CQFD Corp.
-    http://raydium.org/
-    License: GPL - GNU General Public License, see "gpl.txt" file.
+  Raydium - CQFD Corp.
+  http://raydium.org/
+  License: GPL - GNU General Public License, see "gpl.txt" file.
 */
 
 #ifndef DONT_INCLUDE_HEADERS
@@ -22,35 +22,35 @@
 
 void raydium_sound_music_info_init(void)
 {
-strcpy(raydium_sound_music_info.artist,"Unkown artist");
-strcpy(raydium_sound_music_info.album, "Unkown album" );
-strcpy(raydium_sound_music_info.title, "Unkown title" );
+  strcpy(raydium_sound_music_info.artist,"Unkown artist");
+  strcpy(raydium_sound_music_info.album, "Unkown album" );
+  strcpy(raydium_sound_music_info.title, "Unkown title" );
 }
 
 void raydium_sound_music_info_refresh(void)
 {
-char **ptr;
-char part1[RAYDIUM_MAX_NAME_LEN];
-char part2[RAYDIUM_MAX_NAME_LEN];
+  char **ptr;
+  char part1[RAYDIUM_MAX_NAME_LEN];
+  char part2[RAYDIUM_MAX_NAME_LEN];
 
 
-// reset ogg infos
-raydium_sound_music_info_init();
+  // reset ogg infos
+  raydium_sound_music_info_init();
 
-ptr=ov_comment(&raydium_sound_vf,-1)->user_comments;
-while(*ptr)
+  ptr=ov_comment(&raydium_sound_vf,-1)->user_comments;
+  while(*ptr)
     {
-    part1[0]=0;
-    part2[0]=0;
-    raydium_parser_cut(*ptr,part1,part2,'=');
+      part1[0]=0;
+      part2[0]=0;
+      raydium_parser_cut(*ptr,part1,part2,'=');
     
-    if(!strcasecmp("title",part1))
+      if(!strcasecmp("title",part1))
 	strcpy(raydium_sound_music_info.title,part2);
 
-    if(!strcasecmp("album",part1))
+      if(!strcasecmp("album",part1))
 	strcpy(raydium_sound_music_info.album,part2);
 
-    if(!strcasecmp("artist",part1))
+      if(!strcasecmp("artist",part1))
 	strcpy(raydium_sound_music_info.artist,part2);
 
       ++ptr;
@@ -63,54 +63,54 @@
 //IF AN ERROR IS DETECTED IT PRINTS THE caller NAME
 void raydium_sound_verify(char *caller)
 {
- int error;
- if ((error = alGetError()) != AL_NO_ERROR)
- {
-  raydium_log("sound: ERROR : %s :%d",caller,error);
-//  raydium_log("sound: Deleting buffers");
-//   alDeleteBuffers(RAYDIUM_SOUND_NUM_BUFFERS,raydium_sound_buffer);
-//  raydium_log("sound: Releasing OpenAL");
-//   alutExit();
-//   exit(1);
- }
+  int error;
+  if ((error = alGetError()) != AL_NO_ERROR)
+    {
+      raydium_log("sound: ERROR : %s :%d",caller,error);
+      //  raydium_log("sound: Deleting buffers");
+      //   alDeleteBuffers(RAYDIUM_SOUND_NUM_BUFFERS,raydium_sound_buffer);
+      //  raydium_log("sound: Releasing OpenAL");
+      //   alutExit();
+      //   exit(1);
+    }
 }
 
 int raydium_sound_Array3IsValid(ALfloat *a)
 {
-if( !raydium_trigo_isfloat(a[0]) ||
-    !raydium_trigo_isfloat(a[1]) ||
-    !raydium_trigo_isfloat(a[2]) )
-	{
-	raydium_log("sound : ERROR: invalid 3xALfloat array provided");
-	return 0;
-	}
-return 1;
+  if( !raydium_trigo_isfloat(a[0]) ||
+      !raydium_trigo_isfloat(a[1]) ||
+      !raydium_trigo_isfloat(a[2]) )
+    {
+      raydium_log("sound : ERROR: invalid 3xALfloat array provided");
+      return 0;
+    }
+  return 1;
 }
 
 //INITS A SOURCE WITH DEFAULT VALUES
 //TAKES A SOURCE NUMBER
 void raydium_sound_InitSource(int src)
 {
- ALfloat srcPos[]={ 0.0, 0.0, 0.0};
- ALfloat srcVel[]={ 0.0, 0.0, 0.0};
+  ALfloat srcPos[]={ 0.0, 0.0, 0.0};
+  ALfloat srcVel[]={ 0.0, 0.0, 0.0};
 
- alSourcef(raydium_sound_source[src],AL_PITCH,1.0f);                //SETS SOURCE PITCH
-   raydium_sound_verify("setting source pitch");
- alSourcef(raydium_sound_source[src],AL_GAIN,1.0f);                 //SETS SOURCE GAIN
-   raydium_sound_verify("setting source gain");
- alSourcef(raydium_sound_source[src],AL_REFERENCE_DISTANCE,raydium_sound_DefaultReferenceDistance);
-   raydium_sound_verify("setting source reference distance");
- alSourcefv(raydium_sound_source[src],AL_POSITION,srcPos);          //SETS SOURCE POSITION
-   raydium_sound_verify("setting source position");
- alSourcefv(raydium_sound_source[src],AL_VELOCITY,srcVel);          //SETS SOURCE VELOCITY
-   raydium_sound_verify("setting source velocity");
- alSourcei(raydium_sound_source[src],AL_BUFFER,raydium_sound_buffer[src]);               //ATTACHS A SOURCE TO A BUFFER
-   raydium_sound_verify("attaching source to buffer");
- alSourcei(raydium_sound_source[src],AL_LOOPING,AL_TRUE);           //SETS SOURCE LOOPING TO TRUE
-   raydium_sound_verify("setting source loop state");
+  alSourcef(raydium_sound_source[src],AL_PITCH,1.0f);                //SETS SOURCE PITCH
+  raydium_sound_verify("setting source pitch");
+  alSourcef(raydium_sound_source[src],AL_GAIN,1.0f);                 //SETS SOURCE GAIN
+  raydium_sound_verify("setting source gain");
+  alSourcef(raydium_sound_source[src],AL_REFERENCE_DISTANCE,raydium_sound_DefaultReferenceDistance);
+  raydium_sound_verify("setting source reference distance");
+  alSourcefv(raydium_sound_source[src],AL_POSITION,srcPos);          //SETS SOURCE POSITION
+  raydium_sound_verify("setting source position");
+  alSourcefv(raydium_sound_source[src],AL_VELOCITY,srcVel);          //SETS SOURCE VELOCITY
+  raydium_sound_verify("setting source velocity");
+  alSourcei(raydium_sound_source[src],AL_BUFFER,raydium_sound_buffer[src]);               //ATTACHS A SOURCE TO A BUFFER
+  raydium_sound_verify("attaching source to buffer");
+  alSourcei(raydium_sound_source[src],AL_LOOPING,AL_TRUE);           //SETS SOURCE LOOPING TO TRUE
+  raydium_sound_verify("setting source loop state");
 
- raydium_sound_source_fade_factor[src]=0;
- raydium_sound_source_fade_tofile[src][0]=0;
+  raydium_sound_source_fade_factor[src]=0;
+  raydium_sound_source_fade_tofile[src][0]=0;
 }
 
 
@@ -118,11 +118,11 @@
 //RETURNS THE SOURCE NUMBER OR -1 IF IT FAILS
 int raydium_sound_LoadWav(const char *fname)
 {
- int snum;
- ALsizei size;
- ALenum format;
- ALvoid *data;
- FILE *fp;
+  int snum;
+  ALsizei size;
+  ALenum format;
+  ALvoid *data;
+  FILE *fp;
 
 #ifndef WIN32
 #ifdef ALUT_API_MAJOR_VERSION
@@ -131,57 +131,61 @@
 #endif
     
 #ifndef ALUT_API_MAJOR_VERSION_BUT_WIN32
- ALboolean boolean;
- ALsizei freq;
+  ALboolean boolean;
+  ALsizei freq;
 #else
- ALfloat freq;
+  ALfloat freq;
 #endif
+  
+  if(raydium_sound_top_buffer==RAYDIUM_SOUND_NUM_BUFFERS)
+    {
+      raydium_log("sound: ERROR loading %s no more buffers available",fname);
+      //  exit(1);
+      return -1;
+    }
+  else
+    {
+      snum=raydium_sound_top_buffer;
+    }
 
+  fp = raydium_file_fopen((char *)fname,"r");
+  if(fp==NULL)
+    {
+      raydium_log("sound: ERROR opening WAV file %s",fname);
+      return -1;
+    }
+ 
+  char buffer[1024];
+  char *wav_file = NULL;
+  int wav_size = 0;
+  int grow = 0;
+  while( (grow = fread(buffer, sizeof(char) , 1024, fp)) > 0)
+    {
+      wav_file = realloc(wav_file, wav_size + grow * sizeof(char));
+      memcpy(wav_file + wav_size, buffer, grow * sizeof(char));
+      wav_size += grow * sizeof(char);
+    }  
+  if(!feof(fp))
+    {
+      raydium_log("sound: ERROR reading WAV file %s",fname);
+      return -1;
+    }
 
- if(raydium_sound_top_buffer==RAYDIUM_SOUND_NUM_BUFFERS)
- {
-  raydium_log("sound: ERROR loading %s no more buffers available",fname);
-//  exit(1);
-  return -1;
- }
- else
- {
-  snum=raydium_sound_top_buffer;
- }
+  raydium_log("sound: Loaded %s, size %i bytes",fname, wav_size);
+  fclose(fp);
+  
+  data=alutLoadMemoryFromFileImage(wav_file,wav_size,&format,&size,&freq);
+  raydium_sound_verify("alutLoadMemoryFromFile");
 
- fp=raydium_file_fopen((char *)fname,"r");
- if(fp==NULL)
- {
-  raydium_log("sound: ERROR opening file %s",fname);
-  return -1;
-  //exit(1);
- }
- fclose(fp);
+  if(data)
+    alBufferData(raydium_sound_buffer[snum],format,data,size,freq);
+  raydium_sound_verify("alBufferData");
 
-#ifdef ALUT_API_MAJOR_VERSION_BUT_WIN32
- data=alutLoadMemoryFromFile(fname,&format,&size,&freq);
-     raydium_sound_verify("alutLoadMemoryFromFile");
-
- if(data)
- alBufferData(raydium_sound_buffer[snum],format,data,size,freq);
-     raydium_sound_verify("alBufferData");
-
- if(data)
-  free(data);
-
-#else
-  alutLoadWAVFile((ALbyte *)fname,&format,&data,&size,&freq,&boolean);
-     raydium_sound_verify("alutLoadWAVFile");
-
- alBufferData(raydium_sound_buffer[snum],format,data,size,freq);
-     raydium_sound_verify("alBufferData");
-
- alutUnloadWAV(format,data,size,freq);
-     raydium_sound_verify("alutUnloadWAV");
-#endif
-
- raydium_sound_top_buffer++;
- raydium_sound_InitSource(snum);
+  if(data)
+    free(data);
+  
+  raydium_sound_top_buffer++;
+  raydium_sound_InitSource(snum);
   return(snum);
 }
 
@@ -190,24 +194,24 @@
 //RETURNS 0 IF OK, -1 IF THERE'S AN ERROR
 int raydium_sound_SourceVerify(int src)
 {
- if(src<0 || src>=raydium_sound_top_buffer)
- {
-  raydium_log("sound: source %d doesn't exist !",src);
-  return(-1);
- }
- return(0);
+  if(src<0 || src>=raydium_sound_top_buffer)
+    {
+      raydium_log("sound: source %d doesn't exist !",src);
+      return(-1);
+    }
+  return(0);
 }
 
 //SETS THE LOOP ATTRIBUTE OF A SOURCE
 int raydium_sound_SetSourceLoop(int src, signed char loop)
 {
- int result=raydium_sound_SourceVerify(src);
- if(result==0)
- {
-  alSourcei(raydium_sound_source[src],AL_LOOPING,(loop?AL_TRUE:AL_FALSE));
-  raydium_sound_verify("setting source loop");
- }
- return(result);
+  int result=raydium_sound_SourceVerify(src);
+  if(result==0)
+    {
+      alSourcei(raydium_sound_source[src],AL_LOOPING,(loop?AL_TRUE:AL_FALSE));
+      raydium_sound_verify("setting source loop");
+    }
+  return(result);
 }
 
 //GETS SOURCE PITCH
@@ -215,13 +219,13 @@
 //GIVES AN ALfloat
 int raydium_sound_GetSourcePitch(int src, ALfloat *p)
 {
- int result=raydium_sound_SourceVerify(src);
- if(result==0)
- {
-  alGetSourcef(raydium_sound_source[src],AL_PITCH,p);
-  raydium_sound_verify("getting source pitch");
- }
- return(result);
+  int result=raydium_sound_SourceVerify(src);
+  if(result==0)
+    {
+      alGetSourcef(raydium_sound_source[src],AL_PITCH,p);
+      raydium_sound_verify("getting source pitch");
+    }
+  return(result);
 }
 
 
@@ -229,23 +233,23 @@
 //TAKES A SOURCE NUMBER AND AN ALfloat
 int raydium_sound_SetSourcePitch(int src, ALfloat p)
 {
- int result=raydium_sound_SourceVerify(src);
- if(result==0)
- {
-  if(p>2.0)
-  {
-   p=2.0;//CLIPPING
-   raydium_log("sound: Pitch Overflow , clipped to 2");
-  }
-  if(p<=0.0)
-  {
-   p=0.1; // Seems ok :)
-   raydium_log("sound: Tried to set negative or 0 Pitch , clipped to 0.1");
-  }
-  alSourcef(raydium_sound_source[src],AL_PITCH,p);
-  raydium_sound_verify("setting source pitch");
- }
- return(result);
+  int result=raydium_sound_SourceVerify(src);
+  if(result==0)
+    {
+      if(p>2.0)
+	{
+	  p=2.0;//CLIPPING
+	  raydium_log("sound: Pitch Overflow , clipped to 2");
+	}
+      if(p<=0.0)
+	{
+	  p=0.1; // Seems ok :)
+	  raydium_log("sound: Tried to set negative or 0 Pitch , clipped to 0.1");
+	}
+      alSourcef(raydium_sound_source[src],AL_PITCH,p);
+      raydium_sound_verify("setting source pitch");
+    }
+  return(result);
 }
 
 
@@ -254,13 +258,13 @@
 //GIVES AN ALfloat
 int raydium_sound_GetSourceGain(int src, ALfloat *g)
 {
- int result=raydium_sound_SourceVerify(src);
- if(result==0)
- {
-  alGetSourcef(raydium_sound_source[src],AL_GAIN,g);
-  raydium_sound_verify("getting source gain");
- }
- return(result);
+  int result=raydium_sound_SourceVerify(src);
+  if(result==0)
+    {
+      alGetSourcef(raydium_sound_source[src],AL_GAIN,g);
+      raydium_sound_verify("getting source gain");
+    }
+  return(result);
 }
 
 
@@ -268,41 +272,41 @@
 //TAKES A SOURCE NUMBER AND AN ALfloat
 int raydium_sound_SetSourceGain(int src, ALfloat g)
 {
- int result=raydium_sound_SourceVerify(src);
- if(result==0)
- {
-  if(g<0.0)
-  {
-   g=0.0;
-   raydium_log("sound: Tried to set negative Gain , clipped to 0");
-  }
-  alSourcef(raydium_sound_source[src],AL_GAIN,g);
-  raydium_sound_verify("setting source gain");
- }
- return(result);
+  int result=raydium_sound_SourceVerify(src);
+  if(result==0)
+    {
+      if(g<0.0)
+	{
+	  g=0.0;
+	  raydium_log("sound: Tried to set negative Gain , clipped to 0");
+	}
+      alSourcef(raydium_sound_source[src],AL_GAIN,g);
+      raydium_sound_verify("setting source gain");
+    }
+  return(result);
 }
 
 //SETS SOURCE POSITION
 //TAKES A SOURCE NUMBER AND AN ALfloat ARRAY {x,y,z}
 int raydium_sound_SetSourcePos(int src, ALfloat Pos[])
 {
- int result=raydium_sound_SourceVerify(src);
- if(result==0 && raydium_sound_Array3IsValid(Pos))
- {
-  alSourcefv(raydium_sound_source[src],AL_POSITION,Pos);
-  raydium_sound_verify("setting source position");
- }
- return(result);
+  int result=raydium_sound_SourceVerify(src);
+  if(result==0 && raydium_sound_Array3IsValid(Pos))
+    {
+      alSourcefv(raydium_sound_source[src],AL_POSITION,Pos);
+      raydium_sound_verify("setting source position");
+    }
+  return(result);
 }
 
 
 int raydium_sound_SetSourcePosCamera(int src)
 {
-ALfloat p[3];
-p[0]=raydium_camera_x;
-p[1]=raydium_camera_y;
-p[2]=raydium_camera_z;
-return raydium_sound_SetSourcePos(src,p);
+  ALfloat p[3];
+  p[0]=raydium_camera_x;
+  p[1]=raydium_camera_y;
+  p[2]=raydium_camera_z;
+  return raydium_sound_SetSourcePos(src,p);
 }
 
 //GETS SOURCE POSITION
@@ -310,13 +314,13 @@
 //GIVES AN ALfloat ARRAY {x,y,z}
 int raydium_sound_GetSourcePos(int src, ALfloat *Pos[] )
 {
- int result=raydium_sound_SourceVerify(src);
- if(result==0)
- {
-  alGetSourcefv(raydium_sound_source[src],AL_POSITION,(ALfloat *)&(*Pos));
-  raydium_sound_verify("getting source position");
- }
- return(result);
+  int result=raydium_sound_SourceVerify(src);
+  if(result==0)
+    {
+      alGetSourcefv(raydium_sound_source[src],AL_POSITION,(ALfloat *)&(*Pos));
+      raydium_sound_verify("getting source position");
+    }
+  return(result);
 }
 
 
@@ -324,13 +328,13 @@
 //TAKES A SOURCE NUMBER AND AN ALfloat ARRAY {x,y,z}
 int raydium_sound_SetSourceDir(int src, ALfloat Dir[])
 {
- int result=raydium_sound_SourceVerify(src);
- if(result==0 && raydium_sound_Array3IsValid(Dir))
- {
-  alSourcefv(raydium_sound_source[src],AL_DIRECTION,Dir);
-  raydium_sound_verify("setting source direction");
- }
- return(result);
+  int result=raydium_sound_SourceVerify(src);
+  if(result==0 && raydium_sound_Array3IsValid(Dir))
+    {
+      alSourcefv(raydium_sound_source[src],AL_DIRECTION,Dir);
+      raydium_sound_verify("setting source direction");
+    }
+  return(result);
 }
 
 //GETS SOURCE DIRECTION
@@ -338,13 +342,13 @@
 //GIVES AN ALfloat ARRAY {x,y,z}
 int raydium_sound_GetSourceDir(int src, ALfloat *Dir[] )
 {
- int result=raydium_sound_SourceVerify(src);
- if(result==0)
- {
-  alGetSourcefv(raydium_sound_source[src],AL_DIRECTION,(ALfloat *)&(*Dir));
-  raydium_sound_verify("getting source direction");
- }
- return(result);
+  int result=raydium_sound_SourceVerify(src);
+  if(result==0)
+    {
+      alGetSourcefv(raydium_sound_source[src],AL_DIRECTION,(ALfloat *)&(*Dir));
+      raydium_sound_verify("getting source direction");
+    }
+  return(result);
 }
 
 
@@ -352,13 +356,13 @@
 //TAKES A SOURCE NUMBER AND AN ALfloat ARRAY {x,y,z}
 int raydium_sound_SetSourceVel(int src, ALfloat Vel[])
 {
- int result=raydium_sound_SourceVerify(src);
- if(result==0 && raydium_sound_Array3IsValid(Vel))
- {
-  alSourcefv(raydium_sound_source[src],AL_VELOCITY,Vel);
-  raydium_sound_verify("setting source velocity");
- }
- return(result);
+  int result=raydium_sound_SourceVerify(src);
+  if(result==0 && raydium_sound_Array3IsValid(Vel))
+    {
+      alSourcefv(raydium_sound_source[src],AL_VELOCITY,Vel);
+      raydium_sound_verify("setting source velocity");
+    }
+  return(result);
 }
 
 //GETS SOURCE VELOCITY
@@ -366,13 +370,13 @@
 //GIVES AN ALfloat ARRAY {x,y,z}
 int raydium_sound_GetSourceVel(int src, ALfloat *Vel[] )
 {
- int result=raydium_sound_SourceVerify(src);
- if(result==0)
- {
-  alGetSourcefv(raydium_sound_source[src],AL_VELOCITY,(ALfloat *)&(*Vel));
-  raydium_sound_verify("getting source velocity");
- }
- return(result);
+  int result=raydium_sound_SourceVerify(src);
+  if(result==0)
+    {
+      alGetSourcefv(raydium_sound_source[src],AL_VELOCITY,(ALfloat *)&(*Vel));
+      raydium_sound_verify("getting source velocity");
+    }
+  return(result);
 }
 
 
@@ -381,18 +385,18 @@
 //TAKES AN ALfloat ARRAY {x,y,z}
 void raydium_sound_SetListenerPos(ALfloat Pos[])
 {
- if(!raydium_sound_Array3IsValid(Pos)) return;
+  if(!raydium_sound_Array3IsValid(Pos)) return;
  
- alListenerfv(AL_POSITION,Pos);
-   raydium_sound_verify("setting listener position");
+  alListenerfv(AL_POSITION,Pos);
+  raydium_sound_verify("setting listener position");
 }
 
 //GETS LISTENER POSITION
 //GIVES AN ALfloat ARRAY {x,y,z}
 void raydium_sound_GetListenerPos(ALfloat *Pos[] )
 {
- alGetListenerfv(AL_POSITION,(ALfloat *)&(*Pos));
-   raydium_sound_verify("getting listener position");
+  alGetListenerfv(AL_POSITION,(ALfloat *)&(*Pos));
+  raydium_sound_verify("getting listener position");
 }
 
 //SETS LISTENER ORIENTATION
@@ -400,11 +404,11 @@
 //                        ATvector UPvector
 void raydium_sound_SetListenerOr(ALfloat Or[])
 {
- if(!raydium_sound_Array3IsValid(Or)) return;
- if(!raydium_sound_Array3IsValid(Or+3)) return;
+  if(!raydium_sound_Array3IsValid(Or)) return;
+  if(!raydium_sound_Array3IsValid(Or+3)) return;
  
- alListenerfv(AL_ORIENTATION,Or);
-   raydium_sound_verify("setting listener orientation");
+  alListenerfv(AL_ORIENTATION,Or);
+  raydium_sound_verify("setting listener orientation");
 }
 
 //GETS LISTENER ORIENTATION
@@ -413,26 +417,26 @@
 void raydium_sound_GetListenerOr(ALfloat *Or[] )
 {
  
- alGetListenerfv(AL_ORIENTATION,(ALfloat *)&(*Or));
-   raydium_sound_verify("getting listener orientation");
+  alGetListenerfv(AL_ORIENTATION,(ALfloat *)&(*Or));
+  raydium_sound_verify("getting listener orientation");
 }
 
 //SETS LISTENER VELOCITY
 //TAKES AN ALfloat ARRAY {x,y,z}
 void raydium_sound_SetListenerVel(ALfloat Vel[])
 {
-if(!raydium_sound_Array3IsValid(Vel)) return;
+  if(!raydium_sound_Array3IsValid(Vel)) return;
 
- alListenerfv(AL_VELOCITY,Vel);
-   raydium_sound_verify("setting listener velocity");
+  alListenerfv(AL_VELOCITY,Vel);
+  raydium_sound_verify("setting listener velocity");
 }
 
 //GETS LISTENER VELOCITY
 //GIVES AN ALfloat ARRAY {x,y,z}
 void raydium_sound_GetListenerVel(ALfloat *Vel[] )
 {
- alGetListenerfv(AL_VELOCITY,(ALfloat *)&(*Vel));
-   raydium_sound_verify("getting listener velocity");
+  alGetListenerfv(AL_VELOCITY,(ALfloat *)&(*Vel));
+  raydium_sound_verify("getting listener velocity");
 }
 
 
@@ -440,193 +444,193 @@
 //INITIALISATION
 void raydium_sound_init(void)
 {
- int i;
- ALfloat listenerPos[]={-10.0,0.0,0.0};
- ALfloat listenerVel[]={0.0,0.0,0.0};
-// ALfloat back[] ={ 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f };
- ALfloat front[]={ 1.0f, 0.0f,  1.0f, 0.0f, 0.0f, 1.0f };
+  int i;
+  ALfloat listenerPos[]={-10.0,0.0,0.0};
+  ALfloat listenerVel[]={0.0,0.0,0.0};
+  // ALfloat back[] ={ 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f };
+  ALfloat front[]={ 1.0f, 0.0f,  1.0f, 0.0f, 0.0f, 1.0f };
 #ifdef ALUT_API_MAJOR_VERSION
- const ALchar *tempString;
- ALCdevice* pDevice;
- ALCcontext* pContext;
+  const ALchar *tempString;
+  ALCdevice* pDevice;
+  ALCcontext* pContext;
 #endif
  
 #ifdef NO_SOUND_DEBUG
-return;
+  return;
 #endif
 
 #ifndef WIN32
-// I've noticed problems with "manual contexts" under Linux, so let's use ALUT
+  // I've noticed problems with "manual contexts" under Linux, so let's use ALUT
 #ifdef ALUT_API_MAJOR_VERSION
-if(!alutInit(&raydium_init_argc, raydium_init_argv))
+  if(!alutInit(&raydium_init_argc, raydium_init_argv))
     {
-    alGetError();
-    raydium_log("ERROR: Cannot open Sound System");
-    raydium_sound=0;
-    return;
+      alGetError();
+      raydium_log("ERROR: Cannot open Sound System");
+      raydium_sound=0;
+      return;
     }
 #else
- alutInit(&raydium_init_argc, raydium_init_argv);
+  alutInit(&raydium_init_argc, raydium_init_argv);
 #endif
 
 #else
-// With win32, alut may do "bad things" while chosing device ... let's force :
- pDevice = alcOpenDevice("Generic Software"); // or any asked device name ?
- pContext=alcCreateContext(pDevice,NULL);
- alcMakeContextCurrent(pContext);
- alutInitWithoutContext(&raydium_init_argc, raydium_init_argv);
+  // With win32, alut may do "bad things" while chosing device ... let's force :
+  pDevice = alcOpenDevice("Generic Software"); // or any asked device name ?
+  pContext=alcCreateContext(pDevice,NULL);
+  alcMakeContextCurrent(pContext);
+  alutInitWithoutContext(&raydium_init_argc, raydium_init_argv);
 #endif
  
-//alutInit(0, NULL) ;
- alGetError();
+  //alutInit(0, NULL) ;
+  alGetError();
 
- alListenerfv(AL_POSITION,listenerPos);
- alListenerfv(AL_VELOCITY,listenerVel);
- alListenerfv(AL_ORIENTATION,front);
- alDistanceModel(AL_INVERSE_DISTANCE);
-//#ifdef __linux
- alGetError(); /* clear error */
- alGenBuffers(RAYDIUM_SOUND_NUM_BUFFERS, raydium_sound_buffer);
- raydium_sound_verify("alGenBuffers");
-//#else
-//alGenBuffers(RAYDIUM_SOUND_NUM_BUFFERS,raydium_sound_buffer);
-// if (!raydium_sound_buffer)
-// {
-//  raydium_log("sound: Error creating buffers !!");
-//  exit(1);
-// }
-//#endif
+  alListenerfv(AL_POSITION,listenerPos);
+  alListenerfv(AL_VELOCITY,listenerVel);
+  alListenerfv(AL_ORIENTATION,front);
+  alDistanceModel(AL_INVERSE_DISTANCE);
+  //#ifdef __linux
+  alGetError(); /* clear error */
+  alGenBuffers(RAYDIUM_SOUND_NUM_BUFFERS, raydium_sound_buffer);
+  raydium_sound_verify("alGenBuffers");
+  //#else
+  //alGenBuffers(RAYDIUM_SOUND_NUM_BUFFERS,raydium_sound_buffer);
+  // if (!raydium_sound_buffer)
+  // {
+  //  raydium_log("sound: Error creating buffers !!");
+  //  exit(1);
+  // }
+  //#endif
 
- raydium_log("sound: Buffer creation successfull");
+  raydium_log("sound: Buffer creation successfull");
 
-//#ifdef __linux
- alGetError(); /* clear error */
- alGenSources(RAYDIUM_SOUND_NUM_SOURCES, raydium_sound_source);
- raydium_sound_verify("alGenSources");
-//#else
-// raydium_sound_verify("alGenSources");
-//#endif
- raydium_sound_top_buffer=2; //first available buffer (2 first are used by music)
- raydium_sound=1;
- raydium_sound_music_file=NULL;
- raydium_sound_DefaultReferenceDistance=50.f; // default distance where the source sound is half volume
- raydium_sound_music_eof_callback=NULL;
- raydium_sound_music_changed_callback=NULL;
+  //#ifdef __linux
+  alGetError(); /* clear error */
+  alGenSources(RAYDIUM_SOUND_NUM_SOURCES, raydium_sound_source);
+  raydium_sound_verify("alGenSources");
+  //#else
+  // raydium_sound_verify("alGenSources");
+  //#endif
+  raydium_sound_top_buffer=2; //first available buffer (2 first are used by music)
+  raydium_sound=1;
+  raydium_sound_music_file=NULL;
+  raydium_sound_DefaultReferenceDistance=50.f; // default distance where the source sound is half volume
+  raydium_sound_music_eof_callback=NULL;
+  raydium_sound_music_changed_callback=NULL;
 
- for(i=0;i<RAYDIUM_SOUND_NUM_BUFFERS;i++)
+  for(i=0;i<RAYDIUM_SOUND_NUM_BUFFERS;i++)
     raydium_sound_source_fade_factor[i]=0;
 
 #ifdef ALUT_API_MAJOR_VERSION
- pContext = alcGetCurrentContext();
- pDevice = alcGetContextsDevice(pContext);
- tempString = alcGetString(pDevice, ALC_DEVICE_SPECIFIER);
- raydium_log("sound: OK, using '%s'",(strlen(tempString)?tempString:"default device"));
+  pContext = alcGetCurrentContext();
+  pDevice = alcGetContextsDevice(pContext);
+  tempString = alcGetString(pDevice, ALC_DEVICE_SPECIFIER);
+  raydium_log("sound: OK, using '%s'",(strlen(tempString)?tempString:"default device"));
 #else
- raydium_log("sound: OK");
+  raydium_log("sound: OK");
 #endif
-/* 
-{
-		const ALchar *tempString;
+  /* 
+     {
+     const ALchar *tempString;
 
-		ALCcontext* pContext;
-		ALCdevice* pDevice;
-		pContext = alcGetCurrentContext();
-		pDevice = alcGetContextsDevice(pContext);
-		tempString = alcGetString(pDevice, ALC_DEVICE_SPECIFIER);
-		printf("OpenAL Context Device Specifier is '%s'\n", tempString);
-		tempString = alGetString(AL_RENDERER);
-		printf("OpenAL Renderer is '%s'\n", tempString);
-		tempString = alGetString(AL_VERSION);
-		printf("OpenAL Version is '%s'\n", tempString);
-		tempString = alGetString(AL_VENDOR);
-		printf("OpenAL Vendor is '%s'\n", tempString);
-		tempString = alGetString(AL_EXTENSIONS);
-		printf("OpenAL Extensions supported are :\n%s\n", tempString);
-}    
-*/ 
-raydium_sound_music_info_init();
+     ALCcontext* pContext;
+     ALCdevice* pDevice;
+     pContext = alcGetCurrentContext();
+     pDevice = alcGetContextsDevice(pContext);
+     tempString = alcGetString(pDevice, ALC_DEVICE_SPECIFIER);
+     printf("OpenAL Context Device Specifier is '%s'\n", tempString);
+     tempString = alGetString(AL_RENDERER);
+     printf("OpenAL Renderer is '%s'\n", tempString);
+     tempString = alGetString(AL_VERSION);
+     printf("OpenAL Version is '%s'\n", tempString);
+     tempString = alGetString(AL_VENDOR);
+     printf("OpenAL Vendor is '%s'\n", tempString);
+     tempString = alGetString(AL_EXTENSIONS);
+     printf("OpenAL Extensions supported are :\n%s\n", tempString);
+     }    
+  */ 
+  raydium_sound_music_info_init();
 }
 
 //PLAYS A SOURCE
 int raydium_sound_SourcePlay(int src)
 {
- int result=raydium_sound_SourceVerify(src);
- if(result==0)
- {
-  alSourcePlay(raydium_sound_source[src]);
- }
- return(result);
+  int result=raydium_sound_SourceVerify(src);
+  if(result==0)
+    {
+      alSourcePlay(raydium_sound_source[src]);
+    }
+  return(result);
 }
 
 //STOPS A SOURCE
 int raydium_sound_SourceStop(int src)
 {
- int result=raydium_sound_SourceVerify(src);
- if(result==0)
- {
-  alSourceStop(raydium_sound_source[src]);
- }
- return(result);
+  int result=raydium_sound_SourceVerify(src);
+  if(result==0)
+    {
+      alSourceStop(raydium_sound_source[src]);
+    }
+  return(result);
 }
 
 //PAUSE A SOURCE
 int raydium_sound_SourcePause(int src)
 {
- int result=raydium_sound_SourceVerify(src);
- if(result==0)
- {
-  alSourcePause(raydium_sound_source[src]);
- }
- return(result);
+  int result=raydium_sound_SourceVerify(src);
+  if(result==0)
+    {
+      alSourcePause(raydium_sound_source[src]);
+    }
+  return(result);
 }
 
 //UNPAUSE A SOURCE
 int raydium_sound_SourceUnpause(int src)
 {
- int result;
- int state;
- result=raydium_sound_SourceVerify(src);
- if(result==0)
- {
-  alGetSourcei(raydium_sound_source[src], AL_SOURCE_STATE, &state);
-  if(state==AL_PAUSED)
-    alSourcePlay(raydium_sound_source[src]);
- }
- return(result);
+  int result;
+  int state;
+  result=raydium_sound_SourceVerify(src);
+  if(result==0)
+    {
+      alGetSourcei(raydium_sound_source[src], AL_SOURCE_STATE, &state);
+      if(state==AL_PAUSED)
+	alSourcePlay(raydium_sound_source[src]);
+    }
+  return(result);
 }
 
 
 //THINGS TO DO WHEN EXITING
 void raydium_sound_close(void)
 {
-int i;
+  int i;
 #ifdef WIN32
-ALCdevice* pDevice;
-ALCcontext* pContext;
+  ALCdevice* pDevice;
+  ALCcontext* pContext;
 #endif
     
- if(raydium_sound==1) // WE DO THESE THINGS ONLY IF OPEN AL INIT WAS OK
- {
-  for(i=0;i<raydium_sound_top_buffer;i++)
-    raydium_sound_SourceStop(i);
-  raydium_log("sound: Deleting sources");
-   alDeleteSources(RAYDIUM_SOUND_NUM_SOURCES,raydium_sound_source);
-  raydium_log("sound: Deleting buffers");
-   alDeleteBuffers(RAYDIUM_SOUND_NUM_BUFFERS,raydium_sound_buffer);
-  raydium_log("sound: Releasing OpenAL");
+  if(raydium_sound==1) // WE DO THESE THINGS ONLY IF OPEN AL INIT WAS OK
+    {
+      for(i=0;i<raydium_sound_top_buffer;i++)
+	raydium_sound_SourceStop(i);
+      raydium_log("sound: Deleting sources");
+      alDeleteSources(RAYDIUM_SOUND_NUM_SOURCES,raydium_sound_source);
+      raydium_log("sound: Deleting buffers");
+      alDeleteBuffers(RAYDIUM_SOUND_NUM_BUFFERS,raydium_sound_buffer);
+      raydium_log("sound: Releasing OpenAL");
    
 #ifdef WIN32
-  	//Get active context
-	pContext=alcGetCurrentContext();
-	//Get device for active context
-	pDevice=alcGetContextsDevice(pContext);
-	//Release context(s)
-	alcDestroyContext(pContext);
-	//Close device
-	alcCloseDevice(pDevice);
+      //Get active context
+      pContext=alcGetCurrentContext();
+      //Get device for active context
+      pDevice=alcGetContextsDevice(pContext);
+      //Release context(s)
+      alcDestroyContext(pContext);
+      //Close device
+      alcCloseDevice(pDevice);
 #endif
-  alutExit();
- }
+      alutExit();
+    }
 }
 
 
@@ -638,18 +642,17 @@
   ALint format;
 
   while(count<SOUNDDATASIZE)
-  {
-    amt=ov_read(file,&(raydium_sound_music_buf[count]),
-          SOUNDDATASIZE-count,
-          0,2,1,&stream);
-    if(amt<=0)
     {
-//      if(amt<0)fprintf(stderr,"ov_read error: ");
-      raydium_log("sound: ov_read error");
-      break;
+      amt=ov_read(file,&(raydium_sound_music_buf[count]),
+		  SOUNDDATASIZE-count,
+		  0,2,1,&stream);
+      if(amt<=0)
+	{
+	  raydium_log("sound: ov_read error");
+	  break;
+	}
+      count+=amt;
     }
-    count+=amt;
-  }
 
   if(!count)
     return 0;
@@ -660,35 +663,34 @@
     format=AL_FORMAT_STEREO16;
 
   alBufferData(buffer,format,raydium_sound_music_buf,count,ogginfo->rate);
-  //printf("buffered to %i buffer\n",buffer);
   return 1;
 }
 
 void raydium_sound_internal_cleanstreambuffs(void)
 {
-    ALint lProcessed;
-    ALuint TempBufferID;
+  ALint lProcessed;
+  ALuint TempBufferID;
 
-    alGetSourcei(raydium_sound_source[0], AL_BUFFERS_PROCESSED, &lProcessed);
-    //printf("%i -----\n",lProcessed);
-			while (lProcessed)
-			{
-                //printf(".");
-				alSourceUnqueueBuffers(raydium_sound_source[0], 1, &TempBufferID);
-                lProcessed--;
-			}
+  alGetSourcei(raydium_sound_source[0], AL_BUFFERS_PROCESSED, &lProcessed);
+  //printf("%i -----\n",lProcessed);
+  while (lProcessed)
+    {
+      //printf(".");
+      alSourceUnqueueBuffers(raydium_sound_source[0], 1, &TempBufferID);
+      lProcessed--;
+    }
 }
 
 
 int StartMusic(ALuint musicsource,ALuint *buffers,OggVorbis_File *file,
-      vorbis_info *ogginfo)
+	       vorbis_info *ogginfo)
 {
-  int ok;
-  alSourceStop(musicsource);
+  int ok;
+  alSourceStop(musicsource);
   raydium_sound_internal_cleanstreambuffs();
   memset(raydium_sound_music_buf,0,SOUNDDATASIZE);
-  ok=BufferData(raydium_sound_buffer[0],file,ogginfo) 
-     && BufferData(raydium_sound_buffer[1],file,ogginfo);
+  ok = BufferData(raydium_sound_buffer[0],file,ogginfo) 
+    && BufferData(raydium_sound_buffer[1],file,ogginfo);
   alSourceQueueBuffers(musicsource,2,raydium_sound_buffer);
   alSourcePlay(musicsource);
   return ok;
@@ -700,162 +702,160 @@
 int raydium_sound_load_music(char *fname)
 {
 #ifdef NO_SOUND_DEBUG
-return -1;
+  return -1;
 #endif
-if(!raydium_sound)
+  if(!raydium_sound)
     return -1;
 
-
-
- if(raydium_sound_music_file) fclose(raydium_sound_music_file);
- raydium_sound_music_file=NULL;
+  if(raydium_sound_music_file) fclose(raydium_sound_music_file);
+  raydium_sound_music_file=NULL;
  
- if(fname==NULL || strlen(fname)==0)
+  if(fname==NULL || strlen(fname)==0)
     {
-    // seems to fail ... :/
-    //raydium_sound_internal_cleanstreambuffs();
-    return 0;
+      // seems to fail ... :/
+      //raydium_sound_internal_cleanstreambuffs();
+      return 0;
     }
  
- raydium_sound_music_file = raydium_file_fopen( fname, "rb" );
- if(raydium_sound_music_file == NULL)
- {
-  raydium_log("sound: Could not open %s", fname);
-  perror("raydium_sound_load_music");
-  return(-1);
- }
+  raydium_sound_music_file = raydium_file_fopen( fname, "rb" );
+  if(raydium_sound_music_file == NULL)
+    {
+      raydium_log("sound: Could not open %s", fname);
+      perror("raydium_sound_load_music");
+      return(-1);
+    }
 
- alSourcei( raydium_sound_source[0], AL_SOURCE_RELATIVE, AL_TRUE );
- alSourcei( raydium_sound_source[0], AL_LOOPING, AL_FALSE );
- raydium_sound_SetSourceGain(0,1);
+  alSourcei( raydium_sound_source[0], AL_SOURCE_RELATIVE, AL_TRUE );
+  alSourcei( raydium_sound_source[0], AL_LOOPING, AL_FALSE );
+  raydium_sound_SetSourceGain(0,1);
 
 
- if(ov_open(raydium_sound_music_file, &raydium_sound_vf, NULL, 0) < 0)
- {
-  raydium_log("ERROR: Failed to open %s as vorbis",fname);
-  return(-1);
- }
- raydium_sound_ogginfo=ov_info(&raydium_sound_vf,-1);
- raydium_sound_music_info_refresh();
+  if(ov_open(raydium_sound_music_file, &raydium_sound_vf, NULL, 0) < 0)
+    {
+      raydium_log("ERROR: Failed to open %s as vorbis",fname);
+      return(-1);
+    }
+  raydium_sound_ogginfo=ov_info(&raydium_sound_vf,-1);
+  raydium_sound_music_info_refresh();
  
- if(raydium_sound_music_changed_callback)
+  if(raydium_sound_music_changed_callback)
     raydium_sound_music_changed_callback();
+
+  // size = bits/8 * ov_info(&raydium_sound_vf, 0)->channels; 
+  StartMusic(raydium_sound_source[0],raydium_sound_buffer,
+	     &raydium_sound_vf,raydium_sound_ogginfo);
  
-// size = bits/8 * ov_info(&raydium_sound_vf, 0)->channels; 
-StartMusic(raydium_sound_source[0],raydium_sound_buffer,
-           &raydium_sound_vf,raydium_sound_ogginfo);
- 
-return(0);
+  return(0);
 }
 
 
 void raydium_sound_music_callback(void)
 {
-ALint nprocessed;
-ALuint buffer;
-ALint sourcestate;
-char newfile[RAYDIUM_MAX_NAME_LEN];
+  ALint nprocessed;
+  ALuint buffer;
+  ALint sourcestate;
+  char newfile[RAYDIUM_MAX_NAME_LEN];
 
- if(raydium_sound_music_file==NULL) return;
+  if(raydium_sound_music_file==NULL) return;
 
- if(feof(raydium_sound_music_file))
+  if(feof(raydium_sound_music_file))
     {
-    fseek(raydium_sound_music_file,0,SEEK_SET);//rewind in the file if we hit the end
-    raydium_log("sound: end of file reached");
-    if(raydium_sound_music_eof_callback && raydium_sound_music_eof_callback(newfile)>0)
+      fseek(raydium_sound_music_file,0,SEEK_SET);//rewind in the file if we hit the end
+      raydium_log("sound: end of file reached");
+      if(raydium_sound_music_eof_callback && raydium_sound_music_eof_callback(newfile)>0)
 	{
-	if(strlen(newfile)) 
+	  if(strlen(newfile)) 
 	    raydium_sound_load_music(newfile);
-	else
+	  else
 	    {
-	    // may cause glitches on next music.. ?
-	    //fclose(raydium_sound_music_file);
-	    //raydium_sound_music_file=NULL;
-	    raydium_sound_load_music(NULL);
+	      // may cause glitches on next music.. ?
+	      //fclose(raydium_sound_music_file);
+	      //raydium_sound_music_file=NULL;
+	      raydium_sound_load_music(NULL);
 	    }
-	return ;
+	  return ;
 	}
     }
 
- alGetSourcei(raydium_sound_source[0],AL_BUFFERS_PROCESSED,&nprocessed);
- while(nprocessed)
- {
-  static int last;
-     alSourceUnqueueBuffers(raydium_sound_source[0],1,&buffer);
-        //printf("%i, buff = %i\n",nprocessed,buffer);
-  if(buffer==last)
+  alGetSourcei(raydium_sound_source[0],AL_BUFFERS_PROCESSED,&nprocessed);
+  while(nprocessed)
     {
-    alSourceStop(raydium_sound_source[0]);
-    }
-    else  
+      static int last;
+      alSourceUnqueueBuffers(raydium_sound_source[0],1,&buffer);
+      //printf("%i, buff = %i\n",nprocessed,buffer);
+      if(buffer==last)
+	{
+	  alSourceStop(raydium_sound_source[0]);
+	}
+      else  
+	{
+	  last=buffer;
+	  BufferData(buffer,&raydium_sound_vf,raydium_sound_ogginfo);
+	  alSourceQueueBuffers(raydium_sound_source[0],1,&buffer);
+	  nprocessed--;
+	}
+      alGetSourcei(raydium_sound_source[0],AL_BUFFERS_PROCESSED,&nprocessed);
+    } 
+
+  //restart playing if needed
+  alGetSourcei(raydium_sound_source[0],AL_SOURCE_STATE,&sourcestate);
+  if(sourcestate!=AL_PLAYING)
     {
-    last=buffer;
-    BufferData(buffer,&raydium_sound_vf,raydium_sound_ogginfo);
-    alSourceQueueBuffers(raydium_sound_source[0],1,&buffer);
-    nprocessed--;
-    }
- alGetSourcei(raydium_sound_source[0],AL_BUFFERS_PROCESSED,&nprocessed);
- } 
-
- //restart playing if needed
- alGetSourcei(raydium_sound_source[0],AL_SOURCE_STATE,&sourcestate);
- if(sourcestate!=AL_PLAYING)
- {
-    raydium_sound_internal_cleanstreambuffs();
-    alSourcePlay(raydium_sound_source[0]);
-    alGetSourcei(raydium_sound_source[0],AL_SOURCE_STATE,&sourcestate);
-     if(sourcestate!=AL_PLAYING)
+      raydium_sound_internal_cleanstreambuffs();
+      alSourcePlay(raydium_sound_source[0]);
+      alGetSourcei(raydium_sound_source[0],AL_SOURCE_STATE,&sourcestate);
+      if(sourcestate!=AL_PLAYING)
         StartMusic(raydium_sound_source[0],raydium_sound_buffer,
-           &raydium_sound_vf,raydium_sound_ogginfo);         
- } 
+		   &raydium_sound_vf,raydium_sound_ogginfo);         
+    } 
 
 }
 
 void raydium_sound_callback(void)
 {
-int i;
-ALfloat g;
-raydium_sound_music_callback();
+  int i;
+  ALfloat g;
+  raydium_sound_music_callback();
 
-// source fading ?
-for(i=0;i<raydium_sound_top_buffer;i++)
+  // source fading ?
+  for(i=0;i<raydium_sound_top_buffer;i++)
     if(raydium_sound_source_fade_factor[i]!=0)
-	{
+      {
 	raydium_sound_GetSourceGain(i,&g);
 	g+=(raydium_sound_source_fade_factor[i]*raydium_frame_time);
 	raydium_sound_SetSourceGain(i,g);
 	if(g<=0)
-	    {
+	  {
 	    raydium_sound_source_fade_factor[i]=0;
 	    
 	    if(i==0) // music source
-		{
+	      {
 		if(raydium_sound_source_fade_tofile[i][0]==0)
-		    {
+		  {
 		    raydium_sound_load_music(NULL);
-		    }
+		  }
 		else
-		    {
+		  {
 		    raydium_sound_load_music(raydium_sound_source_fade_tofile[i]);
 		    raydium_sound_source_fade_tofile[i][0]=0;
-		    }
-		}
+		  }
+	      }
 	    else
-		    raydium_sound_SourceStop(i);
-	    }
-	}
+	      raydium_sound_SourceStop(i);
+	  }
+      }
 }
 
 void raydium_sound_source_fade(int src, ALfloat len)
 {
-ALfloat g;
-// get current gain
-raydium_sound_GetSourceGain(src,&g);
-raydium_sound_source_fade_factor[src]=-(g/len);
+  ALfloat g;
+  // get current gain
+  raydium_sound_GetSourceGain(src,&g);
+  raydium_sound_source_fade_factor[src]=-(g/len);
 }
 
 void raydium_sound_source_fade_to(int src, ALfloat len, char *to)
 {
-raydium_sound_source_fade(src,len);
-strcpy(raydium_sound_source_fade_tofile[src],to);
+  raydium_sound_source_fade(src,len);
+  strcpy(raydium_sound_source_fade_tofile[src],to);
 }