--- a/src/audio/SDL_audio.c	Thu Jul 06 18:01:37 2006 +0000
+++ b/src/audio/SDL_audio.c	Mon Jul 10 21:04:37 2006 +0000
@@ -37,77 +37,77 @@
 /* Available audio drivers */
 static AudioBootStrap *bootstrap[] = {
 #if SDL_AUDIO_DRIVER_BSD
-	&BSD_AUDIO_bootstrap,
+    &BSD_AUDIO_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_OSS
-	&DSP_bootstrap,
-	&DMA_bootstrap,
+    &DSP_bootstrap,
+    &DMA_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_ALSA
-	&ALSA_bootstrap,
+    &ALSA_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_QNXNTO
-	&QNXNTOAUDIO_bootstrap,
+    &QNXNTOAUDIO_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_SUNAUDIO
-	&SUNAUDIO_bootstrap,
+    &SUNAUDIO_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_DMEDIA
-	&DMEDIA_bootstrap,
+    &DMEDIA_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_ARTS
-	&ARTS_bootstrap,
+    &ARTS_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_ESD
-	&ESD_bootstrap,
+    &ESD_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_NAS
-	&NAS_bootstrap,
+    &NAS_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_DSOUND
-	&DSOUND_bootstrap,
+    &DSOUND_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_WAVEOUT
-	&WAVEOUT_bootstrap,
+    &WAVEOUT_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_PAUD
-	&Paud_bootstrap,
+    &Paud_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_BAUDIO
-	&BAUDIO_bootstrap,
+    &BAUDIO_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_COREAUDIO
-	&COREAUDIO_bootstrap,
+    &COREAUDIO_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_SNDMGR
-	&SNDMGR_bootstrap,
+    &SNDMGR_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_AHI
-	&AHI_bootstrap,
+    &AHI_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_MINT
-	&MINTAUDIO_GSXB_bootstrap,
-	&MINTAUDIO_MCSN_bootstrap,
-	&MINTAUDIO_STFA_bootstrap,
-	&MINTAUDIO_XBIOS_bootstrap,
-	&MINTAUDIO_DMA8_bootstrap,
+    &MINTAUDIO_GSXB_bootstrap,
+    &MINTAUDIO_MCSN_bootstrap,
+    &MINTAUDIO_STFA_bootstrap,
+    &MINTAUDIO_XBIOS_bootstrap,
+    &MINTAUDIO_DMA8_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_DISK
-	&DISKAUD_bootstrap,
+    &DISKAUD_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_DUMMY
-	&DUMMYAUD_bootstrap,
+    &DUMMYAUD_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_DC
-	&DCAUD_bootstrap,
+    &DCAUD_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_MMEAUDIO
-	&MMEAUDIO_bootstrap,
+    &MMEAUDIO_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_DART
-	&DART_bootstrap,
+    &DART_bootstrap,
 #endif
-	NULL
+    NULL
 };
 SDL_AudioDevice *current_audio = NULL;
 
@@ -120,642 +120,684 @@
 #endif
 
 /* The general mixing thread function */
-int SDLCALL SDL_RunAudio(void *audiop)
+int SDLCALL
+SDL_RunAudio(void *audiop)
 {
-	SDL_AudioDevice *audio = (SDL_AudioDevice *)audiop;
-	Uint8 *stream;
-	int    stream_len;
-	void  *udata;
-	void (SDLCALL *fill)(void *userdata,Uint8 *stream, int len);
-	int    silence;
+    SDL_AudioDevice *audio = (SDL_AudioDevice *) audiop;
+    Uint8 *stream;
+    int stream_len;
+    void *udata;
+    void (SDLCALL * fill) (void *userdata, Uint8 * stream, int len);
+    int silence;
 #if SDL_AUDIO_DRIVER_AHI
-	int started = 0;
+    int started = 0;
 
 /* AmigaOS NEEDS that the audio driver is opened in the thread that uses it! */
 
-	D(bug("Task audio started audio struct:<%lx>...\n",audiop));
+    D(bug("Task audio started audio struct:<%lx>...\n", audiop));
 
-	D(bug("Before Openaudio..."));
-	if(audio->OpenAudio(audio, &audio->spec)==-1)
-	{
-		D(bug("Open audio failed...\n"));
-		return(-1);
-	}
-	D(bug("OpenAudio...OK\n"));
+    D(bug("Before Openaudio..."));
+    if (audio->OpenAudio(audio, &audio->spec) == -1) {
+        D(bug("Open audio failed...\n"));
+        return (-1);
+    }
+    D(bug("OpenAudio...OK\n"));
 #endif
 
-	/* Perform any thread setup */
-	if ( audio->ThreadInit ) {
-		audio->ThreadInit(audio);
-	}
-	audio->threadid = SDL_ThreadID();
+    /* Perform any thread setup */
+    if (audio->ThreadInit) {
+        audio->ThreadInit(audio);
+    }
+    audio->threadid = SDL_ThreadID();
 
-	/* Set up the mixing function */
-	fill  = audio->spec.callback;
-	udata = audio->spec.userdata;
+    /* Set up the mixing function */
+    fill = audio->spec.callback;
+    udata = audio->spec.userdata;
 
 #if SDL_AUDIO_DRIVER_AHI
-	audio_configured = 1;
+    audio_configured = 1;
 
-	D(bug("Audio configured... Checking for conversion\n"));
-	SDL_mutexP(audio->mixer_lock);
-	D(bug("Semaphore obtained...\n"));
+    D(bug("Audio configured... Checking for conversion\n"));
+    SDL_mutexP(audio->mixer_lock);
+    D(bug("Semaphore obtained...\n"));
 #endif
 
-	if ( audio->convert.needed ) {
-		if ( audio->convert.src_format == AUDIO_U8 ) {
-			silence = 0x80;
-		} else {
-			silence = 0;
-		}
-		stream_len = audio->convert.len;
-	} else {
-		silence = audio->spec.silence;
-		stream_len = audio->spec.size;
-	}
+    if (audio->convert.needed) {
+        if (audio->convert.src_format == AUDIO_U8) {
+            silence = 0x80;
+        } else {
+            silence = 0;
+        }
+        stream_len = audio->convert.len;
+    } else {
+        silence = audio->spec.silence;
+        stream_len = audio->spec.size;
+    }
 
 #if SDL_AUDIO_DRIVER_AHI
-	SDL_mutexV(audio->mixer_lock);
-	D(bug("Entering audio loop...\n"));
+    SDL_mutexV(audio->mixer_lock);
+    D(bug("Entering audio loop...\n"));
 #endif
 
 #ifdef __OS2__
-        /* Increase the priority of this thread to make sure that
-           the audio will be continuous all the time! */
+    /* Increase the priority of this thread to make sure that
+       the audio will be continuous all the time! */
 #ifdef USE_DOSSETPRIORITY
-        if (SDL_getenv("SDL_USE_TIMECRITICAL_AUDIO"))
-        {
+    if (SDL_getenv("SDL_USE_TIMECRITICAL_AUDIO")) {
 #ifdef DEBUG_BUILD
-          printf("[SDL_RunAudio] : Setting priority to TimeCritical+0! (TID%d)\n", SDL_ThreadID());
+        printf
+            ("[SDL_RunAudio] : Setting priority to TimeCritical+0! (TID%d)\n",
+             SDL_ThreadID());
 #endif
-          DosSetPriority(PRTYS_THREAD, PRTYC_TIMECRITICAL, 0, 0);
-        }
-        else
-        {
+        DosSetPriority(PRTYS_THREAD, PRTYC_TIMECRITICAL, 0, 0);
+    } else {
 #ifdef DEBUG_BUILD
-          printf("[SDL_RunAudio] : Setting priority to ForegroundServer+0! (TID%d)\n", SDL_ThreadID());
+        printf
+            ("[SDL_RunAudio] : Setting priority to ForegroundServer+0! (TID%d)\n",
+             SDL_ThreadID());
 #endif
-          DosSetPriority(PRTYS_THREAD, PRTYC_FOREGROUNDSERVER, 0, 0);
-        }
+        DosSetPriority(PRTYS_THREAD, PRTYC_FOREGROUNDSERVER, 0, 0);
+    }
 #endif
 #endif
 
-	/* Loop, filling the audio buffers */
-	while ( audio->enabled ) {
+    /* Loop, filling the audio buffers */
+    while (audio->enabled) {
 
-		/* Fill the current buffer with sound */
-		if ( audio->convert.needed ) {
-			if ( audio->convert.buf ) {
-				stream = audio->convert.buf;
-			} else {
-				continue;
-			}
-		} else {
-			stream = audio->GetAudioBuf(audio);
-			if ( stream == NULL ) {
-				stream = audio->fake_stream;
-			}
-		}
-		SDL_memset(stream, silence, stream_len);
+        /* Fill the current buffer with sound */
+        if (audio->convert.needed) {
+            if (audio->convert.buf) {
+                stream = audio->convert.buf;
+            } else {
+                continue;
+            }
+        } else {
+            stream = audio->GetAudioBuf(audio);
+            if (stream == NULL) {
+                stream = audio->fake_stream;
+            }
+        }
+        SDL_memset(stream, silence, stream_len);
 
-		if ( ! audio->paused ) {
-			SDL_mutexP(audio->mixer_lock);
-			(*fill)(udata, stream, stream_len);
-			SDL_mutexV(audio->mixer_lock);
-		}
+        if (!audio->paused) {
+            SDL_mutexP(audio->mixer_lock);
+            (*fill) (udata, stream, stream_len);
+            SDL_mutexV(audio->mixer_lock);
+        }
 
-		/* Convert the audio if necessary */
-		if ( audio->convert.needed ) {
-			SDL_ConvertAudio(&audio->convert);
-			stream = audio->GetAudioBuf(audio);
-			if ( stream == NULL ) {
-				stream = audio->fake_stream;
-			}
-			SDL_memcpy(stream, audio->convert.buf,
-			               audio->convert.len_cvt);
-		}
+        /* Convert the audio if necessary */
+        if (audio->convert.needed) {
+            SDL_ConvertAudio(&audio->convert);
+            stream = audio->GetAudioBuf(audio);
+            if (stream == NULL) {
+                stream = audio->fake_stream;
+            }
+            SDL_memcpy(stream, audio->convert.buf, audio->convert.len_cvt);
+        }
 
-		/* Ready current buffer for play and change current buffer */
-		if ( stream != audio->fake_stream ) {
-			audio->PlayAudio(audio);
-		}
+        /* Ready current buffer for play and change current buffer */
+        if (stream != audio->fake_stream) {
+            audio->PlayAudio(audio);
+        }
 
-		/* Wait for an audio buffer to become available */
-		if ( stream == audio->fake_stream ) {
-			SDL_Delay((audio->spec.samples*1000)/audio->spec.freq);
-		} else {
-			audio->WaitAudio(audio);
-		}
-	}
+        /* Wait for an audio buffer to become available */
+        if (stream == audio->fake_stream) {
+            SDL_Delay((audio->spec.samples * 1000) / audio->spec.freq);
+        } else {
+            audio->WaitAudio(audio);
+        }
+    }
 
-	/* Wait for the audio to drain.. */
-	if ( audio->WaitDone ) {
-		audio->WaitDone(audio);
-	}
-
+    /* Wait for the audio to drain.. */
+    if (audio->WaitDone) {
+        audio->WaitDone(audio);
+    }
 #if SDL_AUDIO_DRIVER_AHI
-	D(bug("WaitAudio...Done\n"));
+    D(bug("WaitAudio...Done\n"));
 
-	audio->CloseAudio(audio);
+    audio->CloseAudio(audio);
 
-	D(bug("CloseAudio..Done, subtask exiting...\n"));
-	audio_configured = 0;
+    D(bug("CloseAudio..Done, subtask exiting...\n"));
+    audio_configured = 0;
 #endif
 #ifdef __OS2__
 #ifdef DEBUG_BUILD
-        printf("[SDL_RunAudio] : Task exiting. (TID%d)\n", SDL_ThreadID());
+    printf("[SDL_RunAudio] : Task exiting. (TID%d)\n", SDL_ThreadID());
 #endif
 #endif
-	return(0);
+    return (0);
 }
 
-static void SDL_LockAudio_Default(SDL_AudioDevice *audio)
+static void
+SDL_LockAudio_Default(SDL_AudioDevice * audio)
 {
-	if ( audio->thread && (SDL_ThreadID() == audio->threadid) ) {
-		return;
-	}
-	SDL_mutexP(audio->mixer_lock);
+    if (audio->thread && (SDL_ThreadID() == audio->threadid)) {
+        return;
+    }
+    SDL_mutexP(audio->mixer_lock);
 }
 
-static void SDL_UnlockAudio_Default(SDL_AudioDevice *audio)
+static void
+SDL_UnlockAudio_Default(SDL_AudioDevice * audio)
 {
-	if ( audio->thread && (SDL_ThreadID() == audio->threadid) ) {
-		return;
-	}
-	SDL_mutexV(audio->mixer_lock);
+    if (audio->thread && (SDL_ThreadID() == audio->threadid)) {
+        return;
+    }
+    SDL_mutexV(audio->mixer_lock);
 }
 
-static Uint16 SDL_ParseAudioFormat(const char *string)
+static Uint16
+SDL_ParseAudioFormat(const char *string)
 {
-	Uint16 format = 0;
+    Uint16 format = 0;
 
-	switch (*string) {
-	    case 'U':
-		++string;
-		format |= 0x0000;
-		break;
-	    case 'S':
-		++string;
-		format |= 0x8000;
-		break;
-	    default:
-		return 0;
-	}
-	switch (SDL_atoi(string)) {
-	    case 8:
-		string += 1;
-		format |= 8;
-		break;
-	    case 16:
-		string += 2;
-		format |= 16;
-		if ( SDL_strcmp(string, "LSB") == 0
+    switch (*string) {
+    case 'U':
+        ++string;
+        format |= 0x0000;
+        break;
+    case 'S':
+        ++string;
+        format |= 0x8000;
+        break;
+    default:
+        return 0;
+    }
+    switch (SDL_atoi(string)) {
+    case 8:
+        string += 1;
+        format |= 8;
+        break;
+    case 16:
+        string += 2;
+        format |= 16;
+        if (SDL_strcmp(string, "LSB") == 0
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
-		     || SDL_strcmp(string, "SYS") == 0
+            || SDL_strcmp(string, "SYS") == 0
 #endif
-		    ) {
-			format |= 0x0000;
-		}
-		if ( SDL_strcmp(string, "MSB") == 0
+            ) {
+            format |= 0x0000;
+        }
+        if (SDL_strcmp(string, "MSB") == 0
 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-		     || SDL_strcmp(string, "SYS") == 0
+            || SDL_strcmp(string, "SYS") == 0
 #endif
-		    ) {
-			format |= 0x1000;
-		}
-		break;
-	    default:
-		return 0;
-	}
-	return format;
+            ) {
+            format |= 0x1000;
+        }
+        break;
+    default:
+        return 0;
+    }
+    return format;
+}
+
+int
+SDL_GetNumAudioDrivers(void)
+{
+    return (SDL_arraysize(bootstrap) - 1);
+}
+
+const char *
+SDL_GetAudioDriver(int index)
+{
+    if (index >= 0 && index < SDL_GetNumAudioDrivers()) {
+        return (bootstrap[index]->name);
+    }
+    return (NULL);
 }
 
-int SDL_AudioInit(const char *driver_name)
+int
+SDL_AudioInit(const char *driver_name)
 {
-	SDL_AudioDevice *audio;
-	int i = 0, idx;
+    SDL_AudioDevice *audio;
+    int i = 0, idx;
 
-	/* Check to make sure we don't overwrite 'current_audio' */
-	if ( current_audio != NULL ) {
-		SDL_AudioQuit();
-	}
+    /* Check to make sure we don't overwrite 'current_audio' */
+    if (current_audio != NULL) {
+        SDL_AudioQuit();
+    }
 
-	/* Select the proper audio driver */
-	audio = NULL;
-	idx = 0;
+    /* Select the proper audio driver */
+    audio = NULL;
+    idx = 0;
 #if SDL_AUDIO_DRIVER_ESD
-	if ( (driver_name == NULL) && (SDL_getenv("ESPEAKER") != NULL) ) {
-		/* Ahem, we know that if ESPEAKER is set, user probably wants
-		   to use ESD, but don't start it if it's not already running.
-		   This probably isn't the place to do this, but... Shh! :)
-		 */
-		for ( i=0; bootstrap[i]; ++i ) {
-			if ( SDL_strcmp(bootstrap[i]->name, "esd") == 0 ) {
+    if ((driver_name == NULL) && (SDL_getenv("ESPEAKER") != NULL)) {
+        /* Ahem, we know that if ESPEAKER is set, user probably wants
+           to use ESD, but don't start it if it's not already running.
+           This probably isn't the place to do this, but... Shh! :)
+         */
+        for (i = 0; bootstrap[i]; ++i) {
+            if (SDL_strcmp(bootstrap[i]->name, "esd") == 0) {
 #ifdef HAVE_PUTENV
-				const char *esd_no_spawn;
+                const char *esd_no_spawn;
 
-				/* Don't start ESD if it's not running */
-				esd_no_spawn = getenv("ESD_NO_SPAWN");
-				if ( esd_no_spawn == NULL ) {
-					putenv("ESD_NO_SPAWN=1");
-				}
+                /* Don't start ESD if it's not running */
+                esd_no_spawn = getenv("ESD_NO_SPAWN");
+                if (esd_no_spawn == NULL) {
+                    putenv("ESD_NO_SPAWN=1");
+                }
 #endif
-				if ( bootstrap[i]->available() ) {
-					audio = bootstrap[i]->create(0);
-					break;
-				}
+                if (bootstrap[i]->available()) {
+                    audio = bootstrap[i]->create(0);
+                    break;
+                }
 #ifdef HAVE_UNSETENV
-				if ( esd_no_spawn == NULL ) {
-					unsetenv("ESD_NO_SPAWN");
-				}
+                if (esd_no_spawn == NULL) {
+                    unsetenv("ESD_NO_SPAWN");
+                }
 #endif
-			}
-		}
-	}
+            }
+        }
+    }
 #endif /* SDL_AUDIO_DRIVER_ESD */
-	if ( audio == NULL ) {
-		if ( driver_name != NULL ) {
-#if 0	/* This will be replaced with a better driver selection API */
-			if ( SDL_strrchr(driver_name, ':') != NULL ) {
-				idx = atoi(SDL_strrchr(driver_name, ':')+1);
-			}
+    if (audio == NULL) {
+        if (driver_name != NULL) {
+#if 0                           /* This will be replaced with a better driver selection API */
+            if (SDL_strrchr(driver_name, ':') != NULL) {
+                idx = atoi(SDL_strrchr(driver_name, ':') + 1);
+            }
 #endif
-			for ( i=0; bootstrap[i]; ++i ) {
-				if (SDL_strncmp(bootstrap[i]->name, driver_name,
-				            SDL_strlen(bootstrap[i]->name)) == 0) {
-					if ( bootstrap[i]->available() ) {
-						audio=bootstrap[i]->create(idx);
-						break;
-					}
-				}
-			}
-		} else {
-			for ( i=0; bootstrap[i]; ++i ) {
-				if ( bootstrap[i]->available() ) {
-					audio = bootstrap[i]->create(idx);
-					if ( audio != NULL ) {
-						break;
-					}
-				}
-			}
-		}
-		if ( audio == NULL ) {
-			SDL_SetError("No available audio device");
-#if 0 /* Don't fail SDL_Init() if audio isn't available.
-         SDL_OpenAudio() will handle it at that point.  *sigh*
-       */
-			return(-1);
+            for (i = 0; bootstrap[i]; ++i) {
+                if (SDL_strncmp(bootstrap[i]->name, driver_name,
+                                SDL_strlen(bootstrap[i]->name)) == 0) {
+                    if (bootstrap[i]->available()) {
+                        audio = bootstrap[i]->create(idx);
+                    }
+                    break;
+                }
+            }
+        } else {
+            for (i = 0; bootstrap[i]; ++i) {
+                if (bootstrap[i]->available()) {
+                    audio = bootstrap[i]->create(idx);
+                    if (audio != NULL) {
+                        break;
+                    }
+                }
+            }
+        }
+        if (audio == NULL) {
+            if (driver_name) {
+                SDL_SetError("%s not available", driver_name);
+            } else {
+                SDL_SetError("No available audio device");
+            }
+#if 0                           /* Don't fail SDL_Init() if audio isn't available.
+                                   SDL_OpenAudio() will handle it at that point.  *sigh*
+                                 */
+            return (-1);
 #endif
-		}
-	}
-	current_audio = audio;
-	if ( current_audio ) {
-		current_audio->name = bootstrap[i]->name;
-		if ( !current_audio->LockAudio && !current_audio->UnlockAudio ) {
-			current_audio->LockAudio = SDL_LockAudio_Default;
-			current_audio->UnlockAudio = SDL_UnlockAudio_Default;
-		}
-	}
-	return(0);
+        }
+    }
+    current_audio = audio;
+    if (current_audio) {
+        current_audio->name = bootstrap[i]->name;
+        if (!current_audio->LockAudio && !current_audio->UnlockAudio) {
+            current_audio->LockAudio = SDL_LockAudio_Default;
+            current_audio->UnlockAudio = SDL_UnlockAudio_Default;
+        }
+    }
+    return (0);
 }
 
-char *SDL_AudioDriverName(char *namebuf, int maxlen)
+/*
+ * Get the current audio driver name
+ */
+const char *
+SDL_GetCurrentAudioDriver()
 {
-	if ( current_audio != NULL ) {
-		SDL_strlcpy(namebuf, current_audio->name, maxlen);
-		return(namebuf);
-	}
-	return(NULL);
+    if (current_audio) {
+        return current_audio->name;
+    }
+    return (NULL);
 }
 
-int SDL_OpenAudio(SDL_AudioSpec *desired, SDL_AudioSpec *obtained)
+int
+SDL_OpenAudio(SDL_AudioSpec * desired, SDL_AudioSpec * obtained)
 {
-	SDL_AudioDevice *audio;
-	const char *env;
+    SDL_AudioDevice *audio;
+    const char *env;
 
-	/* Start up the audio driver, if necessary */
-	if ( ! current_audio ) {
-		if ( (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) ||
-		     (current_audio == NULL) ) {
-			return(-1);
-		}
-	}
-	audio = current_audio;
+    /* Start up the audio driver, if necessary */
+    if (!current_audio) {
+        if ((SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) ||
+            (current_audio == NULL)) {
+            return (-1);
+        }
+    }
+    audio = current_audio;
 
-	if (audio->opened) {
-		SDL_SetError("Audio device is already opened");
-		return(-1);
-	}
+    if (audio->opened) {
+        SDL_SetError("Audio device is already opened");
+        return (-1);
+    }
 
-	/* Verify some parameters */
-	if ( desired->freq == 0 ) {
-		env = SDL_getenv("SDL_AUDIO_FREQUENCY");
-		if ( env ) {
-			desired->freq = SDL_atoi(env);
-		}
-	}
-	if ( desired->freq == 0 ) {
-		/* Pick some default audio frequency */
-		desired->freq = 22050;
-	}
-	if ( desired->format == 0 ) {
-		env = SDL_getenv("SDL_AUDIO_FORMAT");
-		if ( env ) {
-			desired->format = SDL_ParseAudioFormat(env);
-		}
-	}
-	if ( desired->format == 0 ) {
-		/* Pick some default audio format */
-		desired->format = AUDIO_S16;
-	}
-	if ( desired->channels == 0 ) {
-		env = SDL_getenv("SDL_AUDIO_CHANNELS");
-		if ( env ) {
-			desired->channels = SDL_atoi(env);
-		}
-	}
-	if ( desired->channels == 0 ) {
-		/* Pick a default number of channels */
-		desired->channels = 2;
-	}
-	switch ( desired->channels ) {
-	    case 1:	/* Mono */
-	    case 2:	/* Stereo */
-	    case 4:	/* surround */
-	    case 6:	/* surround with center and lfe */
-		break;
-	    default:
-		SDL_SetError("1 (mono) and 2 (stereo) channels supported");
-		return(-1);
-	}
-	if ( desired->samples == 0 ) {
-		env = SDL_getenv("SDL_AUDIO_SAMPLES");
-		if ( env ) {
-			desired->samples = SDL_atoi(env);
-		}
-	}
-	if ( desired->samples == 0 ) {
-		/* Pick a default of ~46 ms at desired frequency */
-		int samples = (desired->freq / 1000) * 46;
-		int power2 = 1;
-		while ( power2 < samples ) {
-			power2 *= 2;
-		}
-		desired->samples = power2;
-	}
-	if ( desired->callback == NULL ) {
-		SDL_SetError("SDL_OpenAudio() passed a NULL callback");
-		return(-1);
-	}
-
+    /* Verify some parameters */
+    if (desired->freq == 0) {
+        env = SDL_getenv("SDL_AUDIO_FREQUENCY");
+        if (env) {
+            desired->freq = SDL_atoi(env);
+        }
+    }
+    if (desired->freq == 0) {
+        /* Pick some default audio frequency */
+        desired->freq = 22050;
+    }
+    if (desired->format == 0) {
+        env = SDL_getenv("SDL_AUDIO_FORMAT");
+        if (env) {
+            desired->format = SDL_ParseAudioFormat(env);
+        }
+    }
+    if (desired->format == 0) {
+        /* Pick some default audio format */
+        desired->format = AUDIO_S16;
+    }
+    if (desired->channels == 0) {
+        env = SDL_getenv("SDL_AUDIO_CHANNELS");
+        if (env) {
+            desired->channels = SDL_atoi(env);
+        }
+    }
+    if (desired->channels == 0) {
+        /* Pick a default number of channels */
+        desired->channels = 2;
+    }
+    switch (desired->channels) {
+    case 1:                    /* Mono */
+    case 2:                    /* Stereo */
+    case 4:                    /* surround */
+    case 6:                    /* surround with center and lfe */
+        break;
+    default:
+        SDL_SetError("1 (mono) and 2 (stereo) channels supported");
+        return (-1);
+    }
+    if (desired->samples == 0) {
+        env = SDL_getenv("SDL_AUDIO_SAMPLES");
+        if (env) {
+            desired->samples = SDL_atoi(env);
+        }
+    }
+    if (desired->samples == 0) {
+        /* Pick a default of ~46 ms at desired frequency */
+        int samples = (desired->freq / 1000) * 46;
+        int power2 = 1;
+        while (power2 < samples) {
+            power2 *= 2;
+        }
+        desired->samples = power2;
+    }
+    if (desired->callback == NULL) {
+        SDL_SetError("SDL_OpenAudio() passed a NULL callback");
+        return (-1);
+    }
 #if defined(__MACOS__) || (defined(__RISCOS__) && SDL_THREADS_DISABLED)
-	/* FIXME: Need to implement PPC interrupt asm for SDL_LockAudio() */
+    /* FIXME: Need to implement PPC interrupt asm for SDL_LockAudio() */
 #else
 #if defined(__MINT__) && SDL_THREADS_DISABLED
-	/* Uses interrupt driven audio, without thread */
+    /* Uses interrupt driven audio, without thread */
 #else
-	/* Create a semaphore for locking the sound buffers */
-	audio->mixer_lock = SDL_CreateMutex();
-	if ( audio->mixer_lock == NULL ) {
-		SDL_SetError("Couldn't create mixer lock");
-		SDL_CloseAudio();
-		return(-1);
-	}
+    /* Create a semaphore for locking the sound buffers */
+    audio->mixer_lock = SDL_CreateMutex();
+    if (audio->mixer_lock == NULL) {
+        SDL_SetError("Couldn't create mixer lock");
+        SDL_CloseAudio();
+        return (-1);
+    }
 #endif /* __MINT__ */
 #endif /* __MACOS__ */
 
-	/* Calculate the silence and size of the audio specification */
-	SDL_CalculateAudioSpec(desired);
+    /* Calculate the silence and size of the audio specification */
+    SDL_CalculateAudioSpec(desired);
 
-	/* Open the audio subsystem */
-	SDL_memcpy(&audio->spec, desired, sizeof(audio->spec));
-	audio->convert.needed = 0;
-	audio->enabled = 1;
-	audio->paused  = 1;
+    /* Open the audio subsystem */
+    SDL_memcpy(&audio->spec, desired, sizeof(audio->spec));
+    audio->convert.needed = 0;
+    audio->enabled = 1;
+    audio->paused = 1;
 
 #if !SDL_AUDIO_DRIVER_AHI
 
 /* AmigaOS opens audio inside the main loop */
-	audio->opened = audio->OpenAudio(audio, &audio->spec)+1;
+    audio->opened = audio->OpenAudio(audio, &audio->spec) + 1;
 
-	if ( ! audio->opened ) {
-		SDL_CloseAudio();
-		return(-1);
-	}
+    if (!audio->opened) {
+        SDL_CloseAudio();
+        return (-1);
+    }
 #else
-	D(bug("Locking semaphore..."));
-	SDL_mutexP(audio->mixer_lock);
+    D(bug("Locking semaphore..."));
+    SDL_mutexP(audio->mixer_lock);
 
 
-	audio->thread = SDL_CreateThread(SDL_RunAudio, audio);
-	D(bug("Created thread...\n"));
+    audio->thread = SDL_CreateThread(SDL_RunAudio, audio);
+    D(bug("Created thread...\n"));
 
-	if ( audio->thread == NULL ) {
-		SDL_mutexV(audio->mixer_lock);
-		SDL_CloseAudio();
-		SDL_SetError("Couldn't create audio thread");
-		return(-1);
-	}
+    if (audio->thread == NULL) {
+        SDL_mutexV(audio->mixer_lock);
+        SDL_CloseAudio();
+        SDL_SetError("Couldn't create audio thread");
+        return (-1);
+    }
 
-	while(!audio_configured)
-		SDL_Delay(100);
+    while (!audio_configured)
+        SDL_Delay(100);
 #endif
 
-	/* If the audio driver changes the buffer size, accept it */
-	if ( audio->spec.samples != desired->samples ) {
-		desired->samples = audio->spec.samples;
-		SDL_CalculateAudioSpec(desired);
-	}
+    /* If the audio driver changes the buffer size, accept it */
+    if (audio->spec.samples != desired->samples) {
+        desired->samples = audio->spec.samples;
+        SDL_CalculateAudioSpec(desired);
+    }
 
-	/* Allocate a fake audio memory buffer */
-	audio->fake_stream = SDL_AllocAudioMem(audio->spec.size);
-	if ( audio->fake_stream == NULL ) {
-		SDL_CloseAudio();
-		SDL_OutOfMemory();
-		return(-1);
-	}
+    /* Allocate a fake audio memory buffer */
+    audio->fake_stream = SDL_AllocAudioMem(audio->spec.size);
+    if (audio->fake_stream == NULL) {
+        SDL_CloseAudio();
+        SDL_OutOfMemory();
+        return (-1);
+    }
 
-	/* See if we need to do any conversion */
-	if ( obtained != NULL ) {
-		SDL_memcpy(obtained, &audio->spec, sizeof(audio->spec));
-	} else if ( desired->freq != audio->spec.freq ||
-                    desired->format != audio->spec.format ||
-	            desired->channels != audio->spec.channels ) {
-		/* Build an audio conversion block */
-		if ( SDL_BuildAudioCVT(&audio->convert,
-			desired->format, desired->channels,
-					desired->freq,
-			audio->spec.format, audio->spec.channels,
-					audio->spec.freq) < 0 ) {
-			SDL_CloseAudio();
-			return(-1);
-		}
-		if ( audio->convert.needed ) {
-			audio->convert.len = desired->size;
-			audio->convert.buf =(Uint8 *)SDL_AllocAudioMem(
-			   audio->convert.len*audio->convert.len_mult);
-			if ( audio->convert.buf == NULL ) {
-				SDL_CloseAudio();
-				SDL_OutOfMemory();
-				return(-1);
-			}
-		}
-	}
-
+    /* See if we need to do any conversion */
+    if (obtained != NULL) {
+        SDL_memcpy(obtained, &audio->spec, sizeof(audio->spec));
+    } else if (desired->freq != audio->spec.freq ||
+               desired->format != audio->spec.format ||
+               desired->channels != audio->spec.channels) {
+        /* Build an audio conversion block */
+        if (SDL_BuildAudioCVT(&audio->convert,
+                              desired->format, desired->channels,
+                              desired->freq,
+                              audio->spec.format, audio->spec.channels,
+                              audio->spec.freq) < 0) {
+            SDL_CloseAudio();
+            return (-1);
+        }
+        if (audio->convert.needed) {
+            audio->convert.len = desired->size;
+            audio->convert.buf =
+                (Uint8 *) SDL_AllocAudioMem(audio->convert.len *
+                                            audio->convert.len_mult);
+            if (audio->convert.buf == NULL) {
+                SDL_CloseAudio();
+                SDL_OutOfMemory();
+                return (-1);
+            }
+        }
+    }
 #if !SDL_AUDIO_DRIVER_AHI
-	/* Start the audio thread if necessary */
-	switch (audio->opened) {
-		case  1:
-			/* Start the audio thread */
+    /* Start the audio thread if necessary */
+    switch (audio->opened) {
+    case 1:
+        /* Start the audio thread */
 #if (defined(__WIN32__) && !defined(_WIN32_WCE)) && !defined(HAVE_LIBC)
 #undef SDL_CreateThread
-			audio->thread = SDL_CreateThread(SDL_RunAudio, audio, NULL, NULL);
+        audio->thread = SDL_CreateThread(SDL_RunAudio, audio, NULL, NULL);
 #else
-			audio->thread = SDL_CreateThread(SDL_RunAudio, audio);
+        audio->thread = SDL_CreateThread(SDL_RunAudio, audio);
 #endif
-			if ( audio->thread == NULL ) {
-				SDL_CloseAudio();
-				SDL_SetError("Couldn't create audio thread");
-				return(-1);
-			}
-			break;
+        if (audio->thread == NULL) {
+            SDL_CloseAudio();
+            SDL_SetError("Couldn't create audio thread");
+            return (-1);
+        }
+        break;
 
-		default:
-			/* The audio is now playing */
-			break;
-	}
+    default:
+        /* The audio is now playing */
+        break;
+    }
 #else
-	SDL_mutexV(audio->mixer_lock);
-	D(bug("SDL_OpenAudio USCITA...\n"));
+    SDL_mutexV(audio->mixer_lock);
+    D(bug("SDL_OpenAudio USCITA...\n"));
 
 #endif
 
-	return(0);
+    return (0);
+}
+
+SDL_audiostatus
+SDL_GetAudioStatus(void)
+{
+    SDL_AudioDevice *audio = current_audio;
+    SDL_audiostatus status;
+
+    status = SDL_AUDIO_STOPPED;
+    if (audio && audio->enabled) {
+        if (audio->paused) {
+            status = SDL_AUDIO_PAUSED;
+        } else {
+            status = SDL_AUDIO_PLAYING;
+        }
+    }
+    return (status);
 }
 
-SDL_audiostatus SDL_GetAudioStatus(void)
+void
+SDL_PauseAudio(int pause_on)
 {
-	SDL_AudioDevice *audio = current_audio;
-	SDL_audiostatus status;
+    SDL_AudioDevice *audio = current_audio;
 
-	status = SDL_AUDIO_STOPPED;
-	if ( audio && audio->enabled ) {
-		if ( audio->paused ) {
-			status = SDL_AUDIO_PAUSED;
-		} else {
-			status = SDL_AUDIO_PLAYING;
-		}
-	}
-	return(status);
+    if (audio) {
+        audio->paused = pause_on;
+    }
 }
 
-void SDL_PauseAudio (int pause_on)
+void
+SDL_LockAudio(void)
 {
-	SDL_AudioDevice *audio = current_audio;
-
-	if ( audio ) {
-		audio->paused = pause_on;
-	}
-}
+    SDL_AudioDevice *audio = current_audio;
 
-void SDL_LockAudio (void)
-{
-	SDL_AudioDevice *audio = current_audio;
-
-	/* Obtain a lock on the mixing buffers */
-	if ( audio && audio->LockAudio ) {
-		audio->LockAudio(audio);
-	}
+    /* Obtain a lock on the mixing buffers */
+    if (audio && audio->LockAudio) {
+        audio->LockAudio(audio);
+    }
 }
 
-void SDL_UnlockAudio (void)
+void
+SDL_UnlockAudio(void)
 {
-	SDL_AudioDevice *audio = current_audio;
+    SDL_AudioDevice *audio = current_audio;
 
-	/* Release lock on the mixing buffers */
-	if ( audio && audio->UnlockAudio ) {
-		audio->UnlockAudio(audio);
-	}
+    /* Release lock on the mixing buffers */
+    if (audio && audio->UnlockAudio) {
+        audio->UnlockAudio(audio);
+    }
 }
 
-void SDL_CloseAudio (void)
+void
+SDL_CloseAudio(void)
 {
-	SDL_QuitSubSystem(SDL_INIT_AUDIO);
+    SDL_QuitSubSystem(SDL_INIT_AUDIO);
 }
 
-void SDL_AudioQuit(void)
+void
+SDL_AudioQuit(void)
 {
-	SDL_AudioDevice *audio = current_audio;
+    SDL_AudioDevice *audio = current_audio;
 
-	if ( audio ) {
-		audio->enabled = 0;
-		if ( audio->thread != NULL ) {
-			SDL_WaitThread(audio->thread, NULL);
-		}
-		if ( audio->mixer_lock != NULL ) {
-			SDL_DestroyMutex(audio->mixer_lock);
-		}
-		if ( audio->fake_stream != NULL ) {
-			SDL_FreeAudioMem(audio->fake_stream);
-		}
-		if ( audio->convert.needed ) {
-			SDL_FreeAudioMem(audio->convert.buf);
+    if (audio) {
+        audio->enabled = 0;
+        if (audio->thread != NULL) {
+            SDL_WaitThread(audio->thread, NULL);
+        }
+        if (audio->mixer_lock != NULL) {
+            SDL_DestroyMutex(audio->mixer_lock);
+        }
+        if (audio->fake_stream != NULL) {
+            SDL_FreeAudioMem(audio->fake_stream);
+        }
+        if (audio->convert.needed) {
+            SDL_FreeAudioMem(audio->convert.buf);
 
-		}
+        }
 #if !SDL_AUDIO_DRIVER_AHI
-		if ( audio->opened ) {
-			audio->CloseAudio(audio);
-			audio->opened = 0;
-		}
+        if (audio->opened) {
+            audio->CloseAudio(audio);
+            audio->opened = 0;
+        }
 #endif
-		/* Free the driver data */
-		audio->free(audio);
-		current_audio = NULL;
-	}
+        /* Free the driver data */
+        audio->free(audio);
+        current_audio = NULL;
+    }
 }
 
 #define NUM_FORMATS	6
 static int format_idx;
 static int format_idx_sub;
 static Uint16 format_list[NUM_FORMATS][NUM_FORMATS] = {
- { AUDIO_U8, AUDIO_S8, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB, AUDIO_U16MSB },
- { AUDIO_S8, AUDIO_U8, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB, AUDIO_U16MSB },
- { AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_U8, AUDIO_S8 },
- { AUDIO_S16MSB, AUDIO_S16LSB, AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_U8, AUDIO_S8 },
- { AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U8, AUDIO_S8 },
- { AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_S16MSB, AUDIO_S16LSB, AUDIO_U8, AUDIO_S8 },
+    {AUDIO_U8, AUDIO_S8, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB,
+     AUDIO_U16MSB},
+    {AUDIO_S8, AUDIO_U8, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB,
+     AUDIO_U16MSB},
+    {AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_U8,
+     AUDIO_S8},
+    {AUDIO_S16MSB, AUDIO_S16LSB, AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_U8,
+     AUDIO_S8},
+    {AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U8,
+     AUDIO_S8},
+    {AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_S16MSB, AUDIO_S16LSB, AUDIO_U8,
+     AUDIO_S8},
 };
 
-Uint16 SDL_FirstAudioFormat(Uint16 format)
+Uint16
+SDL_FirstAudioFormat(Uint16 format)
 {
-	for ( format_idx=0; format_idx < NUM_FORMATS; ++format_idx ) {
-		if ( format_list[format_idx][0] == format ) {
-			break;
-		}
-	}
-	format_idx_sub = 0;
-	return(SDL_NextAudioFormat());
+    for (format_idx = 0; format_idx < NUM_FORMATS; ++format_idx) {
+        if (format_list[format_idx][0] == format) {
+            break;
+        }
+    }
+    format_idx_sub = 0;
+    return (SDL_NextAudioFormat());
 }
 
-Uint16 SDL_NextAudioFormat(void)
+Uint16
+SDL_NextAudioFormat(void)
 {
-	if ( (format_idx == NUM_FORMATS) || (format_idx_sub == NUM_FORMATS) ) {
-		return(0);
-	}
-	return(format_list[format_idx][format_idx_sub++]);
+    if ((format_idx == NUM_FORMATS) || (format_idx_sub == NUM_FORMATS)) {
+        return (0);
+    }
+    return (format_list[format_idx][format_idx_sub++]);
 }
 
-void SDL_CalculateAudioSpec(SDL_AudioSpec *spec)
+void
+SDL_CalculateAudioSpec(SDL_AudioSpec * spec)
 {
-	switch (spec->format) {
-		case AUDIO_U8:
-			spec->silence = 0x80;
-			break;
-		default:
-			spec->silence = 0x00;
-			break;
-	}
-	spec->size = (spec->format&0xFF)/8;
-	spec->size *= spec->channels;
-	spec->size *= spec->samples;
+    switch (spec->format) {
+    case AUDIO_U8:
+        spec->silence = 0x80;
+        break;
+    default:
+        spec->silence = 0x00;
+        break;
+    }
+    spec->size = (spec->format & 0xFF) / 8;
+    spec->size *= spec->channels;
+    spec->size *= spec->samples;
 }
+
+/* vi: set ts=4 sw=4 expandtab: */