--- a/src/audio/paudio/SDL_paudio.c	Thu Jul 06 18:01:37 2006 +0000
+++ b/src/audio/paudio/SDL_paudio.c	Mon Jul 10 21:04:37 2006 +0000
@@ -55,7 +55,7 @@
 #define OPEN_FLAGS	O_WRONLY
 
 /* Audio driver functions */
-static int Paud_OpenAudio(_THIS, SDL_AudioSpec *spec);
+static int Paud_OpenAudio(_THIS, SDL_AudioSpec * spec);
 static void Paud_WaitAudio(_THIS);
 static void Paud_PlayAudio(_THIS);
 static Uint8 *Paud_GetAudioBuf(_THIS);
@@ -63,112 +63,116 @@
 
 /* Audio driver bootstrap functions */
 
-static int Audio_Available(void)
+static int
+Audio_Available(void)
 {
-	int fd;
-	int available;
+    int fd;
+    int available;
 
-	available = 0;
-	fd = SDL_OpenAudioPath(NULL, 0, OPEN_FLAGS, 0);
-	if ( fd >= 0 ) {
-		available = 1;
-		close(fd);
-	}
-	return(available);
+    available = 0;
+    fd = SDL_OpenAudioPath(NULL, 0, OPEN_FLAGS, 0);
+    if (fd >= 0) {
+        available = 1;
+        close(fd);
+    }
+    return (available);
 }
 
-static void Audio_DeleteDevice(SDL_AudioDevice *device)
+static void
+Audio_DeleteDevice(SDL_AudioDevice * device)
 {
-	SDL_free(device->hidden);
-	SDL_free(device);
+    SDL_free(device->hidden);
+    SDL_free(device);
 }
 
-static SDL_AudioDevice *Audio_CreateDevice(int devindex)
+static SDL_AudioDevice *
+Audio_CreateDevice(int devindex)
 {
-	SDL_AudioDevice *this;
+    SDL_AudioDevice *this;
 
-	/* Initialize all variables that we clean on shutdown */
-	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;
+    /* Initialize all variables that we clean on shutdown */
+    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 = Paud_OpenAudio;
-	this->WaitAudio = Paud_WaitAudio;
-	this->PlayAudio = Paud_PlayAudio;
-	this->GetAudioBuf = Paud_GetAudioBuf;
-	this->CloseAudio = Paud_CloseAudio;
+    /* Set the function pointers */
+    this->OpenAudio = Paud_OpenAudio;
+    this->WaitAudio = Paud_WaitAudio;
+    this->PlayAudio = Paud_PlayAudio;
+    this->GetAudioBuf = Paud_GetAudioBuf;
+    this->CloseAudio = Paud_CloseAudio;
 
-	this->free = Audio_DeleteDevice;
+    this->free = Audio_DeleteDevice;
 
-	return this;
+    return this;
 }
 
 AudioBootStrap Paud_bootstrap = {
-	Paud_DRIVER_NAME, "AIX Paudio",
-	Audio_Available, Audio_CreateDevice
+    Paud_DRIVER_NAME, "AIX Paudio",
+    Audio_Available, Audio_CreateDevice
 };
 
 /* This function waits until it is possible to write a full sound buffer */
-static void Paud_WaitAudio(_THIS)
+static void
+Paud_WaitAudio(_THIS)
 {
     fd_set fdset;
 
     /* See if we need to use timed audio synchronization */
-    if ( frame_ticks ) {
+    if (frame_ticks) {
         /* Use timer for general audio synchronization */
         Sint32 ticks;
 
-        ticks = ((Sint32)(next_frame - SDL_GetTicks()))-FUDGE_TICKS;
-        if ( ticks > 0 ) {
-	    SDL_Delay(ticks);
+        ticks = ((Sint32) (next_frame - SDL_GetTicks())) - FUDGE_TICKS;
+        if (ticks > 0) {
+            SDL_Delay(ticks);
         }
     } else {
-        audio_buffer  paud_bufinfo;
+        audio_buffer paud_bufinfo;
 
         /* Use select() for audio synchronization */
         struct timeval timeout;
         FD_ZERO(&fdset);
         FD_SET(audio_fd, &fdset);
 
-        if ( ioctl(audio_fd, AUDIO_BUFFER, &paud_bufinfo) < 0 ) {
+        if (ioctl(audio_fd, AUDIO_BUFFER, &paud_bufinfo) < 0) {
 #ifdef DEBUG_AUDIO
             fprintf(stderr, "Couldn't get audio buffer information\n");
 #endif
-            timeout.tv_sec  = 10;
+            timeout.tv_sec = 10;
             timeout.tv_usec = 0;
         } else {
-	    long ms_in_buf = paud_bufinfo.write_buf_time;
-            timeout.tv_sec  = ms_in_buf/1000;
-	    ms_in_buf       = ms_in_buf - timeout.tv_sec*1000;
-            timeout.tv_usec = ms_in_buf*1000;
+            long ms_in_buf = paud_bufinfo.write_buf_time;
+            timeout.tv_sec = ms_in_buf / 1000;
+            ms_in_buf = ms_in_buf - timeout.tv_sec * 1000;
+            timeout.tv_usec = ms_in_buf * 1000;
 #ifdef DEBUG_AUDIO
-            fprintf( stderr,
-		     "Waiting for write_buf_time=%ld,%ld\n",
-		     timeout.tv_sec,
-		     timeout.tv_usec );
+            fprintf(stderr,
+                    "Waiting for write_buf_time=%ld,%ld\n",
+                    timeout.tv_sec, timeout.tv_usec);
 #endif
-	}
+        }
 
 #ifdef DEBUG_AUDIO
         fprintf(stderr, "Waiting for audio to get ready\n");
 #endif
-        if ( select(audio_fd+1, NULL, &fdset, NULL, &timeout) <= 0 ) {
-            const char *message = "Audio timeout - buggy audio driver? (disabled)";
+        if (select(audio_fd + 1, NULL, &fdset, NULL, &timeout) <= 0) {
+            const char *message =
+                "Audio timeout - buggy audio driver? (disabled)";
             /*
-	     * In general we should never print to the screen,
+             * In general we should never print to the screen,
              * but in this case we have no other way of letting
              * the user know what happened.
              */
@@ -186,326 +190,326 @@
     }
 }
 
-static void Paud_PlayAudio(_THIS)
+static void
+Paud_PlayAudio(_THIS)
 {
-	int written;
+    int written;
 
-	/* Write the audio data, checking for EAGAIN on broken audio drivers */
-	do {
-		written = write(audio_fd, mixbuf, mixlen);
-		if ( (written < 0) && ((errno == 0) || (errno == EAGAIN)) ) {
-			SDL_Delay(1);	/* Let a little CPU time go by */
-		}
-	} while ( (written < 0) && 
-	          ((errno == 0) || (errno == EAGAIN) || (errno == EINTR)) );
+    /* Write the audio data, checking for EAGAIN on broken audio drivers */
+    do {
+        written = write(audio_fd, mixbuf, mixlen);
+        if ((written < 0) && ((errno == 0) || (errno == EAGAIN))) {
+            SDL_Delay(1);       /* Let a little CPU time go by */
+        }
+    }
+    while ((written < 0) &&
+           ((errno == 0) || (errno == EAGAIN) || (errno == EINTR)));
 
-	/* If timer synchronization is enabled, set the next write frame */
-	if ( frame_ticks ) {
-		next_frame += frame_ticks;
-	}
+    /* If timer synchronization is enabled, set the next write frame */
+    if (frame_ticks) {
+        next_frame += frame_ticks;
+    }
 
-	/* If we couldn't write, assume fatal error for now */
-	if ( written < 0 ) {
-		this->enabled = 0;
-	}
+    /* If we couldn't write, assume fatal error for now */
+    if (written < 0) {
+        this->enabled = 0;
+    }
 #ifdef DEBUG_AUDIO
-	fprintf(stderr, "Wrote %d bytes of audio data\n", written);
+    fprintf(stderr, "Wrote %d bytes of audio data\n", written);
 #endif
 }
 
-static Uint8 *Paud_GetAudioBuf(_THIS)
+static Uint8 *
+Paud_GetAudioBuf(_THIS)
 {
-	return mixbuf;
+    return mixbuf;
 }
 
-static void Paud_CloseAudio(_THIS)
+static void
+Paud_CloseAudio(_THIS)
 {
-	if ( mixbuf != NULL ) {
-		SDL_FreeAudioMem(mixbuf);
-		mixbuf = NULL;
-	}
-	if ( audio_fd >= 0 ) {
-		close(audio_fd);
-		audio_fd = -1;
-	}
+    if (mixbuf != NULL) {
+        SDL_FreeAudioMem(mixbuf);
+        mixbuf = NULL;
+    }
+    if (audio_fd >= 0) {
+        close(audio_fd);
+        audio_fd = -1;
+    }
 }
 
-static int Paud_OpenAudio(_THIS, SDL_AudioSpec *spec)
+static int
+Paud_OpenAudio(_THIS, SDL_AudioSpec * spec)
 {
-	char          audiodev[1024];
-	int           format;
-	int           bytes_per_sample;
-	Uint16        test_format;
-	audio_init    paud_init;
-	audio_buffer  paud_bufinfo;
-	audio_status  paud_status;
-	audio_control paud_control;
-	audio_change  paud_change;
+    char audiodev[1024];
+    int format;
+    int bytes_per_sample;
+    Uint16 test_format;
+    audio_init paud_init;
+    audio_buffer paud_bufinfo;
+    audio_status paud_status;
+    audio_control paud_control;
+    audio_change paud_change;
 
-	/* Reset the timer synchronization flag */
-	frame_ticks = 0.0;
+    /* Reset the timer synchronization flag */
+    frame_ticks = 0.0;
 
-	/* Open the audio device */
-	audio_fd = SDL_OpenAudioPath(audiodev, sizeof(audiodev), OPEN_FLAGS, 0);
-	if ( audio_fd < 0 ) {
-		SDL_SetError("Couldn't open %s: %s", audiodev, strerror(errno));
-		return -1;
-	}
+    /* Open the audio device */
+    audio_fd = SDL_OpenAudioPath(audiodev, sizeof(audiodev), OPEN_FLAGS, 0);
+    if (audio_fd < 0) {
+        SDL_SetError("Couldn't open %s: %s", audiodev, strerror(errno));
+        return -1;
+    }
 
-	/*
-	 * We can't set the buffer size - just ask the device for the maximum
-	 * that we can have.
-	 */
-	if ( ioctl(audio_fd, AUDIO_BUFFER, &paud_bufinfo) < 0 ) {
-		SDL_SetError("Couldn't get audio buffer information");
-		return -1;
-	}
+    /*
+     * We can't set the buffer size - just ask the device for the maximum
+     * that we can have.
+     */
+    if (ioctl(audio_fd, AUDIO_BUFFER, &paud_bufinfo) < 0) {
+        SDL_SetError("Couldn't get audio buffer information");
+        return -1;
+    }
 
-	mixbuf = NULL;
+    mixbuf = NULL;
 
-	if ( spec->channels > 1 )
-	    spec->channels = 2;
-	else
-	    spec->channels = 1;
+    if (spec->channels > 1)
+        spec->channels = 2;
+    else
+        spec->channels = 1;
 
-	/*
-	 * Fields in the audio_init structure:
-	 *
-	 * Ignored by us:
-	 *
-	 * paud.loadpath[LOAD_PATH]; * DSP code to load, MWave chip only?
-	 * paud.slot_number;         * slot number of the adapter
-	 * paud.device_id;           * adapter identification number
-	 *
-	 * Input:
-	 *
-	 * paud.srate;           * the sampling rate in Hz
-	 * paud.bits_per_sample; * 8, 16, 32, ...
-	 * paud.bsize;           * block size for this rate
-	 * paud.mode;            * ADPCM, PCM, MU_LAW, A_LAW, SOURCE_MIX
-	 * paud.channels;        * 1=mono, 2=stereo
-	 * paud.flags;           * FIXED - fixed length data
-	 *                       * LEFT_ALIGNED, RIGHT_ALIGNED (var len only)
-	 *                       * TWOS_COMPLEMENT - 2's complement data
-	 *                       * SIGNED - signed? comment seems wrong in sys/audio.h
-	 *                       * BIG_ENDIAN
-	 * paud.operation;       * PLAY, RECORD
-	 *
-	 * Output:
-	 *
-	 * paud.flags;           * PITCH            - pitch is supported
-	 *                       * INPUT            - input is supported
-	 *                       * OUTPUT           - output is supported
-	 *                       * MONITOR          - monitor is supported
-	 *                       * VOLUME           - volume is supported
-	 *                       * VOLUME_DELAY     - volume delay is supported
-	 *                       * BALANCE          - balance is supported
-	 *                       * BALANCE_DELAY    - balance delay is supported
-	 *                       * TREBLE           - treble control is supported
-	 *                       * BASS             - bass control is supported
-	 *                       * BESTFIT_PROVIDED - best fit returned
-	 *                       * LOAD_CODE        - DSP load needed
-	 * paud.rc;              * NO_PLAY         - DSP code can't do play requests
-	 *                       * NO_RECORD       - DSP code can't do record requests
-	 *                       * INVALID_REQUEST - request was invalid
-	 *                       * CONFLICT        - conflict with open's flags
-	 *                       * OVERLOADED      - out of DSP MIPS or memory
-	 * paud.position_resolution; * smallest increment for position
-	 */
+    /*
+     * Fields in the audio_init structure:
+     *
+     * Ignored by us:
+     *
+     * paud.loadpath[LOAD_PATH]; * DSP code to load, MWave chip only?
+     * paud.slot_number;         * slot number of the adapter
+     * paud.device_id;           * adapter identification number
+     *
+     * Input:
+     *
+     * paud.srate;           * the sampling rate in Hz
+     * paud.bits_per_sample; * 8, 16, 32, ...
+     * paud.bsize;           * block size for this rate
+     * paud.mode;            * ADPCM, PCM, MU_LAW, A_LAW, SOURCE_MIX
+     * paud.channels;        * 1=mono, 2=stereo
+     * paud.flags;           * FIXED - fixed length data
+     *                       * LEFT_ALIGNED, RIGHT_ALIGNED (var len only)
+     *                       * TWOS_COMPLEMENT - 2's complement data
+     *                       * SIGNED - signed? comment seems wrong in sys/audio.h
+     *                       * BIG_ENDIAN
+     * paud.operation;       * PLAY, RECORD
+     *
+     * Output:
+     *
+     * paud.flags;           * PITCH            - pitch is supported
+     *                       * INPUT            - input is supported
+     *                       * OUTPUT           - output is supported
+     *                       * MONITOR          - monitor is supported
+     *                       * VOLUME           - volume is supported
+     *                       * VOLUME_DELAY     - volume delay is supported
+     *                       * BALANCE          - balance is supported
+     *                       * BALANCE_DELAY    - balance delay is supported
+     *                       * TREBLE           - treble control is supported
+     *                       * BASS             - bass control is supported
+     *                       * BESTFIT_PROVIDED - best fit returned
+     *                       * LOAD_CODE        - DSP load needed
+     * paud.rc;              * NO_PLAY         - DSP code can't do play requests
+     *                       * NO_RECORD       - DSP code can't do record requests
+     *                       * INVALID_REQUEST - request was invalid
+     *                       * CONFLICT        - conflict with open's flags
+     *                       * OVERLOADED      - out of DSP MIPS or memory
+     * paud.position_resolution; * smallest increment for position
+     */
 
-        paud_init.srate = spec->freq;
-	paud_init.mode = PCM;
-	paud_init.operation = PLAY;
-	paud_init.channels = spec->channels;
+    paud_init.srate = spec->freq;
+    paud_init.mode = PCM;
+    paud_init.operation = PLAY;
+    paud_init.channels = spec->channels;
 
-	/* Try for a closest match on audio format */
-	format = 0;
-	for ( test_format = SDL_FirstAudioFormat(spec->format);
-						! format && test_format; ) {
+    /* Try for a closest match on audio format */
+    format = 0;
+    for (test_format = SDL_FirstAudioFormat(spec->format);
+         !format && test_format;) {
 #ifdef DEBUG_AUDIO
-		fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
+        fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
 #endif
-		switch ( test_format ) {
-			case AUDIO_U8:
-			    bytes_per_sample = 1;
-			    paud_init.bits_per_sample = 8;
-			    paud_init.flags = TWOS_COMPLEMENT | FIXED;
-			    format = 1;
-			    break;
-			case AUDIO_S8:
-			    bytes_per_sample = 1;
-			    paud_init.bits_per_sample = 8;
-			    paud_init.flags = SIGNED |
-					      TWOS_COMPLEMENT | FIXED;
-			    format = 1;
-			    break;
-			case AUDIO_S16LSB:
-			    bytes_per_sample = 2;
-			    paud_init.bits_per_sample = 16;
-			    paud_init.flags = SIGNED |
-					      TWOS_COMPLEMENT | FIXED;
-			    format = 1;
-			    break;
-			case AUDIO_S16MSB:
-			    bytes_per_sample = 2;
-			    paud_init.bits_per_sample = 16;
-			    paud_init.flags = BIG_ENDIAN |
-					      SIGNED |
-					      TWOS_COMPLEMENT | FIXED;
-			    format = 1;
-			    break;
-			case AUDIO_U16LSB:
-			    bytes_per_sample = 2;
-			    paud_init.bits_per_sample = 16;
-			    paud_init.flags = TWOS_COMPLEMENT | FIXED;
-			    format = 1;
-			    break;
-			case AUDIO_U16MSB:
-			    bytes_per_sample = 2;
-			    paud_init.bits_per_sample = 16;
-			    paud_init.flags = BIG_ENDIAN |
-					      TWOS_COMPLEMENT | FIXED;
-			    format = 1;
-			    break;
-			default:
-				break;
-		}
-		if ( ! format ) {
-			test_format = SDL_NextAudioFormat();
-		}
-	}
-	if ( format == 0 ) {
+        switch (test_format) {
+        case AUDIO_U8:
+            bytes_per_sample = 1;
+            paud_init.bits_per_sample = 8;
+            paud_init.flags = TWOS_COMPLEMENT | FIXED;
+            format = 1;
+            break;
+        case AUDIO_S8:
+            bytes_per_sample = 1;
+            paud_init.bits_per_sample = 8;
+            paud_init.flags = SIGNED | TWOS_COMPLEMENT | FIXED;
+            format = 1;
+            break;
+        case AUDIO_S16LSB:
+            bytes_per_sample = 2;
+            paud_init.bits_per_sample = 16;
+            paud_init.flags = SIGNED | TWOS_COMPLEMENT | FIXED;
+            format = 1;
+            break;
+        case AUDIO_S16MSB:
+            bytes_per_sample = 2;
+            paud_init.bits_per_sample = 16;
+            paud_init.flags = BIG_ENDIAN | SIGNED | TWOS_COMPLEMENT | FIXED;
+            format = 1;
+            break;
+        case AUDIO_U16LSB:
+            bytes_per_sample = 2;
+            paud_init.bits_per_sample = 16;
+            paud_init.flags = TWOS_COMPLEMENT | FIXED;
+            format = 1;
+            break;
+        case AUDIO_U16MSB:
+            bytes_per_sample = 2;
+            paud_init.bits_per_sample = 16;
+            paud_init.flags = BIG_ENDIAN | TWOS_COMPLEMENT | FIXED;
+            format = 1;
+            break;
+        default:
+            break;
+        }
+        if (!format) {
+            test_format = SDL_NextAudioFormat();
+        }
+    }
+    if (format == 0) {
 #ifdef DEBUG_AUDIO
-            fprintf(stderr, "Couldn't find any hardware audio formats\n");
+        fprintf(stderr, "Couldn't find any hardware audio formats\n");
 #endif
-	    SDL_SetError("Couldn't find any hardware audio formats");
-	    return -1;
-	}
-	spec->format = test_format;
+        SDL_SetError("Couldn't find any hardware audio formats");
+        return -1;
+    }
+    spec->format = test_format;
 
-	/*
-	 * We know the buffer size and the max number of subsequent writes
-	 * that can be pending. If more than one can pend, allow the application
-	 * to do something like double buffering between our write buffer and
-	 * the device's own buffer that we are filling with write() anyway.
-	 *
-	 * We calculate spec->samples like this because SDL_CalculateAudioSpec()
-	 * will give put paud_bufinfo.write_buf_cap (or paud_bufinfo.write_buf_cap/2)
-	 * into spec->size in return.
-	 */
-	if ( paud_bufinfo.request_buf_cap == 1 )
-	{
-	    spec->samples = paud_bufinfo.write_buf_cap
-			  / bytes_per_sample
-			  / spec->channels;
-	}
-	else
-	{
-	    spec->samples = paud_bufinfo.write_buf_cap
-			  / bytes_per_sample
-			  / spec->channels
-			  / 2;
-	}
-        paud_init.bsize = bytes_per_sample * spec->channels;
+    /*
+     * We know the buffer size and the max number of subsequent writes
+     * that can be pending. If more than one can pend, allow the application
+     * to do something like double buffering between our write buffer and
+     * the device's own buffer that we are filling with write() anyway.
+     *
+     * We calculate spec->samples like this because SDL_CalculateAudioSpec()
+     * will give put paud_bufinfo.write_buf_cap (or paud_bufinfo.write_buf_cap/2)
+     * into spec->size in return.
+     */
+    if (paud_bufinfo.request_buf_cap == 1) {
+        spec->samples = paud_bufinfo.write_buf_cap
+            / bytes_per_sample / spec->channels;
+    } else {
+        spec->samples = paud_bufinfo.write_buf_cap
+            / bytes_per_sample / spec->channels / 2;
+    }
+    paud_init.bsize = bytes_per_sample * spec->channels;
 
-	SDL_CalculateAudioSpec(spec);
+    SDL_CalculateAudioSpec(spec);
 
-	/*
-	 * The AIX paud device init can't modify the values of the audio_init
-	 * structure that we pass to it. So we don't need any recalculation
-	 * of this stuff and no reinit call as in linux dsp and dma code.
-	 *
-	 * /dev/paud supports all of the encoding formats, so we don't need
-	 * to do anything like reopening the device, either.
-	 */
-	if ( ioctl(audio_fd, AUDIO_INIT, &paud_init) < 0 ) {
-	    switch ( paud_init.rc )
-	    {
-	    case 1 :
-		SDL_SetError("Couldn't set audio format: DSP can't do play requests");
-		return -1;
-		break;
-	    case 2 :
-		SDL_SetError("Couldn't set audio format: DSP can't do record requests");
-		return -1;
-		break;
-	    case 4 :
-		SDL_SetError("Couldn't set audio format: request was invalid");
-		return -1;
-		break;
-	    case 5 :
-		SDL_SetError("Couldn't set audio format: conflict with open's flags");
-		return -1;
-		break;
-	    case 6 :
-		SDL_SetError("Couldn't set audio format: out of DSP MIPS or memory");
-		return -1;
-		break;
-	    default :
-		SDL_SetError("Couldn't set audio format: not documented in sys/audio.h");
-		return -1;
-		break;
-	    }
-	}
+    /*
+     * The AIX paud device init can't modify the values of the audio_init
+     * structure that we pass to it. So we don't need any recalculation
+     * of this stuff and no reinit call as in linux dsp and dma code.
+     *
+     * /dev/paud supports all of the encoding formats, so we don't need
+     * to do anything like reopening the device, either.
+     */
+    if (ioctl(audio_fd, AUDIO_INIT, &paud_init) < 0) {
+        switch (paud_init.rc) {
+        case 1:
+            SDL_SetError
+                ("Couldn't set audio format: DSP can't do play requests");
+            return -1;
+            break;
+        case 2:
+            SDL_SetError
+                ("Couldn't set audio format: DSP can't do record requests");
+            return -1;
+            break;
+        case 4:
+            SDL_SetError("Couldn't set audio format: request was invalid");
+            return -1;
+            break;
+        case 5:
+            SDL_SetError
+                ("Couldn't set audio format: conflict with open's flags");
+            return -1;
+            break;
+        case 6:
+            SDL_SetError
+                ("Couldn't set audio format: out of DSP MIPS or memory");
+            return -1;
+            break;
+        default:
+            SDL_SetError
+                ("Couldn't set audio format: not documented in sys/audio.h");
+            return -1;
+            break;
+        }
+    }
 
-	/* Allocate mixing buffer */
-	mixlen = spec->size;
-	mixbuf = (Uint8 *)SDL_AllocAudioMem(mixlen);
-	if ( mixbuf == NULL ) {
-		return -1;
-	}
-	SDL_memset(mixbuf, spec->silence, spec->size);
+    /* Allocate mixing buffer */
+    mixlen = spec->size;
+    mixbuf = (Uint8 *) SDL_AllocAudioMem(mixlen);
+    if (mixbuf == NULL) {
+        return -1;
+    }
+    SDL_memset(mixbuf, spec->silence, spec->size);
 
-	/*
-	 * Set some paramters: full volume, first speaker that we can find.
-	 * Ignore the other settings for now.
-	 */
-	paud_change.input = AUDIO_IGNORE;         /* the new input source */
-        paud_change.output = OUTPUT_1;            /* EXTERNAL_SPEAKER,INTERNAL_SPEAKER,OUTPUT_1 */
-        paud_change.monitor = AUDIO_IGNORE;       /* the new monitor state */
-        paud_change.volume = 0x7fffffff;          /* volume level [0-0x7fffffff] */
-        paud_change.volume_delay = AUDIO_IGNORE;  /* the new volume delay */
-        paud_change.balance = 0x3fffffff;         /* the new balance */
-        paud_change.balance_delay = AUDIO_IGNORE; /* the new balance delay */
-        paud_change.treble = AUDIO_IGNORE;        /* the new treble state */
-        paud_change.bass = AUDIO_IGNORE;          /* the new bass state */
-        paud_change.pitch = AUDIO_IGNORE;         /* the new pitch state */
+    /*
+     * Set some paramters: full volume, first speaker that we can find.
+     * Ignore the other settings for now.
+     */
+    paud_change.input = AUDIO_IGNORE;   /* the new input source */
+    paud_change.output = OUTPUT_1;      /* EXTERNAL_SPEAKER,INTERNAL_SPEAKER,OUTPUT_1 */
+    paud_change.monitor = AUDIO_IGNORE; /* the new monitor state */
+    paud_change.volume = 0x7fffffff;    /* volume level [0-0x7fffffff] */
+    paud_change.volume_delay = AUDIO_IGNORE;    /* the new volume delay */
+    paud_change.balance = 0x3fffffff;   /* the new balance */
+    paud_change.balance_delay = AUDIO_IGNORE;   /* the new balance delay */
+    paud_change.treble = AUDIO_IGNORE;  /* the new treble state */
+    paud_change.bass = AUDIO_IGNORE;    /* the new bass state */
+    paud_change.pitch = AUDIO_IGNORE;   /* the new pitch state */
 
-	paud_control.ioctl_request = AUDIO_CHANGE;
-	paud_control.request_info = (char*)&paud_change;
-	if ( ioctl(audio_fd, AUDIO_CONTROL, &paud_control) < 0 ) {
+    paud_control.ioctl_request = AUDIO_CHANGE;
+    paud_control.request_info = (char *) &paud_change;
+    if (ioctl(audio_fd, AUDIO_CONTROL, &paud_control) < 0) {
 #ifdef DEBUG_AUDIO
-            fprintf(stderr, "Can't change audio display settings\n" );
+        fprintf(stderr, "Can't change audio display settings\n");
 #endif
-	}
+    }
 
-	/*
-	 * Tell the device to expect data. Actual start will wait for
-	 * the first write() call.
-	 */
-	paud_control.ioctl_request = AUDIO_START;
-	paud_control.position = 0;
-	if ( ioctl(audio_fd, AUDIO_CONTROL, &paud_control) < 0 ) {
+    /*
+     * Tell the device to expect data. Actual start will wait for
+     * the first write() call.
+     */
+    paud_control.ioctl_request = AUDIO_START;
+    paud_control.position = 0;
+    if (ioctl(audio_fd, AUDIO_CONTROL, &paud_control) < 0) {
 #ifdef DEBUG_AUDIO
-            fprintf(stderr, "Can't start audio play\n" );
+        fprintf(stderr, "Can't start audio play\n");
 #endif
-	    SDL_SetError("Can't start audio play");
-	    return -1;
-	}
+        SDL_SetError("Can't start audio play");
+        return -1;
+    }
 
-        /* Check to see if we need to use select() workaround */
-        { char *workaround;
-                workaround = SDL_getenv("SDL_DSP_NOSELECT");
-                if ( workaround ) {
-                        frame_ticks = (float)(spec->samples*1000)/spec->freq;
-                        next_frame = SDL_GetTicks()+frame_ticks;
-                }
+    /* Check to see if we need to use select() workaround */
+    {
+        char *workaround;
+        workaround = SDL_getenv("SDL_DSP_NOSELECT");
+        if (workaround) {
+            frame_ticks = (float) (spec->samples * 1000) / spec->freq;
+            next_frame = SDL_GetTicks() + frame_ticks;
         }
+    }
 
-	/* Get the parent process id (we're the parent of the audio thread) */
-	parent = getpid();
+    /* Get the parent process id (we're the parent of the audio thread) */
+    parent = getpid();
 
-	/* We're ready to rock and roll. :-) */
-	return 0;
+    /* We're ready to rock and roll. :-) */
+    return 0;
 }
 
+/* vi: set ts=4 sw=4 expandtab: */