char *cardname;

    unsigned long bugtype;

struct BuggyCards buggycards[QSA_WA_CARDS] = {

    {"Sound Blaster Live!", QSA_MMAP_WORKAROUND},

    {"Vortex 8820", QSA_MMAP_WORKAROUND},

    {"Vortex 8830", QSA_MMAP_WORKAROUND},

static void NTO_ThreadInit (_THIS);

static int NTO_OpenAudio (_THIS, SDL_AudioSpec * spec);

static void NTO_WaitAudio (_THIS);

static void NTO_PlayAudio (_THIS);

static Uint8 *NTO_GetAudioBuf (_THIS);

static void NTO_CloseAudio (_THIS);

static int

NTO_CheckBuggyCards (_THIS, unsigned long checkfor)

    if (snd_card_get_name (cardno, scardname, 32) < 0) {

    for (it = 0; it < QSA_WA_CARDS; it++) {

        if (SDL_strcmp (buggycards[it].cardname, scardname) == 0) {

            if (buggycards[it].bugtype == checkfor) {

                return 1;

            }

        }

static void

NTO_ThreadInit (_THIS)

    int status;

    struct sched_param param;

    /* increasing 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);

static void

NTO_InitAudioParams (snd_pcm_channel_params_t * cpars)

    SDL_memset (cpars, 0, sizeof (snd_pcm_channel_params_t));

    cpars->stop_mode = SND_PCM_STOP_STOP;

static int

NTO_AudioAvailable (void)

       Return value '1' means we can.

       Return value '0' means we cannot. */

    snd_pcm_t *handle;

    rval = snd_pcm_open_preferred (&handle, NULL, NULL, OPEN_FLAGS);

    if (rval >= 0) {

        if ((rval = snd_pcm_close (handle)) < 0) {

            SDL_SetError

                ("NTO_AudioAvailable(): snd_pcm_close failed: %s\n",

                 snd_strerror (rval));

    } else {

        SDL_SetError

            ("NTO_AudioAvailable(): there are no available audio devices.\n");

static void

NTO_DeleteAudioDevice (SDL_AudioDevice * device)

    if ((device) && (device->hidden)) {

        SDL_free (device->hidden);

    if (device) {

        SDL_free (device);

static SDL_AudioDevice *

NTO_CreateAudioDevice (int devindex)

    this = (SDL_AudioDevice *) SDL_malloc (sizeof (SDL_AudioDevice));

    if (this) {

        SDL_memset (this, 0, sizeof (SDL_AudioDevice));

        this->hidden = (struct SDL_PrivateAudioData *)

            SDL_malloc (sizeof (struct SDL_PrivateAudioData));

    if ((this == NULL) || (this->hidden == NULL)) {

        SDL_OutOfMemory ();

        if (this) {

            SDL_free (this);

        }

    SDL_memset (this->hidden, 0, sizeof (struct SDL_PrivateAudioData));

AudioBootStrap QNXNTOAUDIO_bootstrap = {

static void

NTO_WaitAudio (_THIS)

    FD_ZERO (&wfds);

    FD_SET (audio_fd, &wfds);

        selectret = select (audio_fd + 1, NULL, &wfds, NULL, NULL);

        switch (selectret) {

        case -1:

        case 0:

            SDL_SetError ("NTO_WaitAudio(): select() failed: %s\n",

                          strerror (errno));

            return;

        default:

            if (FD_ISSET (audio_fd, &wfds)) {

                return;

            }

            break;

    }

    while (1);

static void

NTO_PlayAudio (_THIS)

    void *pcmbuffer;

    if (!this->enabled) {

        written = snd_pcm_plugin_write (audio_handle, pcm_buf, towrite);

        if (written != towrite) {

            if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {

                SDL_Delay (1);

            } else {

                if ((errno == EINVAL) || (errno == EIO)) {

                    SDL_memset (&cstatus, 0, sizeof (cstatus));

                    if ((rval =

                         snd_pcm_plugin_status (audio_handle,

                                                &cstatus)) < 0) {

                        SDL_SetError

                            ("NTO_PlayAudio(): snd_pcm_plugin_status failed: %s\n",

                             snd_strerror (rval));

                    }

                    if ((cstatus.status == SND_PCM_STATUS_UNDERRUN)

                        || (cstatus.status == SND_PCM_STATUS_READY)) {

                        if ((rval =

                             snd_pcm_plugin_prepare (audio_handle,

                                                     SND_PCM_CHANNEL_PLAYBACK))

                            < 0) {

                            SDL_SetError

                                ("NTO_PlayAudio(): snd_pcm_plugin_prepare failed: %s\n",

                                 snd_strerror (rval));

                    }

                } else {

        } else {

    }

    while ((towrite > 0) && (this->enabled));

    if (towrite != 0) {

static Uint8 *

NTO_GetAudioBuf (_THIS)

static void

NTO_CloseAudio (_THIS)

    if (audio_handle != NULL) {

        if ((rval =

             snd_pcm_plugin_flush (audio_handle,

                                   SND_PCM_CHANNEL_PLAYBACK)) < 0) {

            SDL_SetError

                ("NTO_CloseAudio(): snd_pcm_plugin_flush failed: %s\n",

                 snd_strerror (rval));

        if ((rval = snd_pcm_close (audio_handle)) < 0) {

            SDL_SetError ("NTO_CloseAudio(): snd_pcm_close failed: %s\n",

                          snd_strerror (rval));

static int

NTO_OpenAudio (_THIS, SDL_AudioSpec * spec)

    if (pcm_buf != NULL) {

        SDL_FreeAudioMem (pcm_buf);

    NTO_InitAudioParams (&cparams);

    rval =

        snd_pcm_open_preferred (&audio_handle, &cardno, &deviceno,

                                OPEN_FLAGS);

    if (rval < 0) {

        SDL_SetError ("NTO_OpenAudio(): snd_pcm_open failed: %s\n",

                      snd_strerror (rval));

    if (!NTO_CheckBuggyCards (this, QSA_MMAP_WORKAROUND)) {

        if ((rval =

             snd_pcm_plugin_set_disable (audio_handle,

                                         PLUGIN_DISABLE_MMAP)) < 0) {

            SDL_SetError ("snd_pcm_plugin_set_disable failed: %s\n",

                          snd_strerror (rval));

    for (test_format = SDL_FirstAudioFormat (spec->format); !found;) {

        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;

        default:

            break;

        if (!found) {

            test_format = SDL_NextAudioFormat ();

    if (test_format == 0) {

        SDL_SetError

            ("NTO_OpenAudio(): Couldn't find any hardware audio formats");

    rval = snd_pcm_plugin_params (audio_handle, &cparams);

    if (rval < 0) {

        SDL_SetError

            ("NTO_OpenAudio(): snd_pcm_channel_params failed: %s\n",

             snd_strerror (rval));

    SDL_memset (&csetup, 0x00, sizeof (csetup));

    if (snd_pcm_plugin_setup (audio_handle, &csetup) < 0) {

        SDL_SetError ("NTO_OpenAudio(): Unable to setup playback channel\n");

    SDL_CalculateAudioSpec (spec);

    if (pcm_len == 0) {

        pcm_len =

            csetup.buf.block.frag_size * spec->channels *

            (snd_pcm_format_width (format) / 8);

     */

    pcm_buf = (Uint8 *) SDL_AllocAudioMem (pcm_len);

    if (pcm_buf == NULL) {

        SDL_SetError ("NTO_OpenAudio(): pcm buffer allocation failed\n");

    SDL_memset (pcm_buf, spec->silence, pcm_len);

    if ((audio_fd =

         snd_pcm_file_descriptor (audio_handle,

                                  SND_PCM_CHANNEL_PLAYBACK)) < 0) {