(mostly )working audio - Will still need to resolve the 8bit unsigned source formats. Signed 16bit formats are working. Thanks to gligli

Author: lantus360

include/SDL_config_xenon.h

@@ -42,7 +42,7 @@ typedef unsigned int size_t;
 
 #define SDL_BYTEORDER           SDL_BIG_ENDIAN 
 #define SDL_LOADSO_DISABLED	1 
-#define SDL_THREADS_DISABLED	1       //ugh
+#define SDL_THREADS_XENON	1       //ugh
 #define SDL_AUDIO_DRIVER_XENON	1
 #define SDL_VIDEO_DRIVER_XENON	1
 #define SDL_HAS_64BIT_TYPE      1

src/SDL.c

@@ -152,7 +152,7 @@ int SDL_Init(Uint32 flags)
 
 #if defined (__XENON__)    
 	/* !!!! NOTE: THE CALLING CODE in main() needs to call these first !!!!*/
-        /* if SDL_Init() is called to late in the code with these functions it seems to crash libxenon **/
+        /* if SDL_Init() is called too late in the code with these functions it seems to crash libxenon **/
      	//xenon_make_it_faster(XENON_SPEED_FULL);
     	//xenos_init(VIDEO_MODE_AUTO);
         //xenon_sound_init();

src/audio/xenon/SDL_xenonaudio.c

@@ -29,8 +29,26 @@
 #include "SDL_audio_c.h"
 #include "SDL_xenonaudio.h"
 
+#define MAX_UNPLAYED 32768
+#define BUFFER_SIZE 65536
+ 
+static Uint32 dma_buffer[2048];
+ 
+static char buffer[BUFFER_SIZE]; 
+static unsigned int real_freq;
+static double freq_ratio;
+ 
+int buffer_size = 1024;
+
+static unsigned int thread_lock __attribute__ ((aligned (128))) =0;
 
+static unsigned char thread_stack[0x10000];
+static unsigned char thread_stack_get[0x10000];
 
+static volatile void * thread_buffer=NULL;
+static volatile int thread_bufsize=0;
+static int thread_bufmaxsize=0;
+static volatile int thread_terminate=0;
 
 /* Audio driver functions */
 static int XENON_OpenAudio(_THIS, SDL_AudioSpec *spec);
@@ -48,6 +66,49 @@ static int Audio_Available(void)
 	return(1);
 }
 
+static void inline play_buffer(void)
+{
+        int i;
+
+        while(xenon_sound_get_unplayed()>MAX_UNPLAYED);
+     
+        for(i=0;i<buffer_size/4;++i) ((int*)buffer)[i]=bswap_32(((int*)buffer)[i]);
+          
+        xenon_sound_submit(buffer,buffer_size);
+        
+         
+}
+
+static s16 prevLastSample[2]={0,0};
+
+void ResampleLinear(s16* pStereoSamples, s32 oldsamples, s16* pNewSamples, s32 newsamples)
+{
+        s32 newsampL, newsampR;
+        s32 i;
+         
+        for (i = 0; i < newsamples; ++i)
+        {
+                s32 io = i * oldsamples;
+                s32 old = io / newsamples;
+                s32 rem = io - old * newsamples;
+
+                old *= 2;
+ 
+                if (old==0){
+                        newsampL = prevLastSample[0] * (newsamples - rem) + pStereoSamples[0] * rem;
+                        newsampR = prevLastSample[1] * (newsamples - rem) + pStereoSamples[1] * rem;
+                }else{
+                        newsampL = pStereoSamples[old-2] * (newsamples - rem) + pStereoSamples[old] * rem;
+                        newsampR = pStereoSamples[old-1] * (newsamples - rem) + pStereoSamples[old+1] * rem;
+                }
+                
+                pNewSamples[2 * i] = newsampL / newsamples;
+                pNewSamples[2 * i + 1] = newsampR / newsamples;
+        }
+
+        prevLastSample[0]=pStereoSamples[oldsamples*2-2];
+        prevLastSample[1]=pStereoSamples[oldsamples*2-1];
+}
 
 static void XENON_Unload(void)
 {
@@ -116,76 +177,123 @@ static void XENON_WaitAudio_BusyWait(_THIS)
 
 static void XENON_PlayAudio(_THIS)
 {       
+              
+}
+ 
+static void XENON_WaitDone(_THIS)
+{
 
-	
-	//while(xenon_sound_get_unplayed()>(4*mixlen)) udelay(50);
-	
-         
-        //memcpy(&pAudioBuffers[currentBuffer * mixlen], locked_buf, mixlen);
-        //xenon_sound_submit(&pAudioBuffers[currentBuffer * mixlen], mixlen);
-         
 
-	currentBuffer++;
-	currentBuffer %= (NUM_BUFFERS);	       
+ 
+ 
 }
 
-static Uint8 *XENON_GetAudioBuf(_THIS)
-{       
-	return(locked_buf);
+static void XENON_CloseAudio(_THIS)
+{
+
+	
 }
 
-static void XENON_WaitDone(_THIS)
+static void thread_enqueue(void * buffer,int size)
 {
-	Uint8 *stream;
+        while(thread_bufsize);
+      
+        lock(&thread_lock);
 
-	/* Wait for the playing chunk to finish */
-	stream = this->GetAudioBuf(this);
-	if ( stream != NULL ) {
-	memset(stream, silence, mixlen);
-	this->PlayAudio(this);
-	}
-	this->WaitAudio(this);
+        if(thread_bufmaxsize<size){
+               thread_bufmaxsize=size;
+               thread_buffer=realloc((void*)thread_buffer,thread_bufmaxsize);
+        }
 
- 
- 
+        thread_bufsize=size;
+        memcpy((void*)thread_buffer,buffer,thread_bufsize);   
+        
+        unlock(&thread_lock);
+       
 }
 
-static void XENON_CloseAudio(_THIS)
+static void inline add_to_buffer(void* stream, unsigned int length){
+        unsigned int lengthLeft = length >> 2;
+        unsigned int rlengthLeft = ceil(lengthLeft / freq_ratio);
+        ResampleLinear((s16 *)stream,lengthLeft,(s16 *)buffer,rlengthLeft);
+        buffer_size=rlengthLeft<<2;
+        play_buffer();
+}
+
+static void thread_loop()
 {
+        static char * local_buffer[0x10000];
+        int local_bufsize=0;
+        int k;
+
+        while(!thread_terminate){
+            
+                short *stream = (short *)dma_buffer;
+                                     
+                // grab the audio
+                current_audio->spec.callback(
+                current_audio->spec.userdata,
+                (Uint8 *)dma_buffer,
+                2048);         
+                 
+                
+                // queue it up
+                thread_enqueue((short *)stream, 2048);            
+                                                                         
+                lock(&thread_lock);
+                              
+                if (thread_bufsize){                                                   
+                        local_bufsize=thread_bufsize;
+                        if (local_bufsize>sizeof(local_buffer)) local_bufsize=sizeof(local_buffer);
+                        memcpy(local_buffer,(void*)thread_buffer,local_bufsize);
+                        thread_bufsize-=local_bufsize;
+                }
+                
+                unlock(&thread_lock);
 
-	if (locked_buf)
-	{
-		free(locked_buf);
-		locked_buf = NULL;
-	}
+                if (local_bufsize){         
+                        add_to_buffer(local_buffer,local_bufsize);
+                        local_bufsize=0;
+                }
 
-	if (pAudioBuffers)
-	{
-		free(pAudioBuffers);
-		pAudioBuffers = NULL;
-	}
+                for(k=0;k<100;++k) asm volatile("nop");               
+        }
+}
+
+static Uint8 *XENON_GetAudioBuf(_THIS)
+{       
+ 
+	return NULL;
 }
 
 static int XENON_OpenAudio(_THIS, SDL_AudioSpec *spec)
 {
-
-	// Set up actual spec.
-        spec->freq      = 48000;
+        
+        spec->freq      = 32000;
         spec->format    = AUDIO_S16MSB;
-        spec->channels  = 2;        
+        spec->channels  = 2;      
+        
+        freq_ratio = (double)spec->freq / 48000;        
 
 	/* Update the fragment size as size in bytes */
 	SDL_CalculateAudioSpec(spec);
- 
-	locked_buf = (unsigned char *)malloc(spec->size);
-	 
-	/* Create the audio buffer to which we write */
-	NUM_BUFFERS = 2;
-
-
-	pAudioBuffers = (unsigned char *)malloc(spec->size *NUM_BUFFERS);
+        
+      
  	playing = 0;
 	mixlen = spec->size;
 
-	return(0);
+        thread_lock=0;
+        thread_buffer=NULL;
+        thread_bufsize=0;
+        thread_bufmaxsize=0;
+        thread_terminate=0;
+
+        // Semaphores/Mutexes dont exist yet in libXenon so we dont want libSDL to handle
+        // the threading. Instead create our own thread here to handle the audio.
+ 
+        xenon_run_thread_task(1,&thread_stack[sizeof(thread_stack)-0x100],thread_loop); 
+                
+        // 1 means that libSDL wont call SDL_CreateThread();
+        
+	return(1);              
 }

src/audio/xenon/SDL_xenonaudio.h

@@ -22,9 +22,10 @@
 
 #ifndef _SDL_xenonaudio_h
 #define _SDL_xenonaudio_h
-
+ 
+#include <math.h>
 #include <xenon_sound/sound.h>
-
+#include <byteswap.h>
 #include "SDL_sysaudio.h"
 
 /* Hidden "this" pointer for the video functions */
@@ -34,9 +35,7 @@ struct SDL_PrivateAudioData {
 	int NUM_BUFFERS;
 	int mixlen, silence;
 	int currentBuffer;
-	long playing;
-	Uint8 *locked_buf;
-	unsigned char* pAudioBuffers; 
+	long playing;	 
 };
 
 #define sound			(this->hidden->sound)
@@ -45,10 +44,8 @@ struct SDL_PrivateAudioData {
 #define NUM_BUFFERS		(this->hidden->NUM_BUFFERS)
 #define mixlen			(this->hidden->mixlen)
 #define silence			(this->hidden->silence)
-#define playing			(this->hidden->playing)
-#define locked_buf		(this->hidden->locked_buf)
-#define audio_event		(this->hidden->audio_event)
-#define pAudioBuffers	(this->hidden->pAudioBuffers)
+#define playing			(this->hidden->playing) 
+#define audio_event		(this->hidden->audio_event) 
 #define currentBuffer	(this->hidden->currentBuffer)
 
 #endif /* _SDL_xenonaudio_h */

src/joystick/SDL_joystick.c

@@ -538,8 +538,8 @@ int SDL_PrivateJoystickButton(SDL_Joystick *joystick, Uint8 button, Uint8 state)
 void SDL_JoystickUpdate(void)
 {
 	int i;
-
-	for ( i=0; SDL_joysticks[i]; ++i ) {
+          
+	for ( i=0; SDL_joysticks[i]; ++i ) {                
 		SDL_SYS_JoystickUpdate(SDL_joysticks[i]);
 	}
 }

src/joystick/xenon/SDL_xenonjoystick.c

@@ -22,8 +22,7 @@ char joyName[50];
 /* The private structure used to keep track of a joystick */
 struct joystick_hwdata
 { 
-        struct controller_data_s curpad;
-        struct controller_data_s oldpad;
+        struct controller_data_s curpad;      
 
 };
 
@@ -59,6 +58,7 @@ int SDL_SYS_JoystickOpen(SDL_Joystick *joystick)
         joystick->nbuttons = MAX_BUTTONS;
         joystick->naxes = MAX_AXES;
         joystick->nhats = MAX_HATS;
+        joystick->name  = "XENON SDL Gamepad";
         return(0);
 }
 
@@ -289,7 +289,7 @@ void SDL_SYS_JoystickUpdate(SDL_Joystick *joystick)
                 SDL_PrivateJoystickAxis(joystick, (Uint8)3, (Sint16)nYR);
 
 
-        joystick->hwdata->oldpad = joystick->hwdata->curpad;
+        //joystick->hwdata->oldpad = joystick->hwdata->curpad;
 }
 
 void SDL_SYS_JoystickClose(SDL_Joystick *joystick)

src/thread/xenon/SDL_syssem.c

@@ -43,8 +43,7 @@ SDL_sem *SDL_CreateSemaphore(Uint32 initial_value)
 		return NULL;
 	}
 	sem->count = initial_value;
-	sem->waiters_count = 0;
-        
+	sem->waiters_count = 0;       
 	return sem;
 }
 
@@ -68,7 +67,7 @@ int SDL_SemWaitTimeout(SDL_sem *sem, Uint32 timeout)
 {
 	int retval = 0;
 
-	 
+        SDL_Delay(timeout);
 
 	return retval;
 }