Add a QSA backend for QNX

6 files changed, 1211 insertions, 2 deletions

diff --git a/Alc/ALc.c b/Alc/ALc.c
index 094c974c..e859a6c2 100644
--- a/Alc/ALc.c
+++ b/Alc/ALc.c
@@ -62,6 +62,9 @@ static struct BackendInfo BackendList[] = {
 #ifdef HAVE_SNDIO
     { "sndio", alc_sndio_init, alc_sndio_deinit, alc_sndio_probe, EmptyFuncs },
 #endif
+#ifdef HAVE_QSA
+    { "qsa", alc_qsa_init, alc_qsa_deinit, alc_qsa_probe, EmptyFuncs },
+#endif
 #ifdef HAVE_MMDEVAPI
     { "mmdevapi", alcMMDevApiInit, alcMMDevApiDeinit, alcMMDevApiProbe, EmptyFuncs },
 #endif
diff --git a/Alc/backends/qsa.c b/Alc/backends/qsa.c
new file mode 100644
index 00000000..c659ce2f
--- /dev/null
+++ b/Alc/backends/qsa.c
@@ -0,0 +1,1170 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2011-2013 by authors.
+ * 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 Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <sched.h>
+#include <errno.h>
+#include <memory.h>
+#include <sys/select.h>
+#include <sys/asoundlib.h>
+#include <sys/neutrino.h>
+
+#include "alMain.h"
+#include "alu.h"
+
+typedef struct
+{
+    snd_pcm_t* pcmHandle;
+    int audio_fd;
+
+    ALvoid* buffer;
+    ALsizei size;
+
+    volatile int killNow;
+    ALvoid* thread;
+
+    snd_pcm_channel_setup_t  csetup;
+    snd_pcm_channel_params_t cparams;
+} qsa_data;
+
+typedef struct
+{
+    ALCchar* name;
+    int card;
+    int dev;
+} DevMap;
+
+static const ALCchar qsaDevice[]="QSA Default";
+static DevMap* allDevNameMap;
+static ALuint numDevNames;
+static DevMap* allCaptureDevNameMap;
+static ALuint numCaptureDevNames;
+
+static const struct
+{
+    int32_t format;
+} formatlist[]=
+{
+    {SND_PCM_SFMT_FLOAT_LE},
+    {SND_PCM_SFMT_S32_LE},
+    {SND_PCM_SFMT_U32_LE},
+    {SND_PCM_SFMT_S16_LE},
+    {SND_PCM_SFMT_U16_LE},
+    {SND_PCM_SFMT_S8},
+    {SND_PCM_SFMT_U8},
+    {0},
+};
+
+static const struct
+{
+    int32_t rate;
+} ratelist[]=
+{
+    {192000},
+    {176400},
+    {96000},
+    {88200},
+    {48000},
+    {44100},
+    {32000},
+    {24000},
+    {22050},
+    {16000},
+    {12000},
+    {11025},
+    {8000},
+    {0},
+};
+
+static const struct
+{
+    int32_t channels;
+} channellist[]=
+{
+    {8},
+    {7},
+    {6},
+    {4},
+    {2},
+    {1},
+    {0},
+};
+
+static DevMap* deviceList(int type, ALuint* count)
+{
+    snd_ctl_t* handle;
+    snd_pcm_info_t pcminfo;
+    int max_cards, card, err, dev, num_devices, idx;
+    DevMap* dev_list;
+    char name[1024];
+    struct snd_ctl_hw_info info;
+    void* temp;
+
+    idx=0;
+    num_devices=0;
+    max_cards=snd_cards();
+
+    if (max_cards<=0)
+    {
+        return 0;
+    }
+
+    dev_list=malloc(sizeof(DevMap)*1);
+    dev_list[0].name=strdup(qsaDevice);
+    num_devices=1;
+
+    for (card=0; card<max_cards; card++)
+    {
+        if ((err=snd_ctl_open(&handle, card))<0)
+        {
+            continue;
+        }
+        if ((err=snd_ctl_hw_info(handle, &info))<0)
+        {
+            snd_ctl_close(handle);
+            continue;
+        }
+
+        for (dev=0; dev<(int)info.pcmdevs; dev++)
+        {
+            if ((err=snd_ctl_pcm_info(handle, dev, &pcminfo)) < 0)
+            {
+                continue;
+            }
+
+            if ((type==SND_PCM_CHANNEL_PLAYBACK && (pcminfo.flags&SND_PCM_INFO_PLAYBACK)) ||
+                (type==SND_PCM_CHANNEL_CAPTURE && (pcminfo.flags&SND_PCM_INFO_CAPTURE)))
+            {
+                temp=realloc(dev_list, sizeof(DevMap)*(num_devices+1));
+                if (temp)
+                {
+                    dev_list=temp;
+                    snprintf(name, sizeof(name), "%s [%s] (hw:%d,%d)", info.name, pcminfo.name, card, dev);
+                    dev_list[num_devices].name=strdup(name);
+                    dev_list[num_devices].card=card;
+                    dev_list[num_devices].dev=dev;
+                    num_devices++;
+                }
+            }
+        }
+        snd_ctl_close (handle);
+    }
+
+    *count=num_devices;
+
+    return dev_list;
+}
+
+static ALuint qsa_proc_playback(ALvoid* ptr)
+{
+    ALCdevice* device=(ALCdevice*)ptr;
+    qsa_data* data=(qsa_data*)device->ExtraData;
+    char* write_ptr;
+    int avail;
+    snd_pcm_channel_status_t status;
+    struct sched_param param;
+    fd_set wfds;
+    int selectret;
+    struct timeval timeout;
+
+    SetRTPriority();
+
+    /* Increase default 10 priority to 11 to avoid jerky sound */
+    SchedGet(0, 0, &param);
+    param.sched_priority=param.sched_curpriority+1;
+    SchedSet(0, 0, SCHED_NOCHANGE, &param);
+
+    ALint frame_size=FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
+
+    while (!data->killNow)
+    {
+        ALint len=data->size;
+        write_ptr=data->buffer;
+
+        avail=len/frame_size;
+        aluMixData(device, write_ptr, avail);
+
+        while (len>0 && !data->killNow)
+        {
+            FD_ZERO(&wfds);
+            FD_SET(data->audio_fd, &wfds);
+            timeout.tv_sec=2;
+            timeout.tv_usec=0;
+
+            /* Select also works like time slice to OS */
+            selectret=select(data->audio_fd+1, NULL, &wfds, NULL, &timeout);
+            switch (selectret)
+            {
+                case -1:
+                     aluHandleDisconnect(device);
+                     return 1;
+                case 0:
+                     break;
+                default:
+                     if (FD_ISSET(data->audio_fd, &wfds))
+                     {
+                         break;
+                     }
+                     break;
+            }
+
+            int wrote=snd_pcm_plugin_write(data->pcmHandle, write_ptr, len);
+
+            if (wrote<=0)
+            {
+                if ((errno==EAGAIN) || (errno==EWOULDBLOCK))
+                {
+                    continue;
+                }
+
+                memset(&status, 0, sizeof (status));
+                status.channel=SND_PCM_CHANNEL_PLAYBACK;
+
+                snd_pcm_plugin_status(data->pcmHandle, &status);
+
+                /* we need to reinitialize the sound channel if we've underrun the buffer */
+                if ((status.status==SND_PCM_STATUS_UNDERRUN) ||
+                    (status.status==SND_PCM_STATUS_READY))
+                {
+                    if ((snd_pcm_plugin_prepare(data->pcmHandle, SND_PCM_CHANNEL_PLAYBACK))<0)
+                    {
+                        aluHandleDisconnect(device);
+                        break;
+                    }
+                }
+            }
+            else
+            {
+                write_ptr+=wrote;
+                len-=wrote;
+            }
+        }
+    }
+
+    return 0;
+}
+
+/************/
+/* Playback */
+/************/
+
+static ALCenum qsa_open_playback(ALCdevice* device, const ALCchar* deviceName)
+{
+    qsa_data* data;
+    char driver[64];
+    int status;
+    int card, dev;
+
+    strncpy(driver, GetConfigValue("qsa", "device", qsaDevice), sizeof(driver)-1);
+    driver[sizeof(driver)-1]=0;
+
+    data=(qsa_data*)calloc(1, sizeof(qsa_data));
+    if (data==NULL)
+    {
+        return ALC_OUT_OF_MEMORY;
+    }
+
+    if (!deviceName)
+    {
+        deviceName=driver;
+    }
+
+    if (strcmp(deviceName, qsaDevice)==0)
+    {
+        if (!deviceName)
+        {
+            deviceName=qsaDevice;
+        }
+
+        status=snd_pcm_open_preferred(&data->pcmHandle, &card, &dev, SND_PCM_OPEN_PLAYBACK);
+    }
+    else
+    {
+        size_t idx;
+
+        if (!allDevNameMap)
+        {
+            allDevNameMap=deviceList(SND_PCM_CHANNEL_PLAYBACK, &numDevNames);
+        }
+
+        for (idx=0; idx<numDevNames; idx++)
+        {
+            if (allDevNameMap[idx].name && strcmp(deviceName, allDevNameMap[idx].name)==0)
+            {
+                if (idx>0)
+                {
+                    break;
+                }
+            }
+        }
+        if (idx==numDevNames)
+        {
+            free(data);
+            return ALC_INVALID_DEVICE;
+        }
+
+        status=snd_pcm_open(&data->pcmHandle, allDevNameMap[idx].card, allDevNameMap[idx].dev, SND_PCM_OPEN_PLAYBACK);
+    }
+
+    if (status<0)
+    {
+        free(data);
+        return ALC_INVALID_DEVICE;
+    }
+
+    data->audio_fd=snd_pcm_file_descriptor(data->pcmHandle, SND_PCM_CHANNEL_PLAYBACK);
+    if (data->audio_fd<0)
+    {
+        free(data);
+        return ALC_INVALID_DEVICE;
+    }
+
+    device->DeviceName=strdup(deviceName);
+    device->ExtraData=data;
+
+    return ALC_NO_ERROR;
+}
+
+static void qsa_close_playback(ALCdevice* device)
+{
+    qsa_data* data=(qsa_data*)device->ExtraData;
+
+    if (data->buffer!=NULL)
+    {
+        free(data->buffer);
+        data->buffer=NULL;
+    }
+
+    snd_pcm_close(data->pcmHandle);
+    free(data);
+
+    device->ExtraData=NULL;
+}
+
+static ALCboolean qsa_reset_playback(ALCdevice* device)
+{
+    qsa_data* data=(qsa_data*)device->ExtraData;
+    int32_t format=-1;
+
+    switch(device->FmtType)
+    {
+        case DevFmtByte:
+             format=SND_PCM_SFMT_S8;
+             break;
+        case DevFmtUByte:
+             format=SND_PCM_SFMT_U8;
+             break;
+        case DevFmtShort:
+             format=SND_PCM_SFMT_S16_LE;
+             break;
+        case DevFmtUShort:
+             format=SND_PCM_SFMT_U16_LE;
+             break;
+        case DevFmtInt:
+             format=SND_PCM_SFMT_S32_LE;
+             break;
+        case DevFmtUInt:
+             format=SND_PCM_SFMT_U32_LE;
+             break;
+        case DevFmtFloat:
+             format=SND_PCM_SFMT_FLOAT_LE;
+             break;
+    }
+
+    /* we actually don't want to block on writes */
+    snd_pcm_nonblock_mode(data->pcmHandle, 1);
+    /* Disable mmap to control data transfer to the audio device */
+    snd_pcm_plugin_set_disable(data->pcmHandle, PLUGIN_DISABLE_MMAP);
+    snd_pcm_plugin_set_disable(data->pcmHandle, PLUGIN_DISABLE_BUFFER_PARTIAL_BLOCKS);
+
+    // configure a sound channel
+    memset(&data->cparams, 0, sizeof(data->cparams));
+    data->cparams.channel=SND_PCM_CHANNEL_PLAYBACK;
+    data->cparams.mode=SND_PCM_MODE_BLOCK;
+    data->cparams.start_mode=SND_PCM_START_FULL;
+    data->cparams.stop_mode=SND_PCM_STOP_STOP;
+
+    data->cparams.buf.block.frag_size=device->UpdateSize*
+        ChannelsFromDevFmt(device->FmtChans)*BytesFromDevFmt(device->FmtType);
+    data->cparams.buf.block.frags_max=device->NumUpdates;
+    data->cparams.buf.block.frags_min=device->NumUpdates;
+
+    data->cparams.format.interleave=1;
+    data->cparams.format.rate=device->Frequency;
+    data->cparams.format.voices=ChannelsFromDevFmt(device->FmtChans);
+    data->cparams.format.format=format;
+
+    if ((snd_pcm_plugin_params(data->pcmHandle, &data->cparams))<0)
+    {
+        int original_rate=data->cparams.format.rate;
+        int original_voices=data->cparams.format.voices;
+        int original_format=data->cparams.format.format;
+        int it;
+        int jt;
+
+        for (it=0; it<1; it++)
+        {
+            /* Check for second pass */
+            if (it==1)
+            {
+                original_rate=ratelist[0].rate;
+                original_voices=channellist[0].channels;
+                original_format=formatlist[0].format;
+            }
+
+            do {
+                /* At first downgrade sample format */
+                jt=0;
+                do {
+                    if (formatlist[jt].format==data->cparams.format.format)
+                    {
+                        data->cparams.format.format=formatlist[jt+1].format;
+                        break;
+                    }
+                    if (formatlist[jt].format==0)
+                    {
+                        data->cparams.format.format=0;
+                        break;
+                    }
+                    jt++;
+                } while(1);
+
+                if (data->cparams.format.format==0)
+                {
+                    data->cparams.format.format=original_format;
+
+                    /* At secod downgrade sample rate */
+                    jt=0;
+                    do {
+                        if (ratelist[jt].rate==data->cparams.format.rate)
+                        {
+                            data->cparams.format.rate=ratelist[jt+1].rate;
+                            break;
+                        }
+                        if (ratelist[jt].rate==0)
+                        {
+                            data->cparams.format.rate=0;
+                            break;
+                        }
+                        jt++;
+                    } while(1);
+
+                    if (data->cparams.format.rate==0)
+                    {
+                        data->cparams.format.rate=original_rate;
+                        data->cparams.format.format=original_format;
+
+                        /* At third downgrade channels number */
+                        jt=0;
+                        do {
+                            if(channellist[jt].channels==data->cparams.format.voices)
+                            {
+                                data->cparams.format.voices=channellist[jt+1].channels;
+                                break;
+                            }
+                            if (channellist[jt].channels==0)
+                            {
+                                data->cparams.format.voices=0;
+                                break;
+                            }
+                           jt++;
+                        } while(1);
+                    }
+
+                    if (data->cparams.format.voices==0)
+                    {
+                        break;
+                    }
+                }
+
+                data->cparams.buf.block.frag_size=device->UpdateSize*
+                    data->cparams.format.voices*
+                    snd_pcm_format_width(data->cparams.format.format)/8;
+                data->cparams.buf.block.frags_max=device->NumUpdates;
+                data->cparams.buf.block.frags_min=device->NumUpdates;
+                if ((snd_pcm_plugin_params(data->pcmHandle, &data->cparams))<0)
+                {
+                    continue;
+                }
+                else
+                {
+                    break;
+                }
+            } while(1);
+
+            if (data->cparams.format.voices!=0)
+            {
+                break;
+            }
+        }
+
+        if (data->cparams.format.voices==0)
+        {
+            return ALC_FALSE;
+        }
+    }
+
+    if ((snd_pcm_plugin_prepare(data->pcmHandle, SND_PCM_CHANNEL_PLAYBACK))<0)
+    {
+        return ALC_FALSE;
+    }
+
+    memset(&data->csetup, 0, sizeof(data->csetup));
+    data->csetup.channel=SND_PCM_CHANNEL_PLAYBACK;
+    if (snd_pcm_plugin_setup(data->pcmHandle, &data->csetup)<0)
+    {
+        return ALC_FALSE;
+    }
+
+    /* now fill back to the our AL device */
+    device->Frequency=data->cparams.format.rate;
+
+    switch (data->cparams.format.voices)
+    {
+        case 1:
+             device->FmtChans=DevFmtMono;
+             break;
+        case 2:
+             device->FmtChans=DevFmtStereo;
+             break;
+        case 4:
+             device->FmtChans=DevFmtQuad;
+             break;
+        case 6:
+             device->FmtChans=DevFmtX51;
+             break;
+        case 7:
+             device->FmtChans=DevFmtX61;
+             break;
+        case 8:
+             device->FmtChans=DevFmtX71;
+             break;
+        default:
+             device->FmtChans=DevFmtMono;
+             break;
+    }
+
+    switch (data->cparams.format.format)
+    {
+        case SND_PCM_SFMT_S8:
+             device->FmtType=DevFmtByte;
+             break;
+        case SND_PCM_SFMT_U8:
+             device->FmtType=DevFmtUByte;
+             break;
+        case SND_PCM_SFMT_S16_LE:
+             device->FmtType=DevFmtShort;
+             break;
+        case SND_PCM_SFMT_U16_LE:
+             device->FmtType=DevFmtUShort;
+             break;
+        case SND_PCM_SFMT_S32_LE:
+             device->FmtType=DevFmtInt;
+             break;
+        case SND_PCM_SFMT_U32_LE:
+             device->FmtType=DevFmtUInt;
+             break;
+        case SND_PCM_SFMT_FLOAT_LE:
+             device->FmtType=DevFmtFloat;
+             break;
+        default:
+             device->FmtType=DevFmtShort;
+             break;
+    }
+
+    SetDefaultChannelOrder(device);
+
+    device->UpdateSize=data->csetup.buf.block.frag_size/
+        (ChannelsFromDevFmt(device->FmtChans)*BytesFromDevFmt(device->FmtType));
+    device->NumUpdates=data->csetup.buf.block.frags;
+
+    data->size=data->csetup.buf.block.frag_size;
+    data->buffer=malloc(data->size);
+    if (!data->buffer)
+    {
+        return ALC_FALSE;
+    }
+
+    return ALC_TRUE;
+}
+
+static ALCboolean qsa_start_playback(ALCdevice* device)
+{
+    qsa_data* data=(qsa_data*)device->ExtraData;
+
+    data->thread=StartThread(qsa_proc_playback, device);
+    if (data->thread==NULL)
+    {
+        return ALC_FALSE;
+    }
+
+    return ALC_TRUE;
+}
+
+static void qsa_stop_playback(ALCdevice* device)
+{
+    qsa_data* data=(qsa_data*)device->ExtraData;
+
+    if (data->thread)
+    {
+        data->killNow=1;
+        StopThread(data->thread);
+        data->thread=NULL;
+    }
+    data->killNow=0;
+}
+
+/***********/
+/* Capture */
+/***********/
+
+static ALCenum qsa_open_capture(ALCdevice* device, const ALCchar* deviceName)
+{
+    qsa_data* data;
+    int format=-1;
+    char driver[64];
+    int card, dev;
+    int status;
+
+    strncpy(driver, GetConfigValue("qsa", "capture", qsaDevice), sizeof(driver)-1);
+    driver[sizeof(driver)-1]=0;
+
+    data=(qsa_data*)calloc(1, sizeof(qsa_data));
+    if (data==NULL)
+    {
+        return ALC_OUT_OF_MEMORY;
+    }
+
+    if (!deviceName)
+    {
+        deviceName=driver;
+    }
+
+    if (strcmp(deviceName, qsaDevice)==0)
+    {
+        if (!deviceName)
+        {
+            deviceName=qsaDevice;
+        }
+
+        status=snd_pcm_open_preferred(&data->pcmHandle, &card, &dev, SND_PCM_OPEN_CAPTURE);
+    }
+    else
+    {
+        size_t idx;
+
+        if (!allCaptureDevNameMap)
+        {
+            allCaptureDevNameMap=deviceList(SND_PCM_CHANNEL_CAPTURE, &numDevNames);
+        }
+
+        for (idx=0; idx<numDevNames; idx++)
+        {
+            if (allCaptureDevNameMap[idx].name && strcmp(deviceName, allCaptureDevNameMap[idx].name)==0)
+            {
+                if (idx>0)
+                {
+                    break;
+                }
+            }
+        }
+        if (idx==numDevNames)
+        {
+            free(data);
+            return ALC_INVALID_DEVICE;
+        }
+
+        status=snd_pcm_open(&data->pcmHandle, allCaptureDevNameMap[idx].card, allCaptureDevNameMap[idx].dev, SND_PCM_OPEN_CAPTURE);
+    }
+
+    if (status<0)
+    {
+        free(data);
+        return ALC_INVALID_DEVICE;
+    }
+
+    data->audio_fd=snd_pcm_file_descriptor(data->pcmHandle, SND_PCM_CHANNEL_CAPTURE);
+    if (data->audio_fd<0)
+    {
+        free(data);
+        return ALC_INVALID_DEVICE;
+    }
+
+    device->DeviceName=strdup(deviceName);
+    device->ExtraData=data;
+
+    switch (device->FmtType)
+    {
+        case DevFmtByte:
+             format=SND_PCM_SFMT_S8;
+             break;
+        case DevFmtUByte:
+             format=SND_PCM_SFMT_U8;
+             break;
+        case DevFmtShort:
+             format=SND_PCM_SFMT_S16_LE;
+             break;
+        case DevFmtUShort:
+             format=SND_PCM_SFMT_U16_LE;
+             break;
+        case DevFmtInt:
+             format=SND_PCM_SFMT_S32_LE;
+             break;
+        case DevFmtUInt:
+             format=SND_PCM_SFMT_U32_LE;
+             break;
+        case DevFmtFloat:
+             format=SND_PCM_SFMT_FLOAT_LE;
+             break;
+    }
+
+    /* we actually don't want to block on reads */
+    snd_pcm_nonblock_mode(data->pcmHandle, 1);
+    /* Disable mmap to control data transfer to the audio device */
+    snd_pcm_plugin_set_disable(data->pcmHandle, PLUGIN_DISABLE_MMAP);
+
+    /* configure a sound channel */
+    memset(&data->cparams, 0, sizeof(data->cparams));
+    data->cparams.mode=SND_PCM_MODE_BLOCK;
+    data->cparams.channel=SND_PCM_CHANNEL_CAPTURE;
+    data->cparams.start_mode=SND_PCM_START_GO;
+    data->cparams.stop_mode=SND_PCM_STOP_STOP;
+
+    data->cparams.buf.block.frag_size=device->UpdateSize*
+        ChannelsFromDevFmt(device->FmtChans)*BytesFromDevFmt(device->FmtType);
+    data->cparams.buf.block.frags_max=device->NumUpdates;
+    data->cparams.buf.block.frags_min=device->NumUpdates;
+
+    data->cparams.format.interleave=1;
+    data->cparams.format.rate=device->Frequency;
+    data->cparams.format.voices=ChannelsFromDevFmt(device->FmtChans);
+    data->cparams.format.format=format;
+
+    if ((snd_pcm_plugin_params(data->pcmHandle, &data->cparams))<0)
+    {
+        int original_rate=data->cparams.format.rate;
+        int original_voices=data->cparams.format.voices;
+        int original_format=data->cparams.format.format;
+        int it;
+        int jt;
+
+        for (it=0; it<1; it++)
+        {
+            /* Check for second pass */
+            if (it==1)
+            {
+                original_rate=ratelist[0].rate;
+                original_voices=channellist[0].channels;
+                original_format=formatlist[0].format;
+            }
+
+            do {
+                /* At first downgrade sample format */
+                jt=0;
+                do {
+                    if (formatlist[jt].format==data->cparams.format.format)
+                    {
+                        data->cparams.format.format=formatlist[jt+1].format;
+                        break;
+                    }
+                    if (formatlist[jt].format==0)
+                    {
+                        data->cparams.format.format=0;
+                        break;
+                    }
+                    jt++;
+                } while(1);
+
+                if (data->cparams.format.format==0)
+                {
+                    data->cparams.format.format=original_format;
+
+                    /* At secod downgrade sample rate */
+                    jt=0;
+                    do {
+                        if (ratelist[jt].rate==data->cparams.format.rate)
+                        {
+                            data->cparams.format.rate=ratelist[jt+1].rate;
+                            break;
+                        }
+                        if (ratelist[jt].rate==0)
+                        {
+                            data->cparams.format.rate=0;
+                            break;
+                        }
+                        jt++;
+                    } while(1);
+
+                    if (data->cparams.format.rate==0)
+                    {
+                        data->cparams.format.rate=original_rate;
+                        data->cparams.format.format=original_format;
+
+                        /* At third downgrade channels number */
+                        jt=0;
+                        do {
+                            if(channellist[jt].channels==data->cparams.format.voices)
+                            {
+                                data->cparams.format.voices=channellist[jt+1].channels;
+                                break;
+                            }
+                            if (channellist[jt].channels==0)
+                            {
+                                data->cparams.format.voices=0;
+                                break;
+                            }
+                           jt++;
+                        } while(1);
+                    }
+
+                    if (data->cparams.format.voices==0)
+                    {
+                        break;
+                    }
+                }
+
+                data->cparams.buf.block.frag_size=device->UpdateSize*
+                    data->cparams.format.voices*
+                    snd_pcm_format_width(data->cparams.format.format)/8;
+                data->cparams.buf.block.frags_max=device->NumUpdates;
+                data->cparams.buf.block.frags_min=device->NumUpdates;
+                if ((snd_pcm_plugin_params(data->pcmHandle, &data->cparams))<0)
+                {
+                    continue;
+                }
+                else
+                {
+                    break;
+                }
+            } while(1);
+
+            if (data->cparams.format.voices!=0)
+            {
+                break;
+            }
+        }
+
+        if (data->cparams.format.voices==0)
+        {
+            return ALC_INVALID_VALUE;
+        }
+    }
+
+    /* now fill back to the our AL device */
+    device->Frequency=data->cparams.format.rate;
+
+    switch (data->cparams.format.voices)
+    {
+        case 1:
+             device->FmtChans=DevFmtMono;
+             break;
+        case 2:
+             device->FmtChans=DevFmtStereo;
+             break;
+        case 4:
+             device->FmtChans=DevFmtQuad;
+             break;
+        case 6:
+             device->FmtChans=DevFmtX51;
+             break;
+        case 7:
+             device->FmtChans=DevFmtX61;
+             break;
+        case 8:
+             device->FmtChans=DevFmtX71;
+             break;
+        default:
+             device->FmtChans=DevFmtMono;
+             break;
+    }
+
+    switch (data->cparams.format.format)
+    {
+        case SND_PCM_SFMT_S8:
+             device->FmtType=DevFmtByte;
+             break;
+        case SND_PCM_SFMT_U8:
+             device->FmtType=DevFmtUByte;
+             break;
+        case SND_PCM_SFMT_S16_LE:
+             device->FmtType=DevFmtShort;
+             break;
+        case SND_PCM_SFMT_U16_LE:
+             device->FmtType=DevFmtUShort;
+             break;
+        case SND_PCM_SFMT_S32_LE:
+             device->FmtType=DevFmtInt;
+             break;
+        case SND_PCM_SFMT_U32_LE:
+             device->FmtType=DevFmtUInt;
+             break;
+        case SND_PCM_SFMT_FLOAT_LE:
+             device->FmtType=DevFmtFloat;
+             break;
+        default:
+             device->FmtType=DevFmtShort;
+             break;
+    }
+
+    return ALC_NO_ERROR;
+}
+
+static void qsa_close_capture(ALCdevice* device)
+{
+    qsa_data* data=(qsa_data*)device->ExtraData;
+
+    if (data->pcmHandle!=NULL)
+    {
+        snd_pcm_close(data->pcmHandle);
+    }
+    free(data);
+    device->ExtraData=NULL;
+}
+
+static void qsa_start_capture(ALCdevice* device)
+{
+    qsa_data* data=(qsa_data*)device->ExtraData;
+    int rstatus;
+
+    if ((rstatus=snd_pcm_plugin_prepare(data->pcmHandle, SND_PCM_CHANNEL_CAPTURE))<0)
+    {
+        ERR("capture prepare failed: %s\n", snd_strerror(rstatus));
+        return;
+    }
+
+    memset(&data->csetup, 0, sizeof(data->csetup));
+    data->csetup.channel=SND_PCM_CHANNEL_CAPTURE;
+    if ((rstatus=snd_pcm_plugin_setup(data->pcmHandle, &data->csetup))<0)
+    {
+        ERR("capture setup failed: %s\n", snd_strerror(rstatus));
+        return;
+    }
+
+    snd_pcm_capture_go(data->pcmHandle);
+
+    device->UpdateSize=data->csetup.buf.block.frag_size/
+        (ChannelsFromDevFmt(device->FmtChans)*BytesFromDevFmt(device->FmtType));
+    device->NumUpdates=data->csetup.buf.block.frags;
+}
+
+static void qsa_stop_capture(ALCdevice* device)
+{
+    qsa_data* data=(qsa_data*)device->ExtraData;
+
+    snd_pcm_capture_flush(data->pcmHandle);
+}
+
+static ALCuint qsa_available_samples(ALCdevice* device)
+{
+    qsa_data* data=(qsa_data*)device->ExtraData;
+    snd_pcm_channel_status_t status;
+    ALint frame_size=FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
+    ALint free_size;
+    int rstatus;
+
+    memset(&status, 0, sizeof (status));
+    status.channel=SND_PCM_CHANNEL_CAPTURE;
+    snd_pcm_plugin_status(data->pcmHandle, &status);
+    if ((status.status==SND_PCM_STATUS_OVERRUN) ||
+        (status.status==SND_PCM_STATUS_READY))
+    {
+        if ((rstatus=snd_pcm_plugin_prepare(data->pcmHandle, SND_PCM_CHANNEL_CAPTURE))<0)
+        {
+            ERR("capture prepare failed: %s\n", snd_strerror(rstatus));
+            aluHandleDisconnect(device);
+            return 0;
+        }
+
+        snd_pcm_capture_go(data->pcmHandle);
+        return 0;
+    }
+
+    free_size=data->csetup.buf.block.frag_size*data->csetup.buf.block.frags;
+    free_size-=status.free;
+
+    return free_size/frame_size;
+}
+
+static ALCenum qsa_capture_samples(ALCdevice *device, ALCvoid *buffer, ALCuint samples)
+{
+    qsa_data* data=(qsa_data*)device->ExtraData;
+    char* read_ptr;
+    snd_pcm_channel_status_t status;
+    fd_set rfds;
+    int selectret;
+    struct timeval timeout;
+    int bytes_read;
+    ALint frame_size=FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
+    ALint len=samples*frame_size;
+    int rstatus;
+
+    read_ptr=buffer;
+
+    while (len>0)
+    {
+        FD_ZERO(&rfds);
+        FD_SET(data->audio_fd, &rfds);
+        timeout.tv_sec=2;
+        timeout.tv_usec=0;
+
+        /* Select also works like time slice to OS */
+        bytes_read=0;
+        selectret=select(data->audio_fd+1, &rfds, NULL, NULL, &timeout);
+        switch (selectret)
+        {
+            case -1:
+                 aluHandleDisconnect(device);
+                 return ALC_INVALID_DEVICE;
+            case 0:
+                 break;
+            default:
+                 if (FD_ISSET(data->audio_fd, &rfds))
+                 {
+                     bytes_read=snd_pcm_plugin_read(data->pcmHandle, read_ptr, len);
+                     break;
+                 }
+                 break;
+        }
+
+        if (bytes_read<=0)
+        {
+            if ((errno==EAGAIN) || (errno==EWOULDBLOCK))
+            {
+                continue;
+            }
+
+            memset(&status, 0, sizeof (status));
+            status.channel=SND_PCM_CHANNEL_CAPTURE;
+            snd_pcm_plugin_status(data->pcmHandle, &status);
+
+            /* we need to reinitialize the sound channel if we've overrun the buffer */
+            if ((status.status==SND_PCM_STATUS_OVERRUN) ||
+                (status.status==SND_PCM_STATUS_READY))
+            {
+                if ((rstatus=snd_pcm_plugin_prepare(data->pcmHandle, SND_PCM_CHANNEL_CAPTURE))<0)
+                {
+                    ERR("capture prepare failed: %s\n", snd_strerror(rstatus));
+                    aluHandleDisconnect(device);
+                    return ALC_INVALID_DEVICE;
+                }
+                snd_pcm_capture_go(data->pcmHandle);
+            }
+        }
+        else
+        {
+            read_ptr+=bytes_read;
+            len-=bytes_read;
+        }
+    }
+
+    return ALC_NO_ERROR;
+}
+
+static ALint64 qsa_get_latency(ALCdevice* device)
+{
+    ALint frame_size=FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
+
+    return (ALint64)(device->UpdateSize*device->NumUpdates/frame_size)*
+        1000000000/device->Frequency;
+}
+
+BackendFuncs qsa_funcs=
+{
+    qsa_open_playback,
+    qsa_close_playback,
+    qsa_reset_playback,
+    qsa_start_playback,
+    qsa_stop_playback,
+    qsa_open_capture,
+    qsa_close_capture,
+    qsa_start_capture,
+    qsa_stop_capture,
+    qsa_capture_samples,
+    qsa_available_samples,
+    ALCdevice_LockDefault,
+    ALCdevice_UnlockDefault,
+    qsa_get_latency,
+};
+
+ALCboolean alc_qsa_init(BackendFuncs* func_list)
+{
+    *func_list=qsa_funcs;
+
+    return ALC_TRUE;
+}
+
+void alc_qsa_deinit(void)
+{
+    ALuint i;
+
+    for (i=0; i<numDevNames; ++i)
+    {
+        free(allDevNameMap[i].name);
+    }
+    free(allDevNameMap);
+    allDevNameMap=NULL;
+    numDevNames=0;
+
+    for (i=0; i<numCaptureDevNames; ++i)
+    {
+        free(allCaptureDevNameMap[i].name);
+    }
+    free(allCaptureDevNameMap);
+    allCaptureDevNameMap=NULL;
+    numCaptureDevNames=0;
+}
+
+void alc_qsa_probe(enum DevProbe type)
+{
+    ALuint i;
+
+    switch (type)
+    {
+        case ALL_DEVICE_PROBE:
+             for (i=0; i<numDevNames; ++i)
+             {
+                 free(allDevNameMap[i].name);
+             }
+             free(allDevNameMap);
+
+             allDevNameMap=deviceList(SND_PCM_CHANNEL_PLAYBACK, &numDevNames);
+             for (i=0; i<numDevNames; ++i)
+             {
+                 AppendAllDevicesList(allDevNameMap[i].name);
+             }
+             break;
+        case CAPTURE_DEVICE_PROBE:
+             for (i=0; i<numCaptureDevNames; ++i)
+             {
+                 free(allCaptureDevNameMap[i].name);
+             }
+             free(allCaptureDevNameMap);
+
+             allCaptureDevNameMap=deviceList(SND_PCM_CHANNEL_CAPTURE, &numCaptureDevNames);
+             for (i=0; i<numCaptureDevNames; ++i)
+             {
+                 AppendCaptureDeviceList(allCaptureDevNameMap[i].name);
+             }
+             break;
+    }
+}
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4d7c5c97..ed7eb96b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -37,6 +37,7 @@ OPTION(ALSOFT_BACKEND_ALSA    "Check for ALSA backend"                ON)
 OPTION(ALSOFT_BACKEND_OSS     "Check for OSS backend"                 ON)
 OPTION(ALSOFT_BACKEND_SOLARIS "Check for Solaris backend"             ON)
 OPTION(ALSOFT_BACKEND_SNDIO   "Check for SndIO backend"               ON)
+OPTION(ALSOFT_BACKEND_QSA     "Check for QSA backend"                 ON)
 OPTION(ALSOFT_BACKEND_MMDEVAPI "Check for MMDevApi"                   ON)
 OPTION(ALSOFT_BACKEND_DSOUND  "Check for DirectSound backend"         ON)
 OPTION(ALSOFT_BACKEND_WINMM   "Check for Windows Multimedia backend"  ON)
@@ -50,6 +51,7 @@ OPTION(ALSOFT_REQUIRE_ALSA       "Require ALSA backend"               OFF)
 OPTION(ALSOFT_REQUIRE_OSS        "Require OSS backend"                OFF)
 OPTION(ALSOFT_REQUIRE_SOLARIS    "Require Solaris backend"            OFF)
 OPTION(ALSOFT_REQUIRE_SNDIO      "Require SndIO backend"              OFF)
+OPTION(ALSOFT_REQUIRE_QSA        "Require QSA backend"                OFF)
 OPTION(ALSOFT_REQUIRE_MMDEVAPI   "Require MMDevApi"                   OFF)
 OPTION(ALSOFT_REQUIRE_DSOUND     "Require DirectSound backend"        OFF)
 OPTION(ALSOFT_REQUIRE_WINMM      "Require Windows Multimedia backend" OFF)
@@ -76,6 +78,12 @@ ELSE()
     SET(LIBNAME openal)
 ENDIF()
 
+# QNX's gcc do not uses /usr/include and /usr/lib pathes by default
+IF ("${CMAKE_C_PLATFORM_ID}" STREQUAL "QNX")
+    ADD_DEFINITIONS("-I/usr/include")
+    SET(EXTRA_LIBS ${EXTRA_LIBS} -L/usr/lib)
+ENDIF()
+
 IF(NOT LIBTYPE)
     SET(LIBTYPE SHARED)
 ENDIF()
@@ -509,6 +517,7 @@ SET(HAVE_ALSA       0)
 SET(HAVE_OSS        0)
 SET(HAVE_SOLARIS    0)
 SET(HAVE_SNDIO      0)
+SET(HAVE_QSA        0)
 SET(HAVE_DSOUND     0)
 SET(HAVE_MMDEVAPI   0)
 SET(HAVE_WINMM      0)
@@ -582,6 +591,27 @@ IF(ALSOFT_REQUIRE_SNDIO AND NOT HAVE_SNDIO)
     MESSAGE(FATAL_ERROR "Failed to enabled required SndIO backend")
 ENDIF()
 
+# Check QSA backend
+IF (ALSOFT_BACKEND_QSA AND "${CMAKE_C_PLATFORM_ID}" STREQUAL "QNX")
+    CHECK_INCLUDE_FILE(sys/asoundlib.h HAVE_SYS_ASOUNDLIB_H)
+    IF(HAVE_SYS_ASOUNDLIB_H)
+        CHECK_SHARED_FUNCTION_EXISTS(snd_pcm_open "sys/asoundlib.h" asound "" HAVE_LIBASOUND)
+        IF(HAVE_LIBASOUND OR HAVE_DLFCN_H)
+            SET(HAVE_QSA 1)
+            SET(ALC_OBJS  ${ALC_OBJS} Alc/backends/qsa.c)
+            SET(EXTRA_LIBS asound ${EXTRA_LIBS})
+            IF(HAVE_DLFCN_H)
+                SET(BACKENDS  "${BACKENDS} QSA,")
+            ELSE()
+                SET(BACKENDS  "${BACKENDS} QSA \(linked\),")
+            ENDIF()
+        ENDIF()
+    ENDIF()
+ENDIF()
+IF(ALSOFT_REQUIRE_QSA AND NOT HAVE_QSA)
+    MESSAGE(FATAL_ERROR "Failed to enabled required QSA backend")
+ENDIF()
+
 # Check for MMDevApi backend
 IF(HAVE_WINDOWS_H)
     IF(ALSOFT_BACKEND_MMDEVAPI)
diff --git a/OpenAL32/Include/alMain.h b/OpenAL32/Include/alMain.h
index 1110e89e..198ab436 100644
--- a/OpenAL32/Include/alMain.h
+++ b/OpenAL32/Include/alMain.h
@@ -118,7 +118,7 @@ void *GetSymbol(void *handle, const char *name);
 
 typedef void *volatile XchgPtr;
 
-#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1))
+#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)) && !defined(__QNXNTO__)
 typedef ALuint RefCount;
 static __inline RefCount IncrementRef(volatile RefCount *ptr)
 { return __sync_add_and_fetch(ptr, 1); }
@@ -449,6 +449,9 @@ void alc_ca_probe(enum DevProbe type);
 ALCboolean alc_opensl_init(BackendFuncs *func_list);
 void alc_opensl_deinit(void);
 void alc_opensl_probe(enum DevProbe type);
+ALCboolean alc_qsa_init(BackendFuncs *func_list);
+void alc_qsa_deinit(void);
+void alc_qsa_probe(enum DevProbe type);
 ALCboolean alc_null_init(BackendFuncs *func_list);
 void alc_null_deinit(void);
 void alc_null_probe(enum DevProbe type);
diff --git a/alsoftrc.sample b/alsoftrc.sample
index 27aee718..837e01cf 100644
--- a/alsoftrc.sample
+++ b/alsoftrc.sample
@@ -121,7 +121,7 @@
 #  followed by all other available backends, while 'oss' will list OSS only).
 #  Backends prepended with - won't be available for use (eg. '-oss,' will allow
 #  all available backends except OSS). An empty list means the default.
-#drivers = pulse,alsa,core,oss,solaris,sndio,mmdevapi,dsound,winmm,port,opensl,null,wave
+#drivers = pulse,alsa,core,oss,solaris,sndio,qsa,mmdevapi,dsound,winmm,port,opensl,null,wave
 
 ## excludefx:
 #  Sets which effects to exclude, preventing apps from using them. This can
diff --git a/config.h.in b/config.h.in
index 06c34c81..6f45fa84 100644
--- a/config.h.in
+++ b/config.h.in
@@ -41,6 +41,9 @@
 /* Define if we have the SndIO backend */
 #cmakedefine HAVE_SNDIO
 
+/* Define if we have the QSA backend */
+#cmakedefine HAVE_QSA
+
 /* Define if we have the MMDevApi backend */
 #cmakedefine HAVE_MMDEVAPI