--- a/src/audio/esd/SDL_esdaudio.c	Sun Oct 01 16:10:41 2006 +0000
+++ b/src/audio/esd/SDL_esdaudio.c	Tue Oct 17 09:15:21 2006 +0000
@@ -33,7 +33,6 @@
 #include "SDL_audio.h"
 #include "../SDL_audiomem.h"
 #include "../SDL_audio_c.h"
-#include "../SDL_audiodev_c.h"
 #include "SDL_esdaudio.h"
 
 #ifdef SDL_AUDIO_DRIVER_ESD_DYNAMIC
@@ -46,40 +45,34 @@
 /* The tag name used by ESD audio */
 #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);
-
 #ifdef SDL_AUDIO_DRIVER_ESD_DYNAMIC
 
 static const char *esd_library = SDL_AUDIO_DRIVER_ESD_DYNAMIC;
 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);
+
+#define SDL_ESD_SYM(x) { #x, (void **) (char *) &SDL_NAME(x) }
 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)},};
+    SDL_ESD_SYM(esd_open_sound),
+    SDL_ESD_SYM(esd_close),
+    SDL_ESD_SYM(esd_play_stream),
+};
+#undef SDL_ESD_SYM
 
 static void
 UnloadESDLibrary()
 {
-    if (esd_loaded) {
+    if (esd_handle != NULL) {
         SDL_UnloadObject(esd_handle);
         esd_handle = NULL;
-        esd_loaded = 0;
     }
 }
 
@@ -88,17 +81,18 @@
 {
     int i, retval = -1;
 
-    esd_handle = SDL_LoadObject(esd_library);
-    if (esd_handle) {
-        esd_loaded = 1;
-        retval = 0;
-        for (i = 0; i < SDL_arraysize(esd_functions); ++i) {
-            *esd_functions[i].func =
-                SDL_LoadFunction(esd_handle, esd_functions[i].name);
-            if (!*esd_functions[i].func) {
-                retval = -1;
-                UnloadESDLibrary();
-                break;
+    if (esd_handle == NULL) {
+        esd_handle = SDL_LoadObject(esd_library);
+        if (esd_handle) {
+            retval = 0;
+            for (i = 0; i < SDL_arraysize(esd_functions); ++i) {
+                *esd_functions[i].func =
+                    SDL_LoadFunction(esd_handle, esd_functions[i].name);
+                if (!*esd_functions[i].func) {
+                    retval = -1;
+                    UnloadESDLibrary();
+                    break;
+                }
             }
         }
     }
@@ -121,78 +115,10 @@
 
 #endif /* SDL_AUDIO_DRIVER_ESD_DYNAMIC */
 
-/* Audio driver bootstrap functions */
-
-static int
-Audio_Available(void)
-{
-    int connection;
-    int available;
-
-    available = 0;
-    if (LoadESDLibrary() < 0) {
-        return available;
-    }
-    connection = SDL_NAME(esd_open_sound) (NULL);
-    if (connection >= 0) {
-        available = 1;
-        SDL_NAME(esd_close) (connection);
-    }
-    UnloadESDLibrary();
-    return (available);
-}
-
-static void
-Audio_DeleteDevice(SDL_AudioDevice * device)
-{
-    SDL_free(device->hidden);
-    SDL_free(device);
-    UnloadESDLibrary();
-}
-
-static SDL_AudioDevice *
-Audio_CreateDevice(int devindex)
-{
-    SDL_AudioDevice *this;
-
-    /* Initialize all variables that we clean on shutdown */
-    LoadESDLibrary();
-    this = (SDL_AudioDevice *) SDL_malloc(sizeof(SDL_AudioDevice));
-    if (this) {
-        SDL_memset(this, 0, (sizeof *this));
-        this->hidden = (struct SDL_PrivateAudioData *)
-            SDL_malloc((sizeof *this->hidden));
-    }
-    if ((this == NULL) || (this->hidden == NULL)) {
-        SDL_OutOfMemory();
-        if (this) {
-            SDL_free(this);
-        }
-        return (0);
-    }
-    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
-    audio_fd = -1;
-
-    /* Set the function pointers */
-    this->OpenAudio = ESD_OpenAudio;
-    this->WaitAudio = ESD_WaitAudio;
-    this->PlayAudio = ESD_PlayAudio;
-    this->GetAudioBuf = ESD_GetAudioBuf;
-    this->CloseAudio = ESD_CloseAudio;
-
-    this->free = Audio_DeleteDevice;
-
-    return this;
-}
-
-AudioBootStrap ESD_bootstrap = {
-    ESD_DRIVER_NAME, "Enlightened Sound Daemon",
-    Audio_Available, Audio_CreateDevice
-};
 
 /* This function waits until it is possible to write a full sound buffer */
 static void
-ESD_WaitAudio(_THIS)
+ESD_WaitDevice(_THIS)
 {
     Sint32 ticks;
 
@@ -202,28 +128,31 @@
         /* Note that this only works with thread implementations 
            that use a different process id for each thread.
          */
-        if (parent && (((++cnt) % 10) == 0)) {  /* Check every 10 loops */
-            if (kill(parent, 0) < 0) {
+        /* Check every 10 loops */
+        if (this->hidden->parent && (((++cnt) % 10) == 0)) {
+            if (kill(this->hidden->parent, 0) < 0) {
                 this->enabled = 0;
             }
         }
     }
 
     /* Use timer for general audio synchronization */
-    ticks = ((Sint32) (next_frame - SDL_GetTicks())) - FUDGE_TICKS;
+    ticks = ((Sint32) (this->hidden->next_frame-SDL_GetTicks())) - FUDGE_TICKS;
     if (ticks > 0) {
         SDL_Delay(ticks);
     }
 }
 
 static void
-ESD_PlayAudio(_THIS)
+ESD_PlayDevice(_THIS)
 {
-    int written;
+    int written = 0;
 
     /* Write the audio data, checking for EAGAIN on broken audio drivers */
     do {
-        written = write(audio_fd, mixbuf, mixlen);
+        written = write(this->hidden->audio_fd,
+                        this->hidden->mixbuf,
+                        this->hidden->mixlen);
         if ((written < 0) && ((errno == 0) || (errno == EAGAIN))) {
             SDL_Delay(1);       /* Let a little CPU time go by */
         }
@@ -232,7 +161,7 @@
            ((errno == 0) || (errno == EAGAIN) || (errno == EINTR)));
 
     /* Set the next write frame */
-    next_frame += frame_ticks;
+    this->hidden->next_frame += this->hidden->frame_ticks;
 
     /* If we couldn't write, assume fatal error for now */
     if (written < 0) {
@@ -241,21 +170,26 @@
 }
 
 static Uint8 *
-ESD_GetAudioBuf(_THIS)
+ESD_GetDeviceBuf(_THIS)
 {
-    return (mixbuf);
+    return (this->hidden->mixbuf);
 }
 
 static void
-ESD_CloseAudio(_THIS)
+ESD_CloseDevice(_THIS)
 {
-    if (mixbuf != NULL) {
-        SDL_FreeAudioMem(mixbuf);
-        mixbuf = NULL;
-    }
-    if (audio_fd >= 0) {
-        SDL_NAME(esd_close) (audio_fd);
-        audio_fd = -1;
+    if (this->hidden != NULL) {
+        if (this->hidden->mixbuf != NULL) {
+            SDL_FreeAudioMem(this->hidden->mixbuf);
+            this->hidden->mixbuf = NULL;
+        }
+        if (this->hidden->audio_fd >= 0) {
+            SDL_NAME(esd_close) (this->hidden->audio_fd);
+            this->hidden->audio_fd = -1;
+        }
+
+        SDL_free(this->hidden);
+        this->hidden = NULL;
     }
 }
 
@@ -285,59 +219,135 @@
     return (progname);
 }
 
+
 static int
-ESD_OpenAudio(_THIS, SDL_AudioSpec * spec)
+ESD_OpenDevice(_THIS, const char *devname, int iscapture)
 {
-    esd_format_t format;
+    esd_format_t format = (ESD_STREAM | ESD_PLAY);
+    SDL_AudioFormat test_format = 0;
+    int found = 0;
+
+    /* Initialize all variables that we clean on shutdown */
+    this->hidden = (struct SDL_PrivateAudioData *)
+                        SDL_malloc((sizeof *this->hidden));
+    if (this->hidden == NULL) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+    this->hidden->audio_fd = -1;
 
     /* Convert audio spec to the ESD audio format */
-    format = (ESD_STREAM | ESD_PLAY);
-    switch (spec->format & 0xFF) {
-    case 8:
-        format |= ESD_BITS8;
-        break;
-    case 16:
-        format |= ESD_BITS16;
-        break;
-    default:
-        SDL_SetError("Unsupported ESD audio format");
-        return (-1);
+    /* Try for a closest match on audio format */
+    for (test_format = SDL_FirstAudioFormat(this->spec.format);
+         !found && test_format; test_format = SDL_NextAudioFormat()) {
+#ifdef DEBUG_AUDIO
+        fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
+#endif
+        found = 1;
+        switch (test_format) {
+            case AUDIO_U8:
+                format |= ESD_BITS8;
+                break;
+            case AUDIO_S16SYS:
+                format |= ESD_BITS16;
+                break;
+            default:
+                found = 0;
+                break;
+        }
     }
-    if (spec->channels == 1) {
+
+    if (!found) {
+        ESD_CloseDevice(this);
+        SDL_SetError("Couldn't find any hardware audio formats");
+        return 0;
+    }
+
+    if (this->spec.channels == 1) {
         format |= ESD_MONO;
     } else {
         format |= ESD_STEREO;
     }
 #if 0
-    spec->samples = ESD_BUF_SIZE;       /* Darn, no way to change this yet */
+    this->spec.samples = ESD_BUF_SIZE;   /* Darn, no way to change this yet */
 #endif
 
     /* Open a connection to the ESD audio server */
-    audio_fd =
-        SDL_NAME(esd_play_stream) (format, spec->freq, NULL, get_progname());
-    if (audio_fd < 0) {
+    this->hidden->audio_fd =
+        SDL_NAME(esd_play_stream)(format,this->spec.freq,NULL,get_progname());
+
+    if (this->hidden->audio_fd < 0) {
+        ESD_CloseDevice(this);
         SDL_SetError("Couldn't open ESD connection");
-        return (-1);
+        return 0;
     }
 
     /* Calculate the final parameters for this audio specification */
-    SDL_CalculateAudioSpec(spec);
-    frame_ticks = (float) (spec->samples * 1000) / spec->freq;
-    next_frame = SDL_GetTicks() + frame_ticks;
+    SDL_CalculateAudioSpec(&this->spec);
+    this->hidden->frame_ticks = (float) (this->spec.samples*1000) / this->spec.freq;
+    this->hidden->next_frame = SDL_GetTicks() + this->hidden->frame_ticks;
 
     /* Allocate mixing buffer */
-    mixlen = spec->size;
-    mixbuf = (Uint8 *) SDL_AllocAudioMem(mixlen);
-    if (mixbuf == NULL) {
-        return (-1);
+    this->hidden->mixlen = this->spec.size;
+    this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);
+    if (this->hidden->mixbuf == NULL) {
+        ESD_CloseDevice(this);
+        SDL_OutOfMemory();
+        return 0;
     }
-    SDL_memset(mixbuf, spec->silence, spec->size);
+    SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);
 
     /* Get the parent process id (we're the parent of the audio thread) */
-    parent = getpid();
+    this->hidden->parent = getpid();
 
     /* We're ready to rock and roll. :-) */
-    return (0);
+    return 1;
+}
+
+static void
+ESD_Deinitialize(void)
+{
+    UnloadESDLibrary();
 }
 
+static int
+ESD_Init(SDL_AudioDriverImpl *impl)
+{
+    if (LoadESDLibrary() < 0) {
+        return 0;
+    } else {
+        int connection = 0;
+
+        /* Don't start ESD if it's not running */
+        if (SDL_getenv("ESD_NO_SPAWN") == NULL) {
+            SDL_putenv("ESD_NO_SPAWN=1");
+        }
+
+        connection = SDL_NAME(esd_open_sound) (NULL);
+        if (connection < 0) {
+            UnloadESDLibrary();
+            SDL_SetError("ESD: esd_open_sound failed (no audio server?)");
+            return 0;
+        }
+        SDL_NAME(esd_close) (connection);
+    }
+
+    /* Set the function pointers */
+    impl->OpenDevice = ESD_OpenDevice;
+    impl->PlayDevice = ESD_PlayDevice;
+    impl->WaitDevice = ESD_WaitDevice;
+    impl->GetDeviceBuf = ESD_GetDeviceBuf;
+    impl->CloseDevice = ESD_CloseDevice;
+    impl->Deinitialize = ESD_Deinitialize;
+    impl->OnlyHasDefaultOutputDevice = 1;
+
+    return 1;
+}
+
+
+AudioBootStrap ESD_bootstrap = {
+    ESD_DRIVER_NAME, "Enlightened Sound Daemon", ESD_Init, 0
+};
+
 /* vi: set ts=4 sw=4 expandtab: */