--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/audio/qsa/SDL_qsa_audio.c	Tue Mar 24 10:33:12 2009 +0000
@@ -0,0 +1,945 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+
+    QNX Sound Architecture (QSA) SDL driver
+    Copyright (C) 2009 Mike Gorchak
+    (mike@malva.ua, lestat@i.com.ua)
+*/
+
+#include "SDL_config.h"
+
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sched.h>
+#include <sys/select.h>
+#include <sys/neutrino.h>
+#include <sys/asoundlib.h>
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "SDL_qsa_audio.h"
+
+/* The tag name used by QSA audio framework */
+#define DRIVER_NAME "qsa"
+
+/* default channel communication parameters */
+#define DEFAULT_CPARAMS_RATE   44100
+#define DEFAULT_CPARAMS_VOICES 1
+
+#define DEFAULT_CPARAMS_FRAG_SIZE 4096
+#define DEFAULT_CPARAMS_FRAGS_MIN 1
+#define DEFAULT_CPARAMS_FRAGS_MAX 1
+
+#define QSA_NO_WORKAROUNDS  0x00000000
+#define QSA_MMAP_WORKAROUND 0x00000001
+
+struct BuggyCards
+{
+    char* cardname;
+    unsigned long bugtype;
+};
+
+#define QSA_WA_CARDS             3
+#define QSA_MAX_CARD_NAME_LENGTH 33
+
+struct BuggyCards buggycards[QSA_WA_CARDS]=
+{
+   {"Sound Blaster Live!", QSA_MMAP_WORKAROUND},
+   {"Vortex 8820", QSA_MMAP_WORKAROUND},
+   {"Vortex 8830", QSA_MMAP_WORKAROUND},
+};
+
+/* List of found devices */
+#define QSA_MAX_DEVICES       32
+#define QSA_MAX_NAME_LENGTH   81+16 /* Hardcoded in QSA, can't be changed */
+
+typedef struct _QSA_Device
+{
+   char  name[QSA_MAX_NAME_LENGTH];   /* Long audio device name for SDL  */
+   int   cardno;
+   int   deviceno;
+} QSA_Device;
+
+QSA_Device qsa_playback_device[QSA_MAX_DEVICES];
+uint32_t   qsa_playback_devices;
+
+QSA_Device qsa_capture_device[QSA_MAX_DEVICES];
+uint32_t   qsa_capture_devices;
+
+static inline void QSA_SetError(const char* fn, int status)
+{
+   SDL_SetError("QSA: %s failed: %s", fn, snd_strerror(status));
+}
+
+/* card names check to apply the workarounds */
+static int QSA_CheckBuggyCards(_THIS, unsigned long checkfor)
+{
+   char scardname[QSA_MAX_CARD_NAME_LENGTH];
+   int it;
+
+   if (snd_card_get_name(this->hidden->cardno, scardname, QSA_MAX_CARD_NAME_LENGTH-1)<0)
+   {
+      return 0;
+   }
+
+   for (it=0; it<QSA_WA_CARDS; it++)
+   {
+      if (SDL_strcmp(buggycards[it].cardname, scardname)==0)
+      {
+         if (buggycards[it].bugtype==checkfor)
+         {
+            return 1;
+         }
+      }
+   }
+
+   return 0;
+}
+
+static void QSA_ThreadInit(_THIS)
+{
+   struct sched_param param;
+   int status;
+
+   /* Increase default 10 priority to 25 to avoid jerky sound */
+   status=SchedGet(0, 0, &param);
+   param.sched_priority=param.sched_curpriority + 15;
+   status=SchedSet(0, 0, SCHED_NOCHANGE, &param);
+}
+
+/* PCM channel parameters initialize function */
+static void QSA_InitAudioParams(snd_pcm_channel_params_t* cpars)
+{
+   SDL_memset(cpars, 0, sizeof(snd_pcm_channel_params_t));
+
+   cpars->channel=SND_PCM_CHANNEL_PLAYBACK;
+   cpars->mode=SND_PCM_MODE_BLOCK;
+   cpars->start_mode=SND_PCM_START_DATA;
+   cpars->stop_mode=SND_PCM_STOP_STOP;
+   cpars->format.format=SND_PCM_SFMT_S16_LE;
+   cpars->format.interleave=1;
+   cpars->format.rate=DEFAULT_CPARAMS_RATE;
+   cpars->format.voices=DEFAULT_CPARAMS_VOICES;
+   cpars->buf.block.frag_size=DEFAULT_CPARAMS_FRAG_SIZE;
+   cpars->buf.block.frags_min=DEFAULT_CPARAMS_FRAGS_MIN;
+   cpars->buf.block.frags_max=DEFAULT_CPARAMS_FRAGS_MAX;
+}
+
+/* This function waits until it is possible to write a full sound buffer */
+static void QSA_WaitDevice(_THIS)
+{
+   fd_set wfds;
+   fd_set rfds;
+   int selectret;
+   struct timeval timeout;
+
+   if (!this->hidden->iscapture)
+   {
+      FD_ZERO(&wfds);
+      FD_SET(this->hidden->audio_fd, &wfds);
+   }
+   else
+   {
+      FD_ZERO(&rfds);
+      FD_SET(this->hidden->audio_fd, &rfds);
+   }
+
+   do {
+      /* Setup timeout for playing one fragment equal to 2 seconds          */
+      /* If timeout occured than something wrong with hardware or driver    */
+      /* For example, Vortex 8820 audio driver stucks on second DAC because */
+      /* it doesn't exist !                                                 */
+      timeout.tv_sec=2;
+      timeout.tv_usec=0;
+      this->hidden->timeout_on_wait=0;
+
+      if (!this->hidden->iscapture)
+      {
+         selectret=select(this->hidden->audio_fd+1, NULL, &wfds, NULL, &timeout);
+      }
+      else
+      {
+         selectret=select(this->hidden->audio_fd+1, &rfds, NULL, NULL, &timeout);
+      }
+
+      switch(selectret)
+      {
+         case -1:
+              {
+                 SDL_SetError("QSA: select() failed: %s\n", strerror(errno));
+                 return;
+              }
+              break;
+         case 0:
+              {
+                 SDL_SetError("QSA: timeout on buffer waiting occured\n");
+                 this->hidden->timeout_on_wait=1;
+                 return;
+              }
+              break;
+         default:
+              {
+                 if (!this->hidden->iscapture)
+                 {
+                    if (FD_ISSET(this->hidden->audio_fd, &wfds))
+                    {
+                       return;
+                    }
+                 }
+                 else
+                 {
+                    if (FD_ISSET(this->hidden->audio_fd, &rfds))
+                    {
+                       return;
+                    }
+                 }
+              }
+              break;
+      }
+   } while (1);
+}
+
+static void QSA_PlayDevice(_THIS)
+{
+   snd_pcm_channel_status_t cstatus;
+   int   written;
+   int   status;
+   int   towrite;
+   void* pcmbuffer;
+
+   if ((!this->enabled) || (!this->hidden))
+   {
+      return;
+   }
+
+   towrite = this->spec.size;
+   pcmbuffer = this->hidden->pcm_buf;
+
+   /* Write the audio data, checking for EAGAIN (buffer full) and underrun */
+   do {
+      written=snd_pcm_plugin_write(this->hidden->audio_handle, pcmbuffer, towrite);
+      if (written!=towrite)
+      {
+         /* Check if samples playback got stuck somewhere in hardware or in */
+         /* the audio device driver */
+         if ((errno==EAGAIN) && (written==0))
+         {
+            if (this->hidden->timeout_on_wait!=0)
+            {
+               SDL_SetError("QSA: buffer playback timeout\n");
+               return;
+            }
+         }
+
+         /* Check for errors or conditions */
+         if ((errno==EAGAIN)||(errno==EWOULDBLOCK))
+         {
+            /* Let a little CPU time go by and try to write again */
+            SDL_Delay(1);
+
+            /* if we wrote some data */
+            towrite-=written;
+            pcmbuffer+=written*this->spec.channels;
+            continue;
+         }
+         else
+         {
+            if ((errno==EINVAL)||(errno==EIO))
+            {
+               SDL_memset(&cstatus, 0, sizeof(cstatus));
+               if (!this->hidden->iscapture)
+               {
+                  cstatus.channel=SND_PCM_CHANNEL_PLAYBACK;
+               }
+               else
+               {
+                  cstatus.channel=SND_PCM_CHANNEL_CAPTURE;
+               }
+
+               status=snd_pcm_plugin_status(this->hidden->audio_handle, &cstatus);
+               if (status<0)
+               {
+                  QSA_SetError("snd_pcm_plugin_status", status);
+                  return;
+               }
+
+               if ((cstatus.status==SND_PCM_STATUS_UNDERRUN) ||
+                   (cstatus.status==SND_PCM_STATUS_READY))
+               {
+                  if (!this->hidden->iscapture)
+                  {
+                     status=snd_pcm_plugin_prepare(this->hidden->audio_handle,
+                                                   SND_PCM_CHANNEL_PLAYBACK);
+                  }
+                  else
+                  {
+                     status=snd_pcm_plugin_prepare(this->hidden->audio_handle,
+                                                   SND_PCM_CHANNEL_CAPTURE);
+                  }
+                  if (status<0)
+                  {
+                     QSA_SetError("snd_pcm_plugin_prepare", status);
+                     return;
+                  }
+               }
+               continue;
+            }
+            else
+            {
+                return;
+            }
+         }
+      }
+      else
+      {
+         /* we wrote all remaining data */
+         towrite -= written;
+         pcmbuffer += written * this->spec.channels;
+      }
+   } while ((towrite>0) && (this->enabled));
+
+   /* If we couldn't write, assume fatal error for now */
+   if (towrite!=0)
+   {
+      this->enabled=0;
+   }
+}
+
+static Uint8* QSA_GetDeviceBuf(_THIS)
+{
+   return this->hidden->pcm_buf;
+}
+
+static void QSA_CloseDevice(_THIS)
+{
+   if (this->hidden!=NULL)
+   {
+      if (this->hidden->audio_handle!=NULL)
+      {
+         if (!this->hidden->iscapture)
+         {
+            /* Finish playing available samples */
+            snd_pcm_plugin_flush(this->hidden->audio_handle, SND_PCM_CHANNEL_PLAYBACK);
+         }
+         else
+         {
+            /* Cancel unread samples during capture */
+            snd_pcm_plugin_flush(this->hidden->audio_handle, SND_PCM_CHANNEL_CAPTURE);
+         }
+         snd_pcm_close(this->hidden->audio_handle);
+         this->hidden->audio_handle=NULL;
+      }
+
+      if (this->hidden->pcm_buf!=NULL)
+      {
+         SDL_FreeAudioMem(this->hidden->pcm_buf);
+         this->hidden->pcm_buf=NULL;
+      }
+
+      SDL_free(this->hidden);
+      this->hidden=NULL;
+   }
+}
+
+static int QSA_OpenDevice(_THIS, const char* devname, int iscapture)
+{
+   int status=0;
+   int format=0;
+   SDL_AudioFormat test_format=0;
+   int found=0;
+   snd_pcm_channel_setup_t  csetup;
+   snd_pcm_channel_params_t cparams;
+
+   /* Initialize all variables that we clean on shutdown */
+   this->hidden=(struct SDL_PrivateAudioData*)SDL_calloc(1, (sizeof(struct SDL_PrivateAudioData)));
+   if (this->hidden==NULL)
+   {
+      SDL_OutOfMemory();
+      return 0;
+   }
+   SDL_memset(this->hidden, 0, sizeof(struct SDL_PrivateAudioData));
+
+   /* Initialize channel transfer parameters to default */
+   QSA_InitAudioParams(&cparams);
+
+   /* Initialize channel direction: capture or playback */
+   this->hidden->iscapture=iscapture;
+
+   /* Find deviceid and cardid by device name for playback */
+   if ((!this->hidden->iscapture) && (devname!=NULL))
+   {
+      uint32_t device;
+      int32_t  status;
+
+      /* Search in the playback devices */
+      device=0;
+      do {
+         status=SDL_strcmp(qsa_playback_device[device].name, devname);
+         if (status==0)
+         {
+            /* Found requested device */
+            this->hidden->deviceno=qsa_playback_device[device].deviceno;
+            this->hidden->cardno=qsa_playback_device[device].cardno;
+            break;
+         }
+         device++;
+         if (device>=qsa_playback_devices)
+         {
+            QSA_CloseDevice(this);
+            SDL_SetError("No such playback device");
+            return 0;
+         }
+      } while(1);
+   }
+
+   /* Find deviceid and cardid by device name for capture */
+   if ((this->hidden->iscapture) && (devname!=NULL))
+   {
+      /* Search in the capture devices */
+      uint32_t device;
+      int32_t  status;
+
+      /* Searching in the playback devices */
+      device=0;
+      do {
+         status=SDL_strcmp(qsa_capture_device[device].name, devname);
+         if (status==0)
+         {
+            /* Found requested device */
+            this->hidden->deviceno=qsa_capture_device[device].deviceno;
+            this->hidden->cardno=qsa_capture_device[device].cardno;
+            break;
+         }
+         device++;
+         if (device>=qsa_capture_devices)
+         {
+            QSA_CloseDevice(this);
+            SDL_SetError("No such capture device");
+            return 0;
+         }
+      } while(1);
+   }
+
+   /* Check if SDL requested default audio device */
+   if (devname==NULL)
+   {
+      /* Open system default audio device */
+      if (!this->hidden->iscapture)
+      {
+         status=snd_pcm_open_preferred(&this->hidden->audio_handle,
+                                       &this->hidden->cardno,
+                                       &this->hidden->deviceno, SND_PCM_OPEN_PLAYBACK);
+      }
+      else
+      {
+         status=snd_pcm_open_preferred(&this->hidden->audio_handle,
+                                       &this->hidden->cardno,
+                                       &this->hidden->deviceno, SND_PCM_OPEN_CAPTURE);
+      }
+   }
+   else
+   {
+      /* Open requested audio device */
+      if (!this->hidden->iscapture)
+      {
+         status=snd_pcm_open(&this->hidden->audio_handle, this->hidden->cardno,
+                              this->hidden->deviceno, SND_PCM_OPEN_PLAYBACK);
+      }
+      else
+      {
+         status=snd_pcm_open(&this->hidden->audio_handle, this->hidden->cardno,
+                              this->hidden->deviceno, SND_PCM_OPEN_CAPTURE);
+      }
+   }
+
+   /* Check if requested device is opened */
+   if (status<0)
+   {
+      QSA_CloseDevice(this);
+      QSA_SetError("snd_pcm_open", status);
+      return 0;
+   }
+
+   if (!QSA_CheckBuggyCards(this, QSA_MMAP_WORKAROUND))
+   {
+      /* Disable QSA MMAP plugin for buggy audio drivers */
+      status=snd_pcm_plugin_set_disable(this->hidden->audio_handle, PLUGIN_DISABLE_MMAP);
+      if (status<0)
+      {
+         QSA_CloseDevice(this);
+         QSA_SetError("snd_pcm_plugin_set_disable", status);
+         return 0;
+      }
+   }
+
+   /* Try for a closest match on audio format */
+   format = 0;
+   /* can't use format as SND_PCM_SFMT_U8 = 0 in qsa */
+   found = 0;
+
+   for (test_format = SDL_FirstAudioFormat(this->spec.format); !found;)
+   {
+      /* if match found set format to equivalent QSA format */
+      switch (test_format)
+      {
+         case AUDIO_U8:
+              {
+                 format=SND_PCM_SFMT_U8;
+                 found=1;
+              }
+              break;
+         case AUDIO_S8:
+              {
+                 format=SND_PCM_SFMT_S8;
+                 found=1;
+              }
+              break;
+         case AUDIO_S16LSB:
+              {
+                 format=SND_PCM_SFMT_S16_LE;
+                 found=1;
+              }
+              break;
+         case AUDIO_S16MSB:
+              {
+                 format=SND_PCM_SFMT_S16_BE;
+                 found=1;
+              }
+              break;
+         case AUDIO_U16LSB:
+              {
+                 format=SND_PCM_SFMT_U16_LE;
+                 found=1;
+              }
+              break;
+         case AUDIO_U16MSB:
+              {
+                 format=SND_PCM_SFMT_U16_BE;
+                 found=1;
+              }
+              break;
+         case AUDIO_S32LSB:
+              {
+                 format=SND_PCM_SFMT_S32_LE;
+                 found=1;
+              }
+              break;
+         case AUDIO_S32MSB:
+              {
+                 format=SND_PCM_SFMT_S32_BE;
+                 found=1;
+              }
+              break;
+         case AUDIO_F32LSB:
+              {
+                 format=SND_PCM_SFMT_FLOAT_LE;
+                 found=1;
+              }
+              break;
+         case AUDIO_F32MSB:
+              {
+                 format=SND_PCM_SFMT_FLOAT_BE;
+                 found=1;
+              }
+              break;
+         default:
+              {
+                 break;
+              }
+      }
+
+      if (!found)
+      {
+         test_format = SDL_NextAudioFormat();
+      }
+   }
+
+   /* assumes test_format not 0 on success */
+   if (test_format==0)
+   {
+      QSA_CloseDevice(this);
+      SDL_SetError("QSA: Couldn't find any hardware audio formats");
+      return 0;
+   }
+
+   this->spec.format=test_format;
+
+   /* Set the audio format */
+   cparams.format.format=format;
+
+   /* Set mono/stereo/4ch/6ch/8ch audio */
+   cparams.format.voices=this->spec.channels;
+
+   /* Set rate */
+   cparams.format.rate=this->spec.freq;
+
+   /* Setup the transfer parameters according to cparams */
+   status=snd_pcm_plugin_params(this->hidden->audio_handle, &cparams);
+   if (status<0)
+   {
+      QSA_CloseDevice(this);
+      QSA_SetError("snd_pcm_channel_params", status);
+      return 0;
+   }
+
+   /* Make sure channel is setup right one last time */
+   SDL_memset(&csetup, '\0', sizeof(csetup));
+   if (!this->hidden->iscapture)
+   {
+      csetup.channel=SND_PCM_CHANNEL_PLAYBACK;
+   }
+   else
+   {
+      csetup.channel=SND_PCM_CHANNEL_CAPTURE;
+   }
+
+   /* Setup an audio channel */
+   if (snd_pcm_plugin_setup(this->hidden->audio_handle, &csetup) < 0)
+   {
+      QSA_CloseDevice(this);
+      SDL_SetError("QSA: Unable to setup channel\n");
+      return 0;
+   }
+
+   /* Calculate the final parameters for this audio specification */
+   SDL_CalculateAudioSpec(&this->spec);
+
+   this->hidden->pcm_len = this->spec.size;
+
+   if (this->hidden->pcm_len==0)
+   {
+      this->hidden->pcm_len=csetup.buf.block.frag_size * this->spec.channels *
+                           (snd_pcm_format_width(format) / 8);
+   }
+
+   /*
+    * Allocate memory to the audio buffer and initialize with silence
+    *  (Note that buffer size must be a multiple of fragment size, so find
+    *  closest multiple)
+    */
+   this->hidden->pcm_buf=(Uint8*)SDL_AllocAudioMem(this->hidden->pcm_len);
+   if (this->hidden->pcm_buf==NULL)
+   {
+      QSA_CloseDevice(this);
+      SDL_OutOfMemory();
+      return 0;
+   }
+   SDL_memset(this->hidden->pcm_buf, this->spec.silence, this->hidden->pcm_len);
+
+   /* get the file descriptor */
+   if (!this->hidden->iscapture)
+   {
+      this->hidden->audio_fd=snd_pcm_file_descriptor(this->hidden->audio_handle,
+                                                     SND_PCM_CHANNEL_PLAYBACK);
+   }
+   else
+   {
+      this->hidden->audio_fd=snd_pcm_file_descriptor(this->hidden->audio_handle,
+                                                     SND_PCM_CHANNEL_CAPTURE);
+   }
+
+   if (this->hidden->audio_fd<0)
+   {
+      QSA_CloseDevice(this);
+      QSA_SetError("snd_pcm_file_descriptor", status);
+      return 0;
+   }
+
+   /* Prepare an audio channel */
+   if (!this->hidden->iscapture)
+   {
+      /* Prepare audio playback */
+      status=snd_pcm_plugin_prepare(this->hidden->audio_handle, SND_PCM_CHANNEL_PLAYBACK);
+   }
+   else
+   {
+      /* Prepare audio capture */
+      status=snd_pcm_plugin_prepare(this->hidden->audio_handle, SND_PCM_CHANNEL_CAPTURE);
+   }
+
+   if (status<0)
+   {
+      QSA_CloseDevice(this);
+      QSA_SetError("snd_pcm_plugin_prepare", status);
+      return 0;
+   }
+
+   /* We're really ready to rock and roll. :-) */
+   return 1;
+}
+
+int QSA_DetectDevices(int iscapture)
+{
+   uint32_t it;
+   uint32_t cards;
+   uint32_t devices;
+   int32_t  status;
+
+   /* Detect amount of available devices       */
+   /* this value can be changed in the runtime */
+   cards=snd_cards();
+
+   /* If io-audio manager is not running we will get 0 as number */
+   /* of available audio devices                                 */
+   if (cards==0)
+   {
+      /* We have no any available audio devices */
+      return 0;
+   }
+
+   /* Find requested devices by type */
+   if (!iscapture)
+   {
+      /* Playback devices enumeration requested */
+      for(it=0; it<cards; it++)
+      {
+         devices=0;
+         do {
+            status=snd_card_get_longname(it, qsa_playback_device[qsa_playback_devices].name, QSA_MAX_NAME_LENGTH);
+            if (status==EOK)
+            {
+               snd_pcm_t* handle;
+
+               /* Add device number to device name */
+               sprintf(qsa_playback_device[qsa_playback_devices].name + SDL_strlen(qsa_playback_device[qsa_playback_devices].name), " d%d", devices);
+
+               /* Store associated card number id */
+               qsa_playback_device[qsa_playback_devices].cardno=it;
+
+               /* Check if this device id could play anything */
+               status=snd_pcm_open(&handle, it, devices, SND_PCM_OPEN_PLAYBACK);
+               if (status==EOK)
+               {
+                  qsa_playback_device[qsa_playback_devices].deviceno=devices;
+                  status=snd_pcm_close(handle);
+                  if (status==EOK)
+                  {
+                     qsa_playback_devices++;
+                  }
+               }
+               else
+               {
+                  /* Check if we got end of devices list */
+                  if (status==-ENOENT)
+                  {
+                     break;
+                  }
+               }
+            }
+            else
+            {
+               break;
+            }
+
+            /* Check if we reached maximum devices count */
+            if (qsa_playback_devices>=QSA_MAX_DEVICES)
+            {
+               break;
+            }
+            devices++;
+         } while(1);
+
+         /* Check if we reached maximum devices count */
+         if (qsa_playback_devices>=QSA_MAX_DEVICES)
+         {
+            break;
+         }
+      }
+   }
+   else
+   {
+      /* Capture devices enumeration requested */
+      for(it=0; it<cards; it++)
+      {
+         devices=0;
+         do {
+            status=snd_card_get_longname(it, qsa_capture_device[qsa_capture_devices].name, QSA_MAX_NAME_LENGTH);
+            if (status==EOK)
+            {
+               snd_pcm_t* handle;
+
+               /* Add device number to device name */
+               sprintf(qsa_capture_device[qsa_capture_devices].name + SDL_strlen(qsa_capture_device[qsa_capture_devices].name), " d%d", devices);
+
+               /* Store associated card number id */
+               qsa_capture_device[qsa_capture_devices].cardno=it;
+
+               /* Check if this device id could play anything */
+               status=snd_pcm_open(&handle, it, devices, SND_PCM_OPEN_CAPTURE);
+               if (status==EOK)
+               {
+                  qsa_capture_device[qsa_capture_devices].deviceno=devices;
+                  status=snd_pcm_close(handle);
+                  if (status==EOK)
+                  {
+                     qsa_capture_devices++;
+                  }
+               }
+               else
+               {
+                  /* Check if we got end of devices list */
+                  if (status==-ENOENT)
+                  {
+                     break;
+                  }
+               }
+
+               /* Check if we reached maximum devices count */
+               if (qsa_capture_devices>=QSA_MAX_DEVICES)
+               {
+                  break;
+               }
+            }
+            else
+            {
+               break;
+            }
+            devices++;
+         } while(1);
+
+         /* Check if we reached maximum devices count */
+         if (qsa_capture_devices>=QSA_MAX_DEVICES)
+         {
+            break;
+         }
+      }
+   }
+
+   /* Return amount of available playback or capture devices */
+   if (!iscapture)
+   {
+      return qsa_playback_devices;
+   }
+   else
+   {
+      return qsa_capture_devices;
+   }
+}
+
+const char* QSA_GetDeviceName(int index, int iscapture)
+{
+   if (!iscapture)
+   {
+      if (index>=qsa_playback_devices)
+      {
+         return "No such playback device";
+      }
+
+      return qsa_playback_device[index].name;
+   }
+   else
+   {
+      if (index>=qsa_capture_devices)
+      {
+         return "No such capture device";
+      }
+
+      return qsa_capture_device[index].name;
+   }
+}
+
+void QSA_WaitDone(_THIS)
+{
+   if (!this->hidden->iscapture)
+   {
+      if (this->hidden->audio_handle!=NULL)
+      {
+         /* Wait till last fragment is played and stop channel */
+         snd_pcm_plugin_flush(this->hidden->audio_handle, SND_PCM_CHANNEL_PLAYBACK);
+      }
+   }
+   else
+   {
+      if (this->hidden->audio_handle!=NULL)
+      {
+         /* Discard all unread data and stop channel */
+         snd_pcm_plugin_flush(this->hidden->audio_handle, SND_PCM_CHANNEL_CAPTURE);
+      }
+   }
+}
+
+void QSA_Deinitialize(void)
+{
+   /* Clear devices array on shutdown */
+   SDL_memset(qsa_playback_device, 0x00, sizeof(QSA_Device)*QSA_MAX_DEVICES);
+   SDL_memset(qsa_capture_device, 0x00, sizeof(QSA_Device)*QSA_MAX_DEVICES);
+   qsa_playback_devices=0;
+   qsa_capture_devices=0;
+}
+
+static int QSA_Init(SDL_AudioDriverImpl* impl)
+{
+   snd_pcm_t* handle=NULL;
+   int32_t    status=0;
+
+   /* Clear devices array */
+   SDL_memset(qsa_playback_device, 0x00, sizeof(QSA_Device)*QSA_MAX_DEVICES);
+   SDL_memset(qsa_capture_device, 0x00, sizeof(QSA_Device)*QSA_MAX_DEVICES);
+   qsa_playback_devices=0;
+   qsa_capture_devices=0;
+
+   /* Set function pointers                                     */
+   /* DeviceLock and DeviceUnlock functions are used default,   */
+   /* provided by SDL, which uses pthread_mutex for lock/unlock */
+   impl->DetectDevices=QSA_DetectDevices;
+   impl->GetDeviceName=QSA_GetDeviceName;
+   impl->OpenDevice=QSA_OpenDevice;
+   impl->ThreadInit=QSA_ThreadInit;
+   impl->WaitDevice=QSA_WaitDevice;
+   impl->PlayDevice=QSA_PlayDevice;
+   impl->GetDeviceBuf=QSA_GetDeviceBuf;
+   impl->CloseDevice=QSA_CloseDevice;
+   impl->WaitDone=QSA_WaitDone;
+   impl->Deinitialize=QSA_Deinitialize;
+   impl->LockDevice=NULL;
+   impl->UnlockDevice=NULL;
+
+   impl->OnlyHasDefaultOutputDevice=0;
+   impl->ProvidesOwnCallbackThread=0;
+   impl->SkipMixerLock=0;
+   impl->HasCaptureSupport=1;
+   impl->OnlyHasDefaultOutputDevice=0;
+   impl->OnlyHasDefaultInputDevice=0;
+
+   /* Check if io-audio manager is running or not */
+   status=snd_cards();
+   if (status==0)
+   {
+      /* if no, return immediately */
+      return 1;
+   }
+
+   /* At this point we are definitely has an audio device */
+   return 2;
+}
+
+AudioBootStrap QSAAUDIO_bootstrap=
+{
+   DRIVER_NAME, "QNX QSA Audio", QSA_Init, 0
+};
+
+/* vi: set ts=4 sw=4 expandtab: */