--- a/src/audio/ums/SDL_umsaudio.c	Thu Jul 06 18:01:37 2006 +0000
+++ b/src/audio/ums/SDL_umsaudio.c	Mon Jul 10 21:04:37 2006 +0000
@@ -45,50 +45,64 @@
 #define DEBUG_AUDIO 1
 
 /* Audio driver functions */
-static int UMS_OpenAudio(_THIS, SDL_AudioSpec *spec);
+static int UMS_OpenAudio(_THIS, SDL_AudioSpec * spec);
 static void UMS_PlayAudio(_THIS);
 static Uint8 *UMS_GetAudioBuf(_THIS);
 static void UMS_CloseAudio(_THIS);
 
-static UMSAudioDevice_ReturnCode UADOpen(_THIS,  string device, string mode, long flags);
+static UMSAudioDevice_ReturnCode UADOpen(_THIS, string device, string mode,
+                                         long flags);
 static UMSAudioDevice_ReturnCode UADClose(_THIS);
-static UMSAudioDevice_ReturnCode UADGetBitsPerSample(_THIS, long* bits);
+static UMSAudioDevice_ReturnCode UADGetBitsPerSample(_THIS, long *bits);
 static UMSAudioDevice_ReturnCode UADSetBitsPerSample(_THIS, long bits);
-static UMSAudioDevice_ReturnCode UADSetSampleRate(_THIS, long rate, long* set_rate);
+static UMSAudioDevice_ReturnCode UADSetSampleRate(_THIS, long rate,
+                                                  long *set_rate);
 static UMSAudioDevice_ReturnCode UADSetByteOrder(_THIS, string byte_order);
 static UMSAudioDevice_ReturnCode UADSetAudioFormatType(_THIS, string fmt);
 static UMSAudioDevice_ReturnCode UADSetNumberFormat(_THIS, string fmt);
 static UMSAudioDevice_ReturnCode UADInitialize(_THIS);
 static UMSAudioDevice_ReturnCode UADStart(_THIS);
 static UMSAudioDevice_ReturnCode UADStop(_THIS);
-static UMSAudioDevice_ReturnCode UADSetTimeFormat(_THIS,  UMSAudioTypes_TimeFormat fmt );
-static UMSAudioDevice_ReturnCode UADWriteBuffSize(_THIS,  long* buff_size );
-static UMSAudioDevice_ReturnCode UADWriteBuffRemain(_THIS,  long* buff_size );
-static UMSAudioDevice_ReturnCode UADWriteBuffUsed(_THIS,  long* buff_size );
-static UMSAudioDevice_ReturnCode UADSetDMABufferSize(_THIS,  long bytes, long* bytes_ret );
-static UMSAudioDevice_ReturnCode UADSetVolume(_THIS,  long volume );
-static UMSAudioDevice_ReturnCode UADSetBalance(_THIS,  long balance );
-static UMSAudioDevice_ReturnCode UADSetChannels(_THIS,  long channels );
-static UMSAudioDevice_ReturnCode UADPlayRemainingData(_THIS,  boolean block );
-static UMSAudioDevice_ReturnCode UADEnableOutput(_THIS,  string output, long* left_gain, long* right_gain);
-static UMSAudioDevice_ReturnCode UADWrite(_THIS,  UMSAudioTypes_Buffer* buff, long samples, long* samples_written);
+static UMSAudioDevice_ReturnCode UADSetTimeFormat(_THIS,
+                                                  UMSAudioTypes_TimeFormat
+                                                  fmt);
+static UMSAudioDevice_ReturnCode UADWriteBuffSize(_THIS, long *buff_size);
+static UMSAudioDevice_ReturnCode UADWriteBuffRemain(_THIS, long *buff_size);
+static UMSAudioDevice_ReturnCode UADWriteBuffUsed(_THIS, long *buff_size);
+static UMSAudioDevice_ReturnCode UADSetDMABufferSize(_THIS, long bytes,
+                                                     long *bytes_ret);
+static UMSAudioDevice_ReturnCode UADSetVolume(_THIS, long volume);
+static UMSAudioDevice_ReturnCode UADSetBalance(_THIS, long balance);
+static UMSAudioDevice_ReturnCode UADSetChannels(_THIS, long channels);
+static UMSAudioDevice_ReturnCode UADPlayRemainingData(_THIS, boolean block);
+static UMSAudioDevice_ReturnCode UADEnableOutput(_THIS, string output,
+                                                 long *left_gain,
+                                                 long *right_gain);
+static UMSAudioDevice_ReturnCode UADWrite(_THIS, UMSAudioTypes_Buffer * buff,
+                                          long samples,
+                                          long *samples_written);
 
 /* Audio driver bootstrap functions */
-static int Audio_Available(void)
+static int
+Audio_Available(void)
 {
     return 1;
 }
 
-static void Audio_DeleteDevice(_THIS)
+static void
+Audio_DeleteDevice(_THIS)
 {
-    if(this->hidden->playbuf._buffer) SDL_free(this->hidden->playbuf._buffer);
-    if(this->hidden->fillbuf._buffer) SDL_free(this->hidden->fillbuf._buffer);
-    _somFree( this->hidden->umsdev );
+    if (this->hidden->playbuf._buffer)
+        SDL_free(this->hidden->playbuf._buffer);
+    if (this->hidden->fillbuf._buffer)
+        SDL_free(this->hidden->fillbuf._buffer);
+    _somFree(this->hidden->umsdev);
     SDL_free(this->hidden);
     SDL_free(this);
 }
 
-static SDL_AudioDevice *Audio_CreateDevice(int devindex)
+static SDL_AudioDevice *
+Audio_CreateDevice(int devindex)
 {
     SDL_AudioDevice *this;
 
@@ -96,17 +110,18 @@
      * Allocate and initialize management storage and private management
      * storage for this SDL-using library.
      */
-    this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
-    if ( this ) {
+    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));
+        this->hidden = (struct SDL_PrivateAudioData *)
+            SDL_malloc((sizeof *this->hidden));
     }
-    if ( (this == NULL) || (this->hidden == NULL) ) {
+    if ((this == NULL) || (this->hidden == NULL)) {
         SDL_OutOfMemory();
-        if ( this ) {
+        if (this) {
             SDL_free(this);
         }
-        return(0);
+        return (0);
     }
     SDL_memset(this->hidden, 0, (sizeof *this->hidden));
 #ifdef DEBUG_AUDIO
@@ -116,18 +131,18 @@
     /*
      * Calls for UMS env initialization and audio object construction.
      */
-    this->hidden->ev     = somGetGlobalEnvironment();
+    this->hidden->ev = somGetGlobalEnvironment();
     this->hidden->umsdev = UMSAudioDeviceNew();
 
     /*
      * Set the function pointers.
      */
-    this->OpenAudio   = UMS_OpenAudio;
-    this->WaitAudio   = NULL;           /* we do blocking output */
-    this->PlayAudio   = UMS_PlayAudio;
+    this->OpenAudio = UMS_OpenAudio;
+    this->WaitAudio = NULL;     /* we do blocking output */
+    this->PlayAudio = UMS_PlayAudio;
     this->GetAudioBuf = UMS_GetAudioBuf;
-    this->CloseAudio  = UMS_CloseAudio;
-    this->free        = Audio_DeleteDevice;
+    this->CloseAudio = UMS_CloseAudio;
+    this->free = Audio_DeleteDevice;
 
 #ifdef DEBUG_AUDIO
     fprintf(stderr, "done\n");
@@ -136,11 +151,12 @@
 }
 
 AudioBootStrap UMS_bootstrap = {
-	UMS_DRIVER_NAME, "AUX UMS audio",
-	Audio_Available, Audio_CreateDevice
+    UMS_DRIVER_NAME, "AUX UMS audio",
+    Audio_Available, Audio_CreateDevice
 };
 
-static Uint8 *UMS_GetAudioBuf(_THIS)
+static Uint8 *
+UMS_GetAudioBuf(_THIS)
 {
 #ifdef DEBUG_AUDIO
     fprintf(stderr, "enter UMS_GetAudioBuf\n");
@@ -155,7 +171,8 @@
 */
 }
 
-static void UMS_CloseAudio(_THIS)
+static void
+UMS_CloseAudio(_THIS)
 {
     UMSAudioDevice_ReturnCode rc;
 
@@ -167,43 +184,44 @@
     rc = UADClose(this);
 }
 
-static void UMS_PlayAudio(_THIS)
+static void
+UMS_PlayAudio(_THIS)
 {
     UMSAudioDevice_ReturnCode rc;
-    long                      samplesToWrite;
-    long                      samplesWritten;
-    UMSAudioTypes_Buffer      swpbuf;
+    long samplesToWrite;
+    long samplesWritten;
+    UMSAudioTypes_Buffer swpbuf;
 
 #ifdef DEBUG_AUDIO
     fprintf(stderr, "enter UMS_PlayAudio\n");
 #endif
-    samplesToWrite = this->hidden->playbuf._length/this->hidden->bytesPerSample;
-    do
-    {
-        rc = UADWrite(this,  &this->hidden->playbuf,
-		       samplesToWrite,
-	               &samplesWritten );
-	samplesToWrite -= samplesWritten;
+    samplesToWrite =
+        this->hidden->playbuf._length / this->hidden->bytesPerSample;
+    do {
+        rc = UADWrite(this, &this->hidden->playbuf,
+                      samplesToWrite, &samplesWritten);
+        samplesToWrite -= samplesWritten;
 
-	/* rc values: UMSAudioDevice_Success
-	 *            UMSAudioDevice_Failure
-	 *            UMSAudioDevice_Preempted
-	 *            UMSAudioDevice_Interrupted
-	 *            UMSAudioDevice_DeviceError
-	 */
-	if ( rc == UMSAudioDevice_DeviceError ) {
+        /* rc values: UMSAudioDevice_Success
+         *            UMSAudioDevice_Failure
+         *            UMSAudioDevice_Preempted
+         *            UMSAudioDevice_Interrupted
+         *            UMSAudioDevice_DeviceError
+         */
+        if (rc == UMSAudioDevice_DeviceError) {
 #ifdef DEBUG_AUDIO
-	    fprintf(stderr, "Returning from PlayAudio with devices error\n");
+            fprintf(stderr, "Returning from PlayAudio with devices error\n");
 #endif
-	    return;
-	}
+            return;
+        }
     }
-    while(samplesToWrite>0);
+    while (samplesToWrite > 0);
 
     SDL_LockAudio();
-    SDL_memcpy( &swpbuf,                &this->hidden->playbuf, sizeof(UMSAudioTypes_Buffer) );
-    SDL_memcpy( &this->hidden->playbuf, &this->hidden->fillbuf, sizeof(UMSAudioTypes_Buffer) );
-    SDL_memcpy( &this->hidden->fillbuf, &swpbuf,                sizeof(UMSAudioTypes_Buffer) );
+    SDL_memcpy(&swpbuf, &this->hidden->playbuf, sizeof(UMSAudioTypes_Buffer));
+    SDL_memcpy(&this->hidden->playbuf, &this->hidden->fillbuf,
+               sizeof(UMSAudioTypes_Buffer));
+    SDL_memcpy(&this->hidden->fillbuf, &swpbuf, sizeof(UMSAudioTypes_Buffer));
     SDL_UnlockAudio();
 
 #ifdef DEBUG_AUDIO
@@ -212,133 +230,133 @@
 }
 
 #if 0
-// 	/* Set the DSP frequency */
-// 	value = spec->freq;
-// 	if ( ioctl(this->hidden->audio_fd, SOUND_PCM_WRITE_RATE, &value) < 0 ) {
-// 		SDL_SetError("Couldn't set audio frequency");
-// 		return(-1);
-// 	}
-// 	spec->freq = value;
+//      /* Set the DSP frequency */
+//      value = spec->freq;
+//      if ( ioctl(this->hidden->audio_fd, SOUND_PCM_WRITE_RATE, &value) < 0 ) {
+//              SDL_SetError("Couldn't set audio frequency");
+//              return(-1);
+//      }
+//      spec->freq = value;
 #endif
 
-static int UMS_OpenAudio(_THIS, SDL_AudioSpec *spec)
+static int
+UMS_OpenAudio(_THIS, SDL_AudioSpec * spec)
 {
-    char*  audiodev = "/dev/paud0";
-    long   lgain;
-    long   rgain;
-    long   outRate;
-    long   outBufSize;
-    long   bitsPerSample;
-    long   samplesPerSec;
-    long   success;
+    char *audiodev = "/dev/paud0";
+    long lgain;
+    long rgain;
+    long outRate;
+    long outBufSize;
+    long bitsPerSample;
+    long samplesPerSec;
+    long success;
     Uint16 test_format;
-    int    frag_spec;
+    int frag_spec;
     UMSAudioDevice_ReturnCode rc;
 
 #ifdef DEBUG_AUDIO
     fprintf(stderr, "enter UMS_OpenAudio\n");
 #endif
-    rc = UADOpen(this, audiodev,"PLAY", UMSAudioDevice_BlockingIO);
-    if ( rc != UMSAudioDevice_Success ) {
-	SDL_SetError("Couldn't open %s: %s", audiodev, strerror(errno));
-	return -1;
+    rc = UADOpen(this, audiodev, "PLAY", UMSAudioDevice_BlockingIO);
+    if (rc != UMSAudioDevice_Success) {
+        SDL_SetError("Couldn't open %s: %s", audiodev, strerror(errno));
+        return -1;
     }
- 
-    rc = UADSetAudioFormatType(this, "PCM"); 
+
+    rc = UADSetAudioFormatType(this, "PCM");
 
     success = 0;
     test_format = SDL_FirstAudioFormat(spec->format);
-    do
-    {
+    do {
 #ifdef DEBUG_AUDIO
         fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
 #endif
-        switch ( test_format )
-        {
+        switch (test_format) {
         case AUDIO_U8:
 /* from the mac code: better ? */
 /* sample_bits = spec->size / spec->samples / spec->channels * 8; */
-	    success       = 1;
+            success = 1;
             bitsPerSample = 8;
-            rc = UADSetSampleRate(this,  spec->freq << 16, &outRate );
-            rc = UADSetByteOrder(this, "MSB");       /* irrelevant */
+            rc = UADSetSampleRate(this, spec->freq << 16, &outRate);
+            rc = UADSetByteOrder(this, "MSB");  /* irrelevant */
             rc = UADSetNumberFormat(this, "UNSIGNED");
             break;
         case AUDIO_S8:
-	    success       = 1;
+            success = 1;
             bitsPerSample = 8;
-            rc = UADSetSampleRate(this,  spec->freq << 16, &outRate );
-            rc = UADSetByteOrder(this, "MSB");       /* irrelevant */
+            rc = UADSetSampleRate(this, spec->freq << 16, &outRate);
+            rc = UADSetByteOrder(this, "MSB");  /* irrelevant */
             rc = UADSetNumberFormat(this, "SIGNED");
             break;
         case AUDIO_S16LSB:
-	    success       = 1;
+            success = 1;
             bitsPerSample = 16;
-            rc = UADSetSampleRate(this,  spec->freq << 16, &outRate );
+            rc = UADSetSampleRate(this, spec->freq << 16, &outRate);
             rc = UADSetByteOrder(this, "LSB");
             rc = UADSetNumberFormat(this, "SIGNED");
             break;
         case AUDIO_S16MSB:
-	    success       = 1;
+            success = 1;
             bitsPerSample = 16;
-            rc = UADSetSampleRate(this,  spec->freq << 16, &outRate );
+            rc = UADSetSampleRate(this, spec->freq << 16, &outRate);
             rc = UADSetByteOrder(this, "MSB");
             rc = UADSetNumberFormat(this, "SIGNED");
             break;
         case AUDIO_U16LSB:
-	    success       = 1;
+            success = 1;
             bitsPerSample = 16;
-            rc = UADSetSampleRate(this,  spec->freq << 16, &outRate );
+            rc = UADSetSampleRate(this, spec->freq << 16, &outRate);
             rc = UADSetByteOrder(this, "LSB");
             rc = UADSetNumberFormat(this, "UNSIGNED");
             break;
         case AUDIO_U16MSB:
-	    success       = 1;
+            success = 1;
             bitsPerSample = 16;
-            rc = UADSetSampleRate(this,  spec->freq << 16, &outRate );
+            rc = UADSetSampleRate(this, spec->freq << 16, &outRate);
             rc = UADSetByteOrder(this, "MSB");
             rc = UADSetNumberFormat(this, "UNSIGNED");
             break;
         default:
             break;
         }
-        if ( ! success ) {
+        if (!success) {
             test_format = SDL_NextAudioFormat();
         }
     }
-    while ( ! success && test_format );
+    while (!success && test_format);
 
-    if ( success == 0 ) {
+    if (success == 0) {
         SDL_SetError("Couldn't find any hardware audio formats");
         return -1;
     }
 
     spec->format = test_format;
 
-    for ( frag_spec = 0; (0x01<<frag_spec) < spec->size; ++frag_spec );
-    if ( (0x01<<frag_spec) != spec->size ) {
+    for (frag_spec = 0; (0x01 << frag_spec) < spec->size; ++frag_spec);
+    if ((0x01 << frag_spec) != spec->size) {
         SDL_SetError("Fragment size must be a power of two");
         return -1;
     }
-    if ( frag_spec > 2048 ) frag_spec = 2048;
-
-    this->hidden->bytesPerSample   = (bitsPerSample / 8) * spec->channels;
-    samplesPerSec                  = this->hidden->bytesPerSample * outRate;
+    if (frag_spec > 2048)
+        frag_spec = 2048;
 
-    this->hidden->playbuf._length  = 0;
+    this->hidden->bytesPerSample = (bitsPerSample / 8) * spec->channels;
+    samplesPerSec = this->hidden->bytesPerSample * outRate;
+
+    this->hidden->playbuf._length = 0;
     this->hidden->playbuf._maximum = spec->size;
-    this->hidden->playbuf._buffer  = (unsigned char*)SDL_malloc(spec->size);
-    this->hidden->fillbuf._length  = 0;
+    this->hidden->playbuf._buffer = (unsigned char *) SDL_malloc(spec->size);
+    this->hidden->fillbuf._length = 0;
     this->hidden->fillbuf._maximum = spec->size;
-    this->hidden->fillbuf._buffer  = (unsigned char*)SDL_malloc(spec->size);
+    this->hidden->fillbuf._buffer = (unsigned char *) SDL_malloc(spec->size);
 
-    rc = UADSetBitsPerSample(this,  bitsPerSample );
-    rc = UADSetDMABufferSize(this,  frag_spec, &outBufSize );
-    rc = UADSetChannels(this, spec->channels);      /* functions reduces to mono or stereo */
+    rc = UADSetBitsPerSample(this, bitsPerSample);
+    rc = UADSetDMABufferSize(this, frag_spec, &outBufSize);
+    rc = UADSetChannels(this, spec->channels);  /* functions reduces to mono or stereo */
 
-    lgain = 100; /*maximum left input gain*/
-    rgain = 100; /*maimum right input gain*/
-    rc = UADEnableOutput(this, "LINE_OUT",&lgain,&rgain);
+    lgain = 100;                /*maximum left input gain */
+    rgain = 100;                /*maimum right input gain */
+    rc = UADEnableOutput(this, "LINE_OUT", &lgain, &rgain);
     rc = UADInitialize(this);
     rc = UADStart(this);
     rc = UADSetVolume(this, 100);
@@ -347,201 +365,197 @@
     /* We're ready to rock and roll. :-) */
     return 0;
 }
+
 
-
-static UMSAudioDevice_ReturnCode UADGetBitsPerSample(_THIS, long* bits)
+static UMSAudioDevice_ReturnCode
+UADGetBitsPerSample(_THIS, long *bits)
 {
-    return UMSAudioDevice_get_bits_per_sample( this->hidden->umsdev,
-					       this->hidden->ev,
-					       bits );
+    return UMSAudioDevice_get_bits_per_sample(this->hidden->umsdev,
+                                              this->hidden->ev, bits);
 }
 
-static UMSAudioDevice_ReturnCode UADSetBitsPerSample(_THIS, long bits)
+static UMSAudioDevice_ReturnCode
+UADSetBitsPerSample(_THIS, long bits)
 {
-    return UMSAudioDevice_set_bits_per_sample( this->hidden->umsdev,
-					       this->hidden->ev,
-					       bits );
+    return UMSAudioDevice_set_bits_per_sample(this->hidden->umsdev,
+                                              this->hidden->ev, bits);
 }
 
-static UMSAudioDevice_ReturnCode UADSetSampleRate(_THIS, long rate, long* set_rate)
+static UMSAudioDevice_ReturnCode
+UADSetSampleRate(_THIS, long rate, long *set_rate)
 {
     /* from the mac code: sample rate = spec->freq << 16; */
-    return UMSAudioDevice_set_sample_rate( this->hidden->umsdev,
-					   this->hidden->ev,
-					   rate,
-					   set_rate );
+    return UMSAudioDevice_set_sample_rate(this->hidden->umsdev,
+                                          this->hidden->ev, rate, set_rate);
+}
+
+static UMSAudioDevice_ReturnCode
+UADSetByteOrder(_THIS, string byte_order)
+{
+    return UMSAudioDevice_set_byte_order(this->hidden->umsdev,
+                                         this->hidden->ev, byte_order);
 }
 
-static UMSAudioDevice_ReturnCode UADSetByteOrder(_THIS, string byte_order)
+static UMSAudioDevice_ReturnCode
+UADSetAudioFormatType(_THIS, string fmt)
 {
-    return UMSAudioDevice_set_byte_order( this->hidden->umsdev,
-					  this->hidden->ev,
-					  byte_order );
+    /* possible PCM, A_LAW or MU_LAW */
+    return UMSAudioDevice_set_audio_format_type(this->hidden->umsdev,
+                                                this->hidden->ev, fmt);
 }
 
-static UMSAudioDevice_ReturnCode UADSetAudioFormatType(_THIS, string fmt)
-{
-    /* possible PCM, A_LAW or MU_LAW */
-    return UMSAudioDevice_set_audio_format_type( this->hidden->umsdev,
-						 this->hidden->ev,
-						 fmt );
-}
-
-static UMSAudioDevice_ReturnCode UADSetNumberFormat(_THIS, string fmt)
+static UMSAudioDevice_ReturnCode
+UADSetNumberFormat(_THIS, string fmt)
 {
     /* possible SIGNED, UNSIGNED, or TWOS_COMPLEMENT */
-    return UMSAudioDevice_set_number_format( this->hidden->umsdev,
-					     this->hidden->ev,
-					     fmt );
+    return UMSAudioDevice_set_number_format(this->hidden->umsdev,
+                                            this->hidden->ev, fmt);
 }
 
-static UMSAudioDevice_ReturnCode UADInitialize(_THIS)
+static UMSAudioDevice_ReturnCode
+UADInitialize(_THIS)
 {
-    return UMSAudioDevice_initialize( this->hidden->umsdev,
-				      this->hidden->ev );
+    return UMSAudioDevice_initialize(this->hidden->umsdev, this->hidden->ev);
 }
 
-static UMSAudioDevice_ReturnCode UADStart(_THIS)
+static UMSAudioDevice_ReturnCode
+UADStart(_THIS)
 {
-    return UMSAudioDevice_start( this->hidden->umsdev,
-				 this->hidden->ev );
+    return UMSAudioDevice_start(this->hidden->umsdev, this->hidden->ev);
 }
 
-static UMSAudioDevice_ReturnCode UADSetTimeFormat(_THIS,  UMSAudioTypes_TimeFormat fmt )
+static UMSAudioDevice_ReturnCode
+UADSetTimeFormat(_THIS, UMSAudioTypes_TimeFormat fmt)
 {
     /*
      * Switches the time format to the new format, immediately.
      * possible UMSAudioTypes_Msecs, UMSAudioTypes_Bytes or UMSAudioTypes_Samples
      */
-    return UMSAudioDevice_set_time_format( this->hidden->umsdev,
-					   this->hidden->ev,
-					   fmt );
+    return UMSAudioDevice_set_time_format(this->hidden->umsdev,
+                                          this->hidden->ev, fmt);
 }
 
-static UMSAudioDevice_ReturnCode UADWriteBuffSize(_THIS,  long* buff_size )
+static UMSAudioDevice_ReturnCode
+UADWriteBuffSize(_THIS, long *buff_size)
 {
     /*
      * returns write buffer size in the current time format
      */
-    return UMSAudioDevice_write_buff_size( this->hidden->umsdev,
-                                           this->hidden->ev,
-					   buff_size );
+    return UMSAudioDevice_write_buff_size(this->hidden->umsdev,
+                                          this->hidden->ev, buff_size);
 }
 
-static UMSAudioDevice_ReturnCode UADWriteBuffRemain(_THIS,  long* buff_size )
+static UMSAudioDevice_ReturnCode
+UADWriteBuffRemain(_THIS, long *buff_size)
 {
     /*
      * returns amount of available space in the write buffer
      * in the current time format
      */
-    return UMSAudioDevice_write_buff_remain( this->hidden->umsdev,
-                                             this->hidden->ev,
-					     buff_size );
+    return UMSAudioDevice_write_buff_remain(this->hidden->umsdev,
+                                            this->hidden->ev, buff_size);
 }
 
-static UMSAudioDevice_ReturnCode UADWriteBuffUsed(_THIS,  long* buff_size )
+static UMSAudioDevice_ReturnCode
+UADWriteBuffUsed(_THIS, long *buff_size)
 {
     /*
      * returns amount of filled space in the write buffer
      * in the current time format
      */
-    return UMSAudioDevice_write_buff_used( this->hidden->umsdev,
-                                           this->hidden->ev,
-					   buff_size );
+    return UMSAudioDevice_write_buff_used(this->hidden->umsdev,
+                                          this->hidden->ev, buff_size);
 }
 
-static UMSAudioDevice_ReturnCode UADSetDMABufferSize(_THIS,  long bytes, long* bytes_ret )
+static UMSAudioDevice_ReturnCode
+UADSetDMABufferSize(_THIS, long bytes, long *bytes_ret)
 {
     /*
      * Request a new DMA buffer size, maximum requested size 2048.
      * Takes effect with next initialize() call.
      * Devices may or may not support DMA.
      */
-    return UMSAudioDevice_set_DMA_buffer_size( this->hidden->umsdev,
-					       this->hidden->ev,
-					       bytes,
-					       bytes_ret );
+    return UMSAudioDevice_set_DMA_buffer_size(this->hidden->umsdev,
+                                              this->hidden->ev,
+                                              bytes, bytes_ret);
 }
 
-static UMSAudioDevice_ReturnCode UADSetVolume(_THIS,  long volume )
+static UMSAudioDevice_ReturnCode
+UADSetVolume(_THIS, long volume)
 {
     /*
      * Set the volume.
      * Takes effect immediately.
      */
-    return UMSAudioDevice_set_volume( this->hidden->umsdev,
-				      this->hidden->ev,
-				      volume );
+    return UMSAudioDevice_set_volume(this->hidden->umsdev,
+                                     this->hidden->ev, volume);
 }
 
-static UMSAudioDevice_ReturnCode UADSetBalance(_THIS,  long balance )
+static UMSAudioDevice_ReturnCode
+UADSetBalance(_THIS, long balance)
 {
     /*
      * Set the balance.
      * Takes effect immediately.
      */
-    return UMSAudioDevice_set_balance( this->hidden->umsdev,
-				       this->hidden->ev,
-				       balance );
+    return UMSAudioDevice_set_balance(this->hidden->umsdev,
+                                      this->hidden->ev, balance);
 }
 
-static UMSAudioDevice_ReturnCode UADSetChannels(_THIS,  long channels )
+static UMSAudioDevice_ReturnCode
+UADSetChannels(_THIS, long channels)
 {
     /*
      * Set mono or stereo.
      * Takes effect with next initialize() call.
      */
-    if ( channels != 1 ) channels = 2;
-    return UMSAudioDevice_set_number_of_channels( this->hidden->umsdev,
-				                  this->hidden->ev,
-				                  channels );
+    if (channels != 1)
+        channels = 2;
+    return UMSAudioDevice_set_number_of_channels(this->hidden->umsdev,
+                                                 this->hidden->ev, channels);
 }
 
-static UMSAudioDevice_ReturnCode UADOpen(_THIS,  string device, string mode, long flags)
+static UMSAudioDevice_ReturnCode
+UADOpen(_THIS, string device, string mode, long flags)
 {
-    return UMSAudioDevice_open( this->hidden->umsdev,
-				this->hidden->ev,
-				device,
-				mode,
-				flags );
+    return UMSAudioDevice_open(this->hidden->umsdev,
+                               this->hidden->ev, device, mode, flags);
 }
 
-static UMSAudioDevice_ReturnCode UADWrite(_THIS,  UMSAudioTypes_Buffer* buff,
-                                           long samples,
-					   long* samples_written)
+static UMSAudioDevice_ReturnCode
+UADWrite(_THIS, UMSAudioTypes_Buffer * buff,
+         long samples, long *samples_written)
 {
-    return UMSAudioDevice_write( this->hidden->umsdev,
-				 this->hidden->ev,
-				 buff,
-				 samples,
-				 samples_written );
+    return UMSAudioDevice_write(this->hidden->umsdev,
+                                this->hidden->ev,
+                                buff, samples, samples_written);
 }
 
-static UMSAudioDevice_ReturnCode UADPlayRemainingData(_THIS,  boolean block )
+static UMSAudioDevice_ReturnCode
+UADPlayRemainingData(_THIS, boolean block)
 {
-    return UMSAudioDevice_play_remaining_data( this->hidden->umsdev,
-					       this->hidden->ev,
-					       block);
+    return UMSAudioDevice_play_remaining_data(this->hidden->umsdev,
+                                              this->hidden->ev, block);
 }
 
-static UMSAudioDevice_ReturnCode UADStop(_THIS)
+static UMSAudioDevice_ReturnCode
+UADStop(_THIS)
 {
-    return UMSAudioDevice_stop( this->hidden->umsdev,
-				this->hidden->ev );
+    return UMSAudioDevice_stop(this->hidden->umsdev, this->hidden->ev);
 }
 
-static UMSAudioDevice_ReturnCode UADClose(_THIS)
+static UMSAudioDevice_ReturnCode
+UADClose(_THIS)
 {
-    return UMSAudioDevice_close( this->hidden->umsdev,
-				 this->hidden->ev );
+    return UMSAudioDevice_close(this->hidden->umsdev, this->hidden->ev);
 }
 
-static UMSAudioDevice_ReturnCode UADEnableOutput(_THIS,  string output, long* left_gain, long* right_gain)
+static UMSAudioDevice_ReturnCode
+UADEnableOutput(_THIS, string output, long *left_gain, long *right_gain)
 {
-    return UMSAudioDevice_enable_output( this->hidden->umsdev,
-					 this->hidden->ev,
-					 output,
-					 left_gain,
-					 right_gain );
+    return UMSAudioDevice_enable_output(this->hidden->umsdev,
+                                        this->hidden->ev,
+                                        output, left_gain, right_gain);
 }
 
+/* vi: set ts=4 sw=4 expandtab: */