--- a/src/audio/amigaos/SDL_ahiaudio.c	Mon May 29 03:53:21 2006 +0000
+++ b/src/audio/amigaos/SDL_ahiaudio.c	Mon May 29 04:04:35 2006 +0000
@@ -28,11 +28,11 @@
 #include "SDL_ahiaudio.h"
 
 /* Audio driver functions */
-static int AHI_OpenAudio (_THIS, SDL_AudioSpec * spec);
-static void AHI_WaitAudio (_THIS);
-static void AHI_PlayAudio (_THIS);
-static Uint8 *AHI_GetAudioBuf (_THIS);
-static void AHI_CloseAudio (_THIS);
+static int AHI_OpenAudio(_THIS, SDL_AudioSpec * spec);
+static void AHI_WaitAudio(_THIS);
+static void AHI_PlayAudio(_THIS);
+static Uint8 *AHI_GetAudioBuf(_THIS);
+static void AHI_CloseAudio(_THIS);
 
 #ifndef __SASC
 #define mymalloc(x) AllocVec(x,MEMF_PUBLIC)
@@ -45,64 +45,64 @@
 /* Audio driver bootstrap functions */
 
 static int
-Audio_Available (void)
+Audio_Available(void)
 {
     int ok = 0;
     struct MsgPort *p;
     struct AHIRequest *req;
 
-    if (p = CreateMsgPort ()) {
+    if (p = CreateMsgPort()) {
         if (req =
-            (struct AHIRequest *) CreateIORequest (p,
-                                                   sizeof (struct
-                                                           AHIRequest))) {
+            (struct AHIRequest *) CreateIORequest(p,
+                                                  sizeof(struct
+                                                         AHIRequest))) {
             req->ahir_Version = 4;
 
-            if (!OpenDevice (AHINAME, 0, (struct IORequest *) req, NULL)) {
-                D (bug ("AHI available.\n"));
+            if (!OpenDevice(AHINAME, 0, (struct IORequest *) req, NULL)) {
+                D(bug("AHI available.\n"));
                 ok = 1;
-                CloseDevice ((struct IORequest *) req);
+                CloseDevice((struct IORequest *) req);
             }
-            DeleteIORequest ((struct IORequest *) req);
+            DeleteIORequest((struct IORequest *) req);
         }
-        DeleteMsgPort (p);
+        DeleteMsgPort(p);
     }
 
-    D (if (!ok) bug ("AHI not available\n"));
+    D(if (!ok) bug("AHI not available\n"));
     return ok;
 }
 
 static void
-Audio_DeleteDevice (SDL_AudioDevice * device)
+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)
+Audio_CreateDevice(int devindex)
 {
     SDL_AudioDevice *this;
 
 #ifndef NO_AMIGADEBUG
-    D (bug ("AHI created...\n"));
+    D(bug("AHI created...\n"));
 #endif
 
     /* Initialize all variables that we clean on shutdown */
-    this = (SDL_AudioDevice *) SDL_malloc (sizeof (SDL_AudioDevice));
+    this = (SDL_AudioDevice *) SDL_malloc(sizeof(SDL_AudioDevice));
     if (this) {
-        SDL_memset (this, 0, (sizeof *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 ();
+        SDL_OutOfMemory();
         if (this) {
-            SDL_free (this);
+            SDL_free(this);
         }
         return (0);
     }
-    SDL_memset (this->hidden, 0, (sizeof *this->hidden));
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
 
     /* Set the function pointers */
     this->OpenAudio = AHI_OpenAudio;
@@ -122,19 +122,19 @@
 
 
 void static
-AHI_WaitAudio (_THIS)
+AHI_WaitAudio(_THIS)
 {
-    if (!CheckIO ((struct IORequest *) audio_req[current_buffer])) {
-        WaitIO ((struct IORequest *) audio_req[current_buffer]);
+    if (!CheckIO((struct IORequest *) audio_req[current_buffer])) {
+        WaitIO((struct IORequest *) audio_req[current_buffer]);
 //              AbortIO((struct IORequest *)audio_req[current_buffer]);
     }
 }
 
 static void
-AHI_PlayAudio (_THIS)
+AHI_PlayAudio(_THIS)
 {
     if (playing > 1)
-        WaitIO ((struct IORequest *) audio_req[current_buffer]);
+        WaitIO((struct IORequest *) audio_req[current_buffer]);
 
     /* Write the audio data out */
     audio_req[current_buffer]->ahir_Std.io_Message.mn_Node.ln_Pri = 60;
@@ -149,92 +149,92 @@
     audio_req[current_buffer]->ahir_Link =
         (playing > 0 ? audio_req[current_buffer ^ 1] : NULL);
 
-    SendIO ((struct IORequest *) audio_req[current_buffer]);
+    SendIO((struct IORequest *) audio_req[current_buffer]);
     current_buffer ^= 1;
 
     playing++;
 }
 
 static Uint8 *
-AHI_GetAudioBuf (_THIS)
+AHI_GetAudioBuf(_THIS)
 {
     return (mixbuf[current_buffer]);
 }
 
 static void
-AHI_CloseAudio (_THIS)
+AHI_CloseAudio(_THIS)
 {
-    D (bug ("Closing audio...\n"));
+    D(bug("Closing audio...\n"));
 
     playing = 0;
 
     if (audio_req[0]) {
         if (audio_req[1]) {
-            D (bug ("Break req[1]...\n"));
+            D(bug("Break req[1]...\n"));
 
-            AbortIO ((struct IORequest *) audio_req[1]);
-            WaitIO ((struct IORequest *) audio_req[1]);
+            AbortIO((struct IORequest *) audio_req[1]);
+            WaitIO((struct IORequest *) audio_req[1]);
         }
 
-        D (bug ("Break req[0]...\n"));
+        D(bug("Break req[0]...\n"));
 
-        AbortIO ((struct IORequest *) audio_req[0]);
-        WaitIO ((struct IORequest *) audio_req[0]);
+        AbortIO((struct IORequest *) audio_req[0]);
+        WaitIO((struct IORequest *) audio_req[0]);
 
         if (audio_req[1]) {
-            D (bug ("Break AGAIN req[1]...\n"));
-            AbortIO ((struct IORequest *) audio_req[1]);
-            WaitIO ((struct IORequest *) audio_req[1]);
+            D(bug("Break AGAIN req[1]...\n"));
+            AbortIO((struct IORequest *) audio_req[1]);
+            WaitIO((struct IORequest *) audio_req[1]);
         }
 // Double abort to be sure to break the dbuffering process.
 
-        SDL_Delay (200);
+        SDL_Delay(200);
 
-        D (bug ("Reqs breaked, closing device...\n"));
-        CloseDevice ((struct IORequest *) audio_req[0]);
-        D (bug ("Device closed, freeing memory...\n"));
-        myfree (audio_req[1]);
-        D (bug ("Memory freed, deleting IOReq...\n"));
-        DeleteIORequest ((struct IORequest *) audio_req[0]);
+        D(bug("Reqs breaked, closing device...\n"));
+        CloseDevice((struct IORequest *) audio_req[0]);
+        D(bug("Device closed, freeing memory...\n"));
+        myfree(audio_req[1]);
+        D(bug("Memory freed, deleting IOReq...\n"));
+        DeleteIORequest((struct IORequest *) audio_req[0]);
         audio_req[0] = audio_req[1] = NULL;
     }
 
-    D (bug ("Freeing mixbuf[0]...\n"));
+    D(bug("Freeing mixbuf[0]...\n"));
     if (mixbuf[0] != NULL) {
-        myfree (mixbuf[0]);
+        myfree(mixbuf[0]);
 //              SDL_FreeAudioMem(mixbuf[0]);
         mixbuf[0] = NULL;
     }
 
-    D (bug ("Freeing mixbuf[1]...\n"));
+    D(bug("Freeing mixbuf[1]...\n"));
     if (mixbuf[1] != NULL) {
-        myfree (mixbuf[1]);
+        myfree(mixbuf[1]);
 //              SDL_FreeAudioMem(mixbuf[1]);
         mixbuf[1] = NULL;
     }
 
-    D (bug ("Freeing audio_port...\n"));
+    D(bug("Freeing audio_port...\n"));
 
     if (audio_port != NULL) {
-        DeleteMsgPort (audio_port);
+        DeleteMsgPort(audio_port);
         audio_port = NULL;
     }
-    D (bug ("...done!\n"));
+    D(bug("...done!\n"));
 }
 
 static int
-AHI_OpenAudio (_THIS, SDL_AudioSpec * spec)
+AHI_OpenAudio(_THIS, SDL_AudioSpec * spec)
 {
 //      int width;
 
-    D (bug ("AHI opening...\n"));
+    D(bug("AHI opening...\n"));
 
     /* Determine the audio parameters from the AudioSpec */
     switch (spec->format & 0xFF) {
 
     case 8:
         {                       /* Signed 8 bit audio data */
-            D (bug ("Samples a 8 bit...\n"));
+            D(bug("Samples a 8 bit...\n"));
             spec->format = AUDIO_S8;
             this->hidden->bytespersample = 1;
             if (spec->channels < 2)
@@ -246,7 +246,7 @@
 
     case 16:
         {                       /* Signed 16 bit audio data */
-            D (bug ("Samples a 16 bit...\n"));
+            D(bug("Samples a 16 bit...\n"));
             spec->format = AUDIO_S16MSB;
             this->hidden->bytespersample = 2;
             if (spec->channels < 2)
@@ -258,89 +258,88 @@
 
     default:
         {
-            SDL_SetError ("Unsupported audio format");
+            SDL_SetError("Unsupported audio format");
             return (-1);
         }
     }
 
     if (spec->channels != 1 && spec->channels != 2) {
-        D (bug ("Wrong channel number!\n"));
-        SDL_SetError ("Channel number non supported");
+        D(bug("Wrong channel number!\n"));
+        SDL_SetError("Channel number non supported");
         return -1;
     }
 
-    D (bug ("Before CalculateAudioSpec\n"));
+    D(bug("Before CalculateAudioSpec\n"));
     /* Update the fragment size as size in bytes */
-    SDL_CalculateAudioSpec (spec);
+    SDL_CalculateAudioSpec(spec);
 
-    D (bug ("Before CreateMsgPort\n"));
+    D(bug("Before CreateMsgPort\n"));
 
-    if (!(audio_port = CreateMsgPort ())) {
-        SDL_SetError ("Unable to create a MsgPort");
+    if (!(audio_port = CreateMsgPort())) {
+        SDL_SetError("Unable to create a MsgPort");
         return -1;
     }
 
-    D (bug ("Before CreateIORequest\n"));
+    D(bug("Before CreateIORequest\n"));
 
     if (!
         (audio_req[0] =
-         (struct AHIRequest *) CreateIORequest (audio_port,
-                                                sizeof (struct AHIRequest))))
-    {
-        SDL_SetError ("Unable to create an AHIRequest");
-        DeleteMsgPort (audio_port);
+         (struct AHIRequest *) CreateIORequest(audio_port,
+                                               sizeof(struct AHIRequest)))) {
+        SDL_SetError("Unable to create an AHIRequest");
+        DeleteMsgPort(audio_port);
         return -1;
     }
 
     audio_req[0]->ahir_Version = 4;
 
-    if (OpenDevice (AHINAME, 0, (struct IORequest *) audio_req[0], NULL)) {
-        SDL_SetError ("Unable to open AHI device!\n");
-        DeleteIORequest ((struct IORequest *) audio_req[0]);
-        DeleteMsgPort (audio_port);
+    if (OpenDevice(AHINAME, 0, (struct IORequest *) audio_req[0], NULL)) {
+        SDL_SetError("Unable to open AHI device!\n");
+        DeleteIORequest((struct IORequest *) audio_req[0]);
+        DeleteMsgPort(audio_port);
         return -1;
     }
 
-    D (bug ("AFTER opendevice\n"));
+    D(bug("AFTER opendevice\n"));
 
     /* Set output frequency and size */
     this->hidden->freq = spec->freq;
     this->hidden->size = spec->size;
 
-    D (bug ("Before buffer allocation\n"));
+    D(bug("Before buffer allocation\n"));
 
     /* Allocate mixing buffer */
-    mixbuf[0] = (Uint8 *) mymalloc (spec->size);
-    mixbuf[1] = (Uint8 *) mymalloc (spec->size);
+    mixbuf[0] = (Uint8 *) mymalloc(spec->size);
+    mixbuf[1] = (Uint8 *) mymalloc(spec->size);
 
-    D (bug ("Before audio_req allocation\n"));
+    D(bug("Before audio_req allocation\n"));
 
-    if (!(audio_req[1] = mymalloc (sizeof (struct AHIRequest)))) {
-        SDL_OutOfMemory ();
+    if (!(audio_req[1] = mymalloc(sizeof(struct AHIRequest)))) {
+        SDL_OutOfMemory();
         return (-1);
     }
 
-    D (bug ("Before audio_req memcpy\n"));
+    D(bug("Before audio_req memcpy\n"));
 
-    SDL_memcpy (audio_req[1], audio_req[0], sizeof (struct AHIRequest));
+    SDL_memcpy(audio_req[1], audio_req[0], sizeof(struct AHIRequest));
 
     if (mixbuf[0] == NULL || mixbuf[1] == NULL) {
-        SDL_OutOfMemory ();
+        SDL_OutOfMemory();
         return (-1);
     }
 
-    D (bug ("Before mixbuf memset\n"));
+    D(bug("Before mixbuf memset\n"));
 
-    SDL_memset (mixbuf[0], spec->silence, spec->size);
-    SDL_memset (mixbuf[1], spec->silence, spec->size);
+    SDL_memset(mixbuf[0], spec->silence, spec->size);
+    SDL_memset(mixbuf[1], spec->silence, spec->size);
 
     current_buffer = 0;
     playing = 0;
 
-    D (bug
-       ("AHI opened: freq:%ld mixbuf:%lx/%lx buflen:%ld bits:%ld channels:%ld\n",
-        spec->freq, mixbuf[0], mixbuf[1], spec->size,
-        this->hidden->bytespersample * 8, spec->channels));
+    D(bug
+      ("AHI opened: freq:%ld mixbuf:%lx/%lx buflen:%ld bits:%ld channels:%ld\n",
+       spec->freq, mixbuf[0], mixbuf[1], spec->size,
+       this->hidden->bytespersample * 8, spec->channels));
 
     /* We're ready to rock and roll. :-) */
     return (0);