Move backend sources to a separate sub-directory

1 files changed, 282 insertions, 0 deletions

diff --git a/Alc/backends/solaris.c b/Alc/backends/solaris.c
new file mode 100644
index 00000000..b2b8196d
--- /dev/null
+++ b/Alc/backends/solaris.c
@@ -0,0 +1,282 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 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 <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <memory.h>
+#include <unistd.h>
+#include <errno.h>
+#include <math.h>
+#include "alMain.h"
+#include "AL/al.h"
+#include "AL/alc.h"
+
+#include <sys/audioio.h>
+
+
+static const ALCchar solaris_device[] = "Solaris Default";
+
+typedef struct {
+    int fd;
+    volatile int killNow;
+    ALvoid *thread;
+
+    ALubyte *mix_data;
+    int data_size;
+} solaris_data;
+
+
+static ALuint SolarisProc(ALvoid *ptr)
+{
+    ALCdevice *pDevice = (ALCdevice*)ptr;
+    solaris_data *data = (solaris_data*)pDevice->ExtraData;
+    ALint frameSize;
+    int wrote;
+
+    SetRTPriority();
+
+    frameSize = FrameSizeFromDevFmt(pDevice->FmtChans, pDevice->FmtType);
+
+    while(!data->killNow && pDevice->Connected)
+    {
+        ALint len = data->data_size;
+        ALubyte *WritePtr = data->mix_data;
+
+        aluMixData(pDevice, WritePtr, len/frameSize);
+        while(len > 0 && !data->killNow)
+        {
+            wrote = write(data->fd, WritePtr, len);
+            if(wrote < 0)
+            {
+                if(errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR)
+                {
+                    ERR("write failed: %s\n", strerror(errno));
+                    aluHandleDisconnect(pDevice);
+                    break;
+                }
+
+                Sleep(1);
+                continue;
+            }
+
+            len -= wrote;
+            WritePtr += wrote;
+        }
+    }
+
+    return 0;
+}
+
+
+static ALCboolean solaris_open_playback(ALCdevice *device, const ALCchar *deviceName)
+{
+    char driver[64];
+    solaris_data *data;
+
+    strncpy(driver, GetConfigValue("solaris", "device", "/dev/audio"), sizeof(driver)-1);
+    driver[sizeof(driver)-1] = 0;
+
+    if(!deviceName)
+        deviceName = solaris_device;
+    else if(strcmp(deviceName, solaris_device) != 0)
+        return ALC_FALSE;
+
+    data = (solaris_data*)calloc(1, sizeof(solaris_data));
+    data->killNow = 0;
+
+    data->fd = open(driver, O_WRONLY);
+    if(data->fd == -1)
+    {
+        free(data);
+        ERR("Could not open %s: %s\n", driver, strerror(errno));
+        return ALC_FALSE;
+    }
+
+    device->szDeviceName = strdup(deviceName);
+    device->ExtraData = data;
+    return ALC_TRUE;
+}
+
+static void solaris_close_playback(ALCdevice *device)
+{
+    solaris_data *data = (solaris_data*)device->ExtraData;
+
+    close(data->fd);
+    free(data);
+    device->ExtraData = NULL;
+}
+
+static ALCboolean solaris_reset_playback(ALCdevice *device)
+{
+    solaris_data *data = (solaris_data*)device->ExtraData;
+    audio_info_t info;
+    ALuint frameSize;
+    int numChannels;
+
+    AUDIO_INITINFO(&info);
+
+    info.play.sample_rate = device->Frequency;
+
+    if(device->FmtChans != DevFmtMono)
+        device->FmtChans = DevFmtStereo;
+    numChannels = ChannelsFromDevFmt(device->FmtChans);
+    info.play.channels = numChannels;
+
+    switch(device->FmtType)
+    {
+        case DevFmtByte:
+            info.play.precision = 8;
+            info.play.encoding = AUDIO_ENCODING_LINEAR;
+            break;
+        case DevFmtUByte:
+            info.play.precision = 8;
+            info.play.encoding = AUDIO_ENCODING_LINEAR8;
+            break;
+        case DevFmtUShort:
+        case DevFmtFloat:
+            device->FmtType = DevFmtShort;
+            /* fall-through */
+        case DevFmtShort:
+            info.play.precision = 16;
+            info.play.encoding = AUDIO_ENCODING_LINEAR;
+            break;
+    }
+
+    frameSize = numChannels * BytesFromDevFmt(device->FmtType);
+    info.play.buffer_size = device->UpdateSize*device->NumUpdates * frameSize;
+
+    if(ioctl(data->fd, AUDIO_SETINFO, &info) < 0)
+    {
+        ERR("ioctl failed: %s\n", strerror(errno));
+        return ALC_FALSE;
+    }
+
+    if(ChannelsFromDevFmt(device->FmtChans) != info.play.channels)
+    {
+        ERR("Could not set %d channels, got %d instead\n", ChannelsFromDevFmt(device->FmtChans), info.play.channels);
+        return ALC_FALSE;
+    }
+
+    if(!((info.play.precision == 8 && info.play.encoding == AUDIO_ENCODING_LINEAR &&
+          device->FmtType == DevFmtByte) ||
+         (info.play.precision == 8 && info.play.encoding == AUDIO_ENCODING_LINEAR8 &&
+          device->FmtType == DevFmtUByte) ||
+         (info.play.precision == 16 && info.play.encoding == AUDIO_ENCODING_LINEAR &&
+          device->FmtType == DevFmtShort)))
+    {
+        ERR("Could not set %#x sample type, got %d (%#x)\n",
+            device->FmtType, info.play.precision, info.play.encoding);
+        return ALC_FALSE;
+    }
+
+    if(device->Frequency != info.play.sample_rate)
+    {
+        if((device->Flags&DEVICE_FREQUENCY_REQUEST))
+            ERR("Failed to set requested frequency %dhz, got %dhz instead\n", device->Frequency, info.play.sample_rate);
+        device->Flags &= ~DEVICE_FREQUENCY_REQUEST;
+        device->Frequency = info.play.sample_rate;
+    }
+    device->UpdateSize = (info.play.buffer_size/device->NumUpdates) + 1;
+
+    data->data_size = device->UpdateSize * frameSize;
+    data->mix_data = calloc(1, data->data_size);
+
+    SetDefaultChannelOrder(device);
+
+    data->thread = StartThread(SolarisProc, device);
+    if(data->thread == NULL)
+    {
+        free(data->mix_data);
+        data->mix_data = NULL;
+        return ALC_FALSE;
+    }
+
+    return ALC_TRUE;
+}
+
+static void solaris_stop_playback(ALCdevice *device)
+{
+    solaris_data *data = (solaris_data*)device->ExtraData;
+
+    if(!data->thread)
+        return;
+
+    data->killNow = 1;
+    StopThread(data->thread);
+    data->thread = NULL;
+
+    data->killNow = 0;
+    if(ioctl(data->fd, AUDIO_DRAIN) < 0)
+        ERR("Error draining device: %s\n", strerror(errno));
+
+    free(data->mix_data);
+    data->mix_data = NULL;
+}
+
+
+static const BackendFuncs solaris_funcs = {
+    solaris_open_playback,
+    solaris_close_playback,
+    solaris_reset_playback,
+    solaris_stop_playback,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+ALCboolean alc_solaris_init(BackendFuncs *func_list)
+{
+    *func_list = solaris_funcs;
+    return ALC_TRUE;
+}
+
+void alc_solaris_deinit(void)
+{
+}
+
+void alc_solaris_probe(enum DevProbe type)
+{
+#ifdef HAVE_STAT
+    struct stat buf;
+    if(stat(GetConfigValue("solaris", "device", "/dev/audio"), &buf) != 0)
+        return;
+#endif
+
+    switch(type)
+    {
+        case DEVICE_PROBE:
+            AppendDeviceList(solaris_device);
+            break;
+        case ALL_DEVICE_PROBE:
+            AppendAllDeviceList(solaris_device);
+            break;
+        case CAPTURE_DEVICE_PROBE:
+            break;
+    }
+}