--- a/src/audio/esd/SDL_esdaudio.c	Mon May 29 03:53:21 2006 +0000
+++ b/src/audio/esd/SDL_esdaudio.c	Mon May 29 04:04:35 2006 +0000
@@ -47,11 +47,11 @@
 #define ESD_DRIVER_NAME		"esd"
 
 /* Audio driver functions */
-static int ESD_OpenAudio (_THIS, SDL_AudioSpec * spec);
-static void ESD_WaitAudio (_THIS);
-static void ESD_PlayAudio (_THIS);
-static Uint8 *ESD_GetAudioBuf (_THIS);
-static void ESD_CloseAudio (_THIS);
+static int ESD_OpenAudio(_THIS, SDL_AudioSpec * spec);
+static void ESD_WaitAudio(_THIS);
+static void ESD_PlayAudio(_THIS);
+static Uint8 *ESD_GetAudioBuf(_THIS);
+static void ESD_CloseAudio(_THIS);
 
 #ifdef SDL_AUDIO_DRIVER_ESD_DYNAMIC
 
@@ -59,45 +59,45 @@
 static void *esd_handle = NULL;
 static int esd_loaded = 0;
 
-static int (*SDL_NAME (esd_open_sound)) (const char *host);
-static int (*SDL_NAME (esd_close)) (int esd);
-static int (*SDL_NAME (esd_play_stream)) (esd_format_t format, int rate,
-                                          const char *host, const char *name);
+static int (*SDL_NAME(esd_open_sound)) (const char *host);
+static int (*SDL_NAME(esd_close)) (int esd);
+static int (*SDL_NAME(esd_play_stream)) (esd_format_t format, int rate,
+                                         const char *host, const char *name);
 static struct
 {
     const char *name;
     void **func;
 } esd_functions[] = {
     {
-    "esd_open_sound", (void **) &SDL_NAME (esd_open_sound)}, {
-    "esd_close", (void **) &SDL_NAME (esd_close)}, {
-"esd_play_stream", (void **) &SDL_NAME (esd_play_stream)},};
+    "esd_open_sound", (void **) &SDL_NAME(esd_open_sound)}, {
+    "esd_close", (void **) &SDL_NAME(esd_close)}, {
+"esd_play_stream", (void **) &SDL_NAME(esd_play_stream)},};
 
 static void
-UnloadESDLibrary ()
+UnloadESDLibrary()
 {
     if (esd_loaded) {
-        SDL_UnloadObject (esd_handle);
+        SDL_UnloadObject(esd_handle);
         esd_handle = NULL;
         esd_loaded = 0;
     }
 }
 
 static int
-LoadESDLibrary (void)
+LoadESDLibrary(void)
 {
     int i, retval = -1;
 
-    esd_handle = SDL_LoadObject (esd_library);
+    esd_handle = SDL_LoadObject(esd_library);
     if (esd_handle) {
         esd_loaded = 1;
         retval = 0;
-        for (i = 0; i < SDL_arraysize (esd_functions); ++i) {
+        for (i = 0; i < SDL_arraysize(esd_functions); ++i) {
             *esd_functions[i].func =
-                SDL_LoadFunction (esd_handle, esd_functions[i].name);
+                SDL_LoadFunction(esd_handle, esd_functions[i].name);
             if (!*esd_functions[i].func) {
                 retval = -1;
-                UnloadESDLibrary ();
+                UnloadESDLibrary();
                 break;
             }
         }
@@ -108,13 +108,13 @@
 #else
 
 static void
-UnloadESDLibrary ()
+UnloadESDLibrary()
 {
     return;
 }
 
 static int
-LoadESDLibrary (void)
+LoadESDLibrary(void)
 {
     return 0;
 }
@@ -124,53 +124,53 @@
 /* Audio driver bootstrap functions */
 
 static int
-Audio_Available (void)
+Audio_Available(void)
 {
     int connection;
     int available;
 
     available = 0;
-    if (LoadESDLibrary () < 0) {
+    if (LoadESDLibrary() < 0) {
         return available;
     }
-    connection = SDL_NAME (esd_open_sound) (NULL);
+    connection = SDL_NAME(esd_open_sound) (NULL);
     if (connection >= 0) {
         available = 1;
-        SDL_NAME (esd_close) (connection);
+        SDL_NAME(esd_close) (connection);
     }
-    UnloadESDLibrary ();
+    UnloadESDLibrary();
     return (available);
 }
 
 static void
-Audio_DeleteDevice (SDL_AudioDevice * device)
+Audio_DeleteDevice(SDL_AudioDevice * device)
 {
-    SDL_free (device->hidden);
-    SDL_free (device);
-    UnloadESDLibrary ();
+    SDL_free(device->hidden);
+    SDL_free(device);
+    UnloadESDLibrary();
 }
 
 static SDL_AudioDevice *
-Audio_CreateDevice (int devindex)
+Audio_CreateDevice(int devindex)
 {
     SDL_AudioDevice *this;
 
     /* Initialize all variables that we clean on shutdown */
-    LoadESDLibrary ();
-    this = (SDL_AudioDevice *) SDL_malloc (sizeof (SDL_AudioDevice));
+    LoadESDLibrary();
+    this = (SDL_AudioDevice *) SDL_malloc(sizeof(SDL_AudioDevice));
     if (this) {
-        SDL_memset (this, 0, (sizeof *this));
+        SDL_memset(this, 0, (sizeof *this));
         this->hidden = (struct SDL_PrivateAudioData *)
-            SDL_malloc ((sizeof *this->hidden));
+            SDL_malloc((sizeof *this->hidden));
     }
     if ((this == NULL) || (this->hidden == NULL)) {
-        SDL_OutOfMemory ();
+        SDL_OutOfMemory();
         if (this) {
-            SDL_free (this);
+            SDL_free(this);
         }
         return (0);
     }
-    SDL_memset (this->hidden, 0, (sizeof *this->hidden));
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
     audio_fd = -1;
 
     /* Set the function pointers */
@@ -192,7 +192,7 @@
 
 /* This function waits until it is possible to write a full sound buffer */
 static void
-ESD_WaitAudio (_THIS)
+ESD_WaitAudio(_THIS)
 {
     Sint32 ticks;
 
@@ -203,29 +203,29 @@
            that use a different process id for each thread.
          */
         if (parent && (((++cnt) % 10) == 0)) {  /* Check every 10 loops */
-            if (kill (parent, 0) < 0) {
+            if (kill(parent, 0) < 0) {
                 this->enabled = 0;
             }
         }
     }
 
     /* Use timer for general audio synchronization */
-    ticks = ((Sint32) (next_frame - SDL_GetTicks ())) - FUDGE_TICKS;
+    ticks = ((Sint32) (next_frame - SDL_GetTicks())) - FUDGE_TICKS;
     if (ticks > 0) {
-        SDL_Delay (ticks);
+        SDL_Delay(ticks);
     }
 }
 
 static void
-ESD_PlayAudio (_THIS)
+ESD_PlayAudio(_THIS)
 {
     int written;
 
     /* Write the audio data, checking for EAGAIN on broken audio drivers */
     do {
-        written = write (audio_fd, mixbuf, mixlen);
+        written = write(audio_fd, mixbuf, mixlen);
         if ((written < 0) && ((errno == 0) || (errno == EAGAIN))) {
-            SDL_Delay (1);      /* Let a little CPU time go by */
+            SDL_Delay(1);       /* Let a little CPU time go by */
         }
     }
     while ((written < 0) &&
@@ -241,52 +241,52 @@
 }
 
 static Uint8 *
-ESD_GetAudioBuf (_THIS)
+ESD_GetAudioBuf(_THIS)
 {
     return (mixbuf);
 }
 
 static void
-ESD_CloseAudio (_THIS)
+ESD_CloseAudio(_THIS)
 {
     if (mixbuf != NULL) {
-        SDL_FreeAudioMem (mixbuf);
+        SDL_FreeAudioMem(mixbuf);
         mixbuf = NULL;
     }
     if (audio_fd >= 0) {
-        SDL_NAME (esd_close) (audio_fd);
+        SDL_NAME(esd_close) (audio_fd);
         audio_fd = -1;
     }
 }
 
 /* Try to get the name of the program */
 static char *
-get_progname (void)
+get_progname(void)
 {
     char *progname = NULL;
 #ifdef __LINUX__
     FILE *fp;
     static char temp[BUFSIZ];
 
-    SDL_snprintf (temp, SDL_arraysize (temp), "/proc/%d/cmdline", getpid ());
-    fp = fopen (temp, "r");
+    SDL_snprintf(temp, SDL_arraysize(temp), "/proc/%d/cmdline", getpid());
+    fp = fopen(temp, "r");
     if (fp != NULL) {
-        if (fgets (temp, sizeof (temp) - 1, fp)) {
-            progname = SDL_strrchr (temp, '/');
+        if (fgets(temp, sizeof(temp) - 1, fp)) {
+            progname = SDL_strrchr(temp, '/');
             if (progname == NULL) {
                 progname = temp;
             } else {
                 progname = progname + 1;
             }
         }
-        fclose (fp);
+        fclose(fp);
     }
 #endif
     return (progname);
 }
 
 static int
-ESD_OpenAudio (_THIS, SDL_AudioSpec * spec)
+ESD_OpenAudio(_THIS, SDL_AudioSpec * spec)
 {
     esd_format_t format;
 
@@ -300,7 +300,7 @@
         format |= ESD_BITS16;
         break;
     default:
-        SDL_SetError ("Unsupported ESD audio format");
+        SDL_SetError("Unsupported ESD audio format");
         return (-1);
     }
     if (spec->channels == 1) {
@@ -314,28 +314,27 @@
 
     /* Open a connection to the ESD audio server */
     audio_fd =
-        SDL_NAME (esd_play_stream) (format, spec->freq, NULL,
-                                    get_progname ());
+        SDL_NAME(esd_play_stream) (format, spec->freq, NULL, get_progname());
     if (audio_fd < 0) {
-        SDL_SetError ("Couldn't open ESD connection");
+        SDL_SetError("Couldn't open ESD connection");
         return (-1);
     }
 
     /* Calculate the final parameters for this audio specification */
-    SDL_CalculateAudioSpec (spec);
+    SDL_CalculateAudioSpec(spec);
     frame_ticks = (float) (spec->samples * 1000) / spec->freq;
-    next_frame = SDL_GetTicks () + frame_ticks;
+    next_frame = SDL_GetTicks() + frame_ticks;
 
     /* Allocate mixing buffer */
     mixlen = spec->size;
-    mixbuf = (Uint8 *) SDL_AllocAudioMem (mixlen);
+    mixbuf = (Uint8 *) SDL_AllocAudioMem(mixlen);
     if (mixbuf == NULL) {
         return (-1);
     }
-    SDL_memset (mixbuf, spec->silence, spec->size);
+    SDL_memset(mixbuf, spec->silence, spec->size);
 
     /* Get the parent process id (we're the parent of the audio thread) */
-    parent = getpid ();
+    parent = getpid();
 
     /* We're ready to rock and roll. :-) */
     return (0);