--- a/src/audio/macrom/SDL_romaudio.c	Sun May 21 17:27:13 2006 +0000
+++ b/src/audio/macrom/SDL_romaudio.c	Sun May 28 13:04:16 2006 +0000
@@ -26,13 +26,13 @@
 #elif TARGET_API_MAC_CARBON && (UNIVERSAL_INTERFACES_VERSION > 0x0335)
 #  include <Carbon.h>
 #else
-#  include <Sound.h> /* SoundManager interface */
+#  include <Sound.h>            /* SoundManager interface */
 #  include <Gestalt.h>
 #  include <DriverServices.h>
 #endif
 
 #if !defined(NewSndCallBackUPP) && (UNIVERSAL_INTERFACES_VERSION < 0x0335)
-#if !defined(NewSndCallBackProc) /* avoid circular redefinition... */
+#if !defined(NewSndCallBackProc)        /* avoid circular redefinition... */
 #define NewSndCallBackUPP NewSndCallBackProc
 #endif
 #if !defined(NewSndCallBackUPP)
@@ -47,62 +47,65 @@
 
 /* Audio driver functions */
 
-static void Mac_CloseAudio(_THIS);
-static int Mac_OpenAudio(_THIS, SDL_AudioSpec *spec);
-static void Mac_LockAudio(_THIS);
-static void Mac_UnlockAudio(_THIS);
+static void Mac_CloseAudio (_THIS);
+static int Mac_OpenAudio (_THIS, SDL_AudioSpec * spec);
+static void Mac_LockAudio (_THIS);
+static void Mac_UnlockAudio (_THIS);
 
 /* Audio driver bootstrap functions */
 
 
-static int Audio_Available(void)
+static int
+Audio_Available (void)
 {
-    return(1);
+    return (1);
 }
 
-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;
 
     /* 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 = (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));
+            SDL_malloc ((sizeof *this->hidden));
     }
-    if ( (this == NULL) || (this->hidden == NULL) ) {
-        SDL_OutOfMemory();
-        if ( this ) {
-            SDL_free(this);
+    if ((this == NULL) || (this->hidden == NULL)) {
+        SDL_OutOfMemory ();
+        if (this) {
+            SDL_free (this);
         }
-        return(0);
+        return (0);
     }
-    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+    SDL_memset (this->hidden, 0, (sizeof *this->hidden));
 
     /* Set the function pointers */
-    this->OpenAudio   = Mac_OpenAudio;
-    this->CloseAudio  = Mac_CloseAudio;
-    this->LockAudio   = Mac_LockAudio;
+    this->OpenAudio = Mac_OpenAudio;
+    this->CloseAudio = Mac_CloseAudio;
+    this->LockAudio = Mac_LockAudio;
     this->UnlockAudio = Mac_UnlockAudio;
-    this->free        = Audio_DeleteDevice;
+    this->free = Audio_DeleteDevice;
 
-#ifdef __MACOSX__	/* Mac OS X uses threaded audio, so normal thread code is okay */
-    this->LockAudio   = NULL;
+#ifdef __MACOSX__               /* Mac OS X uses threaded audio, so normal thread code is okay */
+    this->LockAudio = NULL;
     this->UnlockAudio = NULL;
 #endif
     return this;
 }
 
 AudioBootStrap SNDMGR_bootstrap = {
-	"sndmgr", "MacOS SoundManager 3.0",
-	Audio_Available, Audio_CreateDevice
+    "sndmgr", "MacOS SoundManager 3.0",
+    Audio_Available, Audio_CreateDevice
 };
 
 #if defined(TARGET_API_MAC_CARBON) || defined(USE_RYANS_SOUNDCODE)
@@ -113,51 +116,56 @@
 static volatile SInt32 audio_is_locked = 0;
 static volatile SInt32 need_to_mix = 0;
 
-static UInt8  *buffer[2];
+static UInt8 *buffer[2];
 static volatile UInt32 running = 0;
 static CmpSoundHeader header;
 static volatile Uint32 fill_me = 0;
 
-static void mix_buffer(SDL_AudioDevice *audio, UInt8 *buffer)
+static void
+mix_buffer (SDL_AudioDevice * audio, UInt8 * buffer)
 {
-   if ( ! audio->paused ) {
+    if (!audio->paused) {
 #ifdef __MACOSX__
-        SDL_mutexP(audio->mixer_lock);
+        SDL_mutexP (audio->mixer_lock);
 #endif
-        if ( audio->convert.needed ) {
-            audio->spec.callback(audio->spec.userdata,
-                    (Uint8 *)audio->convert.buf,audio->convert.len);
-            SDL_ConvertAudio(&audio->convert);
-            if ( audio->convert.len_cvt != audio->spec.size ) {
-                /* Uh oh... probably crashes here */;
+        if (audio->convert.needed) {
+            audio->spec.callback (audio->spec.userdata,
+                                  (Uint8 *) audio->convert.buf,
+                                  audio->convert.len);
+            SDL_ConvertAudio (&audio->convert);
+            if (audio->convert.len_cvt != audio->spec.size) {
+                /* Uh oh... probably crashes here */ ;
             }
-            SDL_memcpy(buffer, audio->convert.buf, audio->convert.len_cvt);
+            SDL_memcpy (buffer, audio->convert.buf, audio->convert.len_cvt);
         } else {
-            audio->spec.callback(audio->spec.userdata, buffer, audio->spec.size);
+            audio->spec.callback (audio->spec.userdata, buffer,
+                                  audio->spec.size);
         }
 #ifdef __MACOSX__
-        SDL_mutexV(audio->mixer_lock);
+        SDL_mutexV (audio->mixer_lock);
 #endif
     }
 
-    DecrementAtomic((SInt32 *) &need_to_mix);
+    DecrementAtomic ((SInt32 *) & need_to_mix);
 }
 
-static void Mac_LockAudio(_THIS)
+static void
+Mac_LockAudio (_THIS)
 {
-    IncrementAtomic((SInt32 *) &audio_is_locked);
+    IncrementAtomic ((SInt32 *) & audio_is_locked);
 }
 
-static void Mac_UnlockAudio(_THIS)
+static void
+Mac_UnlockAudio (_THIS)
 {
     SInt32 oldval;
-         
-    oldval = DecrementAtomic((SInt32 *) &audio_is_locked);
-    if ( oldval != 1 )  /* != 1 means audio is still locked. */
+
+    oldval = DecrementAtomic ((SInt32 *) & audio_is_locked);
+    if (oldval != 1)            /* != 1 means audio is still locked. */
         return;
 
     /* Did we miss the chance to mix in an interrupt? Do it now. */
-    if ( BitAndAtomic (0xFFFFFFFF, (UInt32 *) &need_to_mix) ) {
+    if (BitAndAtomic (0xFFFFFFFF, (UInt32 *) & need_to_mix)) {
         /*
          * Note that this could be a problem if you missed an interrupt
          *  while the audio was locked, and get preempted by a second
@@ -167,147 +175,154 @@
     }
 }
 
-static void callBackProc (SndChannel *chan, SndCommand *cmd_passed ) {
-   UInt32 play_me;
-   SndCommand cmd; 
-   SDL_AudioDevice *audio = (SDL_AudioDevice *)chan->userInfo;
+static void
+callBackProc (SndChannel * chan, SndCommand * cmd_passed)
+{
+    UInt32 play_me;
+    SndCommand cmd;
+    SDL_AudioDevice *audio = (SDL_AudioDevice *) chan->userInfo;
 
-   IncrementAtomic((SInt32 *) &need_to_mix);
+    IncrementAtomic ((SInt32 *) & need_to_mix);
 
-   fill_me = cmd_passed->param2;  /* buffer that has just finished playing, so fill it */      
-   play_me = ! fill_me;           /* filled buffer to play _now_ */
+    fill_me = cmd_passed->param2;       /* buffer that has just finished playing, so fill it */
+    play_me = !fill_me;         /* filled buffer to play _now_ */
+
+    if (!audio->enabled) {
+        return;
+    }
 
-   if ( ! audio->enabled ) {
-      return;
-   }
-   
-   /* queue previously mixed buffer for playback. */
-   header.samplePtr = (Ptr)buffer[play_me];
-   cmd.cmd = bufferCmd;
-   cmd.param1 = 0; 
-   cmd.param2 = (long)&header;
-   SndDoCommand (chan, &cmd, 0);
+    /* queue previously mixed buffer for playback. */
+    header.samplePtr = (Ptr) buffer[play_me];
+    cmd.cmd = bufferCmd;
+    cmd.param1 = 0;
+    cmd.param2 = (long) &header;
+    SndDoCommand (chan, &cmd, 0);
 
-   memset (buffer[fill_me], 0, audio->spec.size);
+    memset (buffer[fill_me], 0, audio->spec.size);
 
-   /*
-    * if audio device isn't locked, mix the next buffer to be queued in
-    *  the memory block that just finished playing.
-    */
-   if ( ! BitAndAtomic(0xFFFFFFFF, (UInt32 *) &audio_is_locked) ) {
-      mix_buffer (audio, buffer[fill_me]);
-   } 
+    /*
+     * if audio device isn't locked, mix the next buffer to be queued in
+     *  the memory block that just finished playing.
+     */
+    if (!BitAndAtomic (0xFFFFFFFF, (UInt32 *) & audio_is_locked)) {
+        mix_buffer (audio, buffer[fill_me]);
+    }
 
-   /* set this callback to run again when current buffer drains. */
-   if ( running ) {
-      cmd.cmd = callBackCmd;
-      cmd.param1 = 0;
-      cmd.param2 = play_me;
-   
-      SndDoCommand (chan, &cmd, 0);
-   }
+    /* set this callback to run again when current buffer drains. */
+    if (running) {
+        cmd.cmd = callBackCmd;
+        cmd.param1 = 0;
+        cmd.param2 = play_me;
+
+        SndDoCommand (chan, &cmd, 0);
+    }
 }
 
-static int Mac_OpenAudio(_THIS, SDL_AudioSpec *spec) {
+static int
+Mac_OpenAudio (_THIS, SDL_AudioSpec * spec)
+{
 
-   SndCallBackUPP callback;
-   int sample_bits;
-   int i;
-   long initOptions;
-      
-   /* Very few conversions are required, but... */
+    SndCallBackUPP callback;
+    int sample_bits;
+    int i;
+    long initOptions;
+
+    /* Very few conversions are required, but... */
     switch (spec->format) {
-        case AUDIO_S8:
+    case AUDIO_S8:
         spec->format = AUDIO_U8;
         break;
-        case AUDIO_U16LSB:
+    case AUDIO_U16LSB:
         spec->format = AUDIO_S16LSB;
         break;
-        case AUDIO_U16MSB:
+    case AUDIO_U16MSB:
         spec->format = AUDIO_S16MSB;
         break;
     }
-    SDL_CalculateAudioSpec(spec);
-    
+    SDL_CalculateAudioSpec (spec);
+
     /* initialize bufferCmd header */
-    memset (&header, 0, sizeof(header));
+    memset (&header, 0, sizeof (header));
     callback = (SndCallBackUPP) NewSndCallBackUPP (callBackProc);
     sample_bits = spec->size / spec->samples / spec->channels * 8;
 
 #ifdef DEBUG_AUDIO
-    fprintf(stderr,
-	"Audio format 0x%x, channels = %d, sample_bits = %d, frequency = %d\n",
-	spec->format, spec->channels, sample_bits, spec->freq);
+    fprintf (stderr,
+             "Audio format 0x%x, channels = %d, sample_bits = %d, frequency = %d\n",
+             spec->format, spec->channels, sample_bits, spec->freq);
 #endif /* DEBUG_AUDIO */
-    
+
     header.numChannels = spec->channels;
-    header.sampleSize  = sample_bits;
-    header.sampleRate  = spec->freq << 16;
-    header.numFrames   = spec->samples;
-    header.encode      = cmpSH;
-    
+    header.sampleSize = sample_bits;
+    header.sampleRate = spec->freq << 16;
+    header.numFrames = spec->samples;
+    header.encode = cmpSH;
+
     /* Note that we install the 16bitLittleEndian Converter if needed. */
-    if ( spec->format == 0x8010 ) {
+    if (spec->format == 0x8010) {
         header.compressionID = fixedCompression;
         header.format = k16BitLittleEndianFormat;
     }
-    
+
     /* allocate 2 buffers */
-    for (i=0; i<2; i++) {
-       buffer[i] = (UInt8*)malloc (sizeof(UInt8) * spec->size);
-      if (buffer[i] == NULL) {
-         SDL_OutOfMemory();
-         return (-1);
-      }
-     memset (buffer[i], 0, spec->size);
-   }
-   
-   /* Create the sound manager channel */
-    channel = (SndChannelPtr)SDL_malloc(sizeof(*channel));
-    if ( channel == NULL ) {
-        SDL_OutOfMemory();
-        return(-1);
+    for (i = 0; i < 2; i++) {
+        buffer[i] = (UInt8 *) malloc (sizeof (UInt8) * spec->size);
+        if (buffer[i] == NULL) {
+            SDL_OutOfMemory ();
+            return (-1);
+        }
+        memset (buffer[i], 0, spec->size);
     }
-    if ( spec->channels >= 2 ) {
+
+    /* Create the sound manager channel */
+    channel = (SndChannelPtr) SDL_malloc (sizeof (*channel));
+    if (channel == NULL) {
+        SDL_OutOfMemory ();
+        return (-1);
+    }
+    if (spec->channels >= 2) {
         initOptions = initStereo;
     } else {
         initOptions = initMono;
     }
-    channel->userInfo = (long)this;
+    channel->userInfo = (long) this;
     channel->qLength = 128;
-    if ( SndNewChannel(&channel, sampledSynth, initOptions, callback) != noErr ) {
-        SDL_SetError("Unable to create audio channel");
-        SDL_free(channel);
+    if (SndNewChannel (&channel, sampledSynth, initOptions, callback) !=
+        noErr) {
+        SDL_SetError ("Unable to create audio channel");
+        SDL_free (channel);
         channel = NULL;
-        return(-1);
+        return (-1);
     }
-   
-   /* start playback */
-   {
-      SndCommand cmd;
-      cmd.cmd = callBackCmd;
-      cmd.param2 = 0;
-      running = 1;
-      SndDoCommand (channel, &cmd, 0);
-   }
-   
-   return 1;
+
+    /* start playback */
+    {
+        SndCommand cmd;
+        cmd.cmd = callBackCmd;
+        cmd.param2 = 0;
+        running = 1;
+        SndDoCommand (channel, &cmd, 0);
+    }
+
+    return 1;
 }
 
-static void Mac_CloseAudio(_THIS) {
-   
-   int i;
-   
-   running = 0;
-   
-   if (channel) {
-      SndDisposeChannel (channel, true);
-      channel = NULL;
-   }
-   
-    for ( i=0; i<2; ++i ) {
-        if ( buffer[i] ) {
-            SDL_free(buffer[i]);
+static void
+Mac_CloseAudio (_THIS)
+{
+
+    int i;
+
+    running = 0;
+
+    if (channel) {
+        SndDisposeChannel (channel, true);
+        channel = NULL;
+    }
+
+    for (i = 0; i < 2; ++i) {
+        if (buffer[i]) {
+            SDL_free (buffer[i]);
             buffer[i] = NULL;
         }
     }
@@ -315,12 +330,14 @@
 
 #else /* !TARGET_API_MAC_CARBON && !USE_RYANS_SOUNDCODE */
 
-static void Mac_LockAudio(_THIS)
+static void
+Mac_LockAudio (_THIS)
 {
     /* no-op. */
 }
 
-static void Mac_UnlockAudio(_THIS)
+static void
+Mac_UnlockAudio (_THIS)
 {
     /* no-op. */
 }
@@ -330,79 +347,84 @@
    the buffers, so we'll zero it to silence and fill it with audio if
    we're not paused.
 */
-static pascal
-void sndDoubleBackProc (SndChannelPtr chan, SndDoubleBufferPtr newbuf)
+static pascal void
+sndDoubleBackProc (SndChannelPtr chan, SndDoubleBufferPtr newbuf)
 {
-    SDL_AudioDevice *audio = (SDL_AudioDevice *)newbuf->dbUserInfo[0];
+    SDL_AudioDevice *audio = (SDL_AudioDevice *) newbuf->dbUserInfo[0];
 
     /* If audio is quitting, don't do anything */
-    if ( ! audio->enabled ) {
+    if (!audio->enabled) {
         return;
     }
     memset (newbuf->dbSoundData, 0, audio->spec.size);
     newbuf->dbNumFrames = audio->spec.samples;
-    if ( ! audio->paused ) {
-        if ( audio->convert.needed ) {
-            audio->spec.callback(audio->spec.userdata,
-                (Uint8 *)audio->convert.buf,audio->convert.len);
-            SDL_ConvertAudio(&audio->convert);
+    if (!audio->paused) {
+        if (audio->convert.needed) {
+            audio->spec.callback (audio->spec.userdata,
+                                  (Uint8 *) audio->convert.buf,
+                                  audio->convert.len);
+            SDL_ConvertAudio (&audio->convert);
 #if 0
-            if ( audio->convert.len_cvt != audio->spec.size ) {
-                /* Uh oh... probably crashes here */;
+            if (audio->convert.len_cvt != audio->spec.size) {
+                /* Uh oh... probably crashes here */ ;
             }
 #endif
-            SDL_memcpy(newbuf->dbSoundData, audio->convert.buf,
-                            audio->convert.len_cvt);
+            SDL_memcpy (newbuf->dbSoundData, audio->convert.buf,
+                        audio->convert.len_cvt);
         } else {
-            audio->spec.callback(audio->spec.userdata,
-                (Uint8 *)newbuf->dbSoundData, audio->spec.size);
+            audio->spec.callback (audio->spec.userdata,
+                                  (Uint8 *) newbuf->dbSoundData,
+                                  audio->spec.size);
         }
     }
-    newbuf->dbFlags    |= dbBufferReady;
+    newbuf->dbFlags |= dbBufferReady;
 }
 
-static int DoubleBufferAudio_Available(void)
+static int
+DoubleBufferAudio_Available (void)
 {
     int available;
     NumVersion sndversion;
     long response;
 
     available = 0;
-    sndversion = SndSoundManagerVersion();
-    if ( sndversion.majorRev >= 3 ) {
-        if ( Gestalt(gestaltSoundAttr, &response) == noErr ) {
-            if ( (response & (1 << gestaltSndPlayDoubleBuffer)) ) {
+    sndversion = SndSoundManagerVersion ();
+    if (sndversion.majorRev >= 3) {
+        if (Gestalt (gestaltSoundAttr, &response) == noErr) {
+            if ((response & (1 << gestaltSndPlayDoubleBuffer))) {
                 available = 1;
             }
         }
     } else {
-        if ( Gestalt(gestaltSoundAttr, &response) == noErr ) {
-            if ( (response & (1 << gestaltHasASC)) ) {
+        if (Gestalt (gestaltSoundAttr, &response) == noErr) {
+            if ((response & (1 << gestaltHasASC))) {
                 available = 1;
             }
         }
     }
-    return(available);
+    return (available);
 }
 
-static void Mac_CloseAudio(_THIS)
+static void
+Mac_CloseAudio (_THIS)
 {
     int i;
 
-    if ( channel != NULL ) {
+    if (channel != NULL) {
         /* Clean up the audio channel */
-        SndDisposeChannel(channel, true);
+        SndDisposeChannel (channel, true);
         channel = NULL;
     }
-    for ( i=0; i<2; ++i ) {
-        if ( audio_buf[i] ) {
-            SDL_free(audio_buf[i]);
+    for (i = 0; i < 2; ++i) {
+        if (audio_buf[i]) {
+            SDL_free (audio_buf[i]);
             audio_buf[i] = NULL;
         }
     }
 }
 
-static int Mac_OpenAudio(_THIS, SDL_AudioSpec *spec)
+static int
+Mac_OpenAudio (_THIS, SDL_AudioSpec * spec)
 {
     SndDoubleBufferHeader2 audio_dbh;
     int i;
@@ -411,86 +433,86 @@
     SndDoubleBackUPP doubleBackProc;
 
     /* Check to make sure double-buffered audio is available */
-    if ( ! DoubleBufferAudio_Available() ) {
-        SDL_SetError("Sound manager doesn't support double-buffering");
-        return(-1);
+    if (!DoubleBufferAudio_Available ()) {
+        SDL_SetError ("Sound manager doesn't support double-buffering");
+        return (-1);
     }
 
     /* Very few conversions are required, but... */
     switch (spec->format) {
-        case AUDIO_S8:
+    case AUDIO_S8:
         spec->format = AUDIO_U8;
         break;
-        case AUDIO_U16LSB:
+    case AUDIO_U16LSB:
         spec->format = AUDIO_S16LSB;
         break;
-        case AUDIO_U16MSB:
+    case AUDIO_U16MSB:
         spec->format = AUDIO_S16MSB;
         break;
     }
-    SDL_CalculateAudioSpec(spec);
+    SDL_CalculateAudioSpec (spec);
 
     /* initialize the double-back header */
-    SDL_memset(&audio_dbh, 0, sizeof(audio_dbh));
+    SDL_memset (&audio_dbh, 0, sizeof (audio_dbh));
     doubleBackProc = NewSndDoubleBackProc (sndDoubleBackProc);
     sample_bits = spec->size / spec->samples / spec->channels * 8;
-    
+
     audio_dbh.dbhNumChannels = spec->channels;
-    audio_dbh.dbhSampleSize    = sample_bits;
+    audio_dbh.dbhSampleSize = sample_bits;
     audio_dbh.dbhCompressionID = 0;
-    audio_dbh.dbhPacketSize    = 0;
-    audio_dbh.dbhSampleRate    = spec->freq << 16;
-    audio_dbh.dbhDoubleBack    = doubleBackProc;
-    audio_dbh.dbhFormat    = 0;
+    audio_dbh.dbhPacketSize = 0;
+    audio_dbh.dbhSampleRate = spec->freq << 16;
+    audio_dbh.dbhDoubleBack = doubleBackProc;
+    audio_dbh.dbhFormat = 0;
 
     /* Note that we install the 16bitLittleEndian Converter if needed. */
-    if ( spec->format == 0x8010 ) {
+    if (spec->format == 0x8010) {
         audio_dbh.dbhCompressionID = fixedCompression;
         audio_dbh.dbhFormat = k16BitLittleEndianFormat;
     }
 
     /* allocate the 2 double-back buffers */
-    for ( i=0; i<2; ++i ) {
-        audio_buf[i] = SDL_calloc(1, sizeof(SndDoubleBuffer)+spec->size);
-        if ( audio_buf[i] == NULL ) {
-            SDL_OutOfMemory();
-            return(-1);
+    for (i = 0; i < 2; ++i) {
+        audio_buf[i] = SDL_calloc (1, sizeof (SndDoubleBuffer) + spec->size);
+        if (audio_buf[i] == NULL) {
+            SDL_OutOfMemory ();
+            return (-1);
         }
         audio_buf[i]->dbNumFrames = spec->samples;
         audio_buf[i]->dbFlags = dbBufferReady;
-        audio_buf[i]->dbUserInfo[0] = (long)this;
+        audio_buf[i]->dbUserInfo[0] = (long) this;
         audio_dbh.dbhBufferPtr[i] = audio_buf[i];
     }
 
     /* Create the sound manager channel */
-    channel = (SndChannelPtr)SDL_malloc(sizeof(*channel));
-    if ( channel == NULL ) {
-        SDL_OutOfMemory();
-        return(-1);
+    channel = (SndChannelPtr) SDL_malloc (sizeof (*channel));
+    if (channel == NULL) {
+        SDL_OutOfMemory ();
+        return (-1);
     }
-    if ( spec->channels >= 2 ) {
+    if (spec->channels >= 2) {
         initOptions = initStereo;
     } else {
         initOptions = initMono;
     }
     channel->userInfo = 0;
     channel->qLength = 128;
-    if ( SndNewChannel(&channel, sampledSynth, initOptions, 0L) != noErr ) {
-        SDL_SetError("Unable to create audio channel");
-        SDL_free(channel);
+    if (SndNewChannel (&channel, sampledSynth, initOptions, 0L) != noErr) {
+        SDL_SetError ("Unable to create audio channel");
+        SDL_free (channel);
         channel = NULL;
-        return(-1);
+        return (-1);
     }
- 
+
     /* Start playback */
-    if ( SndPlayDoubleBuffer(channel, (SndDoubleBufferHeaderPtr)&audio_dbh)
-                                != noErr ) {
-        SDL_SetError("Unable to play double buffered audio");
-        return(-1);
+    if (SndPlayDoubleBuffer (channel, (SndDoubleBufferHeaderPtr) & audio_dbh)
+        != noErr) {
+        SDL_SetError ("Unable to play double buffered audio");
+        return (-1);
     }
-    
+
     return 1;
 }
 
 #endif /* TARGET_API_MAC_CARBON || USE_RYANS_SOUNDCODE */
-
+/* vi: set ts=4 sw=4 expandtab: */