/*

    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)

{

}

/* 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: