1.1 --- a/Alc/backends/alsa.c	Tue Oct 25 13:03:35 2011 -0700
     1.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.3 @@ -1,1138 +0,0 @@
     1.4 -/**
     1.5 - * OpenAL cross platform audio library
     1.6 - * Copyright (C) 1999-2007 by authors.
     1.7 - * This library is free software; you can redistribute it and/or
     1.8 - *  modify it under the terms of the GNU Library General Public
     1.9 - *  License as published by the Free Software Foundation; either
    1.10 - *  version 2 of the License, or (at your option) any later version.
    1.11 - *
    1.12 - * This library is distributed in the hope that it will be useful,
    1.13 - *  but WITHOUT ANY WARRANTY; without even the implied warranty of
    1.14 - *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    1.15 - *  Library General Public License for more details.
    1.16 - *
    1.17 - * You should have received a copy of the GNU Library General Public
    1.18 - *  License along with this library; if not, write to the
    1.19 - *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    1.20 - *  Boston, MA  02111-1307, USA.
    1.21 - * Or go to http://www.gnu.org/copyleft/lgpl.html
    1.22 - */
    1.23 -
    1.24 -#include "config.h"
    1.25 -
    1.26 -#include <stdlib.h>
    1.27 -#include <stdio.h>
    1.28 -#include <memory.h>
    1.29 -
    1.30 -#include "alMain.h"
    1.31 -
    1.32 -#include <alsa/asoundlib.h>
    1.33 -
    1.34 -
    1.35 -static const ALCchar alsaDevice[] = "ALSA Default";
    1.36 -
    1.37 -
    1.38 -static void *alsa_handle;
    1.39 -#ifdef HAVE_DYNLOAD
    1.40 -#define MAKE_FUNC(f) static typeof(f) * p##f
    1.41 -MAKE_FUNC(snd_strerror);
    1.42 -MAKE_FUNC(snd_pcm_open);
    1.43 -MAKE_FUNC(snd_pcm_close);
    1.44 -MAKE_FUNC(snd_pcm_nonblock);
    1.45 -MAKE_FUNC(snd_pcm_frames_to_bytes);
    1.46 -MAKE_FUNC(snd_pcm_bytes_to_frames);
    1.47 -MAKE_FUNC(snd_pcm_hw_params_malloc);
    1.48 -MAKE_FUNC(snd_pcm_hw_params_free);
    1.49 -MAKE_FUNC(snd_pcm_hw_params_any);
    1.50 -MAKE_FUNC(snd_pcm_hw_params_set_access);
    1.51 -MAKE_FUNC(snd_pcm_hw_params_set_format);
    1.52 -MAKE_FUNC(snd_pcm_hw_params_set_channels);
    1.53 -MAKE_FUNC(snd_pcm_hw_params_set_periods_near);
    1.54 -MAKE_FUNC(snd_pcm_hw_params_set_rate_near);
    1.55 -MAKE_FUNC(snd_pcm_hw_params_set_rate);
    1.56 -MAKE_FUNC(snd_pcm_hw_params_set_rate_resample);
    1.57 -MAKE_FUNC(snd_pcm_hw_params_set_buffer_time_near);
    1.58 -MAKE_FUNC(snd_pcm_hw_params_set_period_time_near);
    1.59 -MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_near);
    1.60 -MAKE_FUNC(snd_pcm_hw_params_set_period_size_near);
    1.61 -MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_min);
    1.62 -MAKE_FUNC(snd_pcm_hw_params_get_buffer_size);
    1.63 -MAKE_FUNC(snd_pcm_hw_params_get_period_size);
    1.64 -MAKE_FUNC(snd_pcm_hw_params_get_access);
    1.65 -MAKE_FUNC(snd_pcm_hw_params_get_periods);
    1.66 -MAKE_FUNC(snd_pcm_hw_params);
    1.67 -MAKE_FUNC(snd_pcm_sw_params_malloc);
    1.68 -MAKE_FUNC(snd_pcm_sw_params_current);
    1.69 -MAKE_FUNC(snd_pcm_sw_params_set_avail_min);
    1.70 -MAKE_FUNC(snd_pcm_sw_params);
    1.71 -MAKE_FUNC(snd_pcm_sw_params_free);
    1.72 -MAKE_FUNC(snd_pcm_prepare);
    1.73 -MAKE_FUNC(snd_pcm_start);
    1.74 -MAKE_FUNC(snd_pcm_resume);
    1.75 -MAKE_FUNC(snd_pcm_wait);
    1.76 -MAKE_FUNC(snd_pcm_state);
    1.77 -MAKE_FUNC(snd_pcm_avail_update);
    1.78 -MAKE_FUNC(snd_pcm_areas_silence);
    1.79 -MAKE_FUNC(snd_pcm_mmap_begin);
    1.80 -MAKE_FUNC(snd_pcm_mmap_commit);
    1.81 -MAKE_FUNC(snd_pcm_readi);
    1.82 -MAKE_FUNC(snd_pcm_writei);
    1.83 -MAKE_FUNC(snd_pcm_drain);
    1.84 -MAKE_FUNC(snd_pcm_recover);
    1.85 -MAKE_FUNC(snd_pcm_info_malloc);
    1.86 -MAKE_FUNC(snd_pcm_info_free);
    1.87 -MAKE_FUNC(snd_pcm_info_set_device);
    1.88 -MAKE_FUNC(snd_pcm_info_set_subdevice);
    1.89 -MAKE_FUNC(snd_pcm_info_set_stream);
    1.90 -MAKE_FUNC(snd_pcm_info_get_name);
    1.91 -MAKE_FUNC(snd_ctl_pcm_next_device);
    1.92 -MAKE_FUNC(snd_ctl_pcm_info);
    1.93 -MAKE_FUNC(snd_ctl_open);
    1.94 -MAKE_FUNC(snd_ctl_close);
    1.95 -MAKE_FUNC(snd_ctl_card_info_malloc);
    1.96 -MAKE_FUNC(snd_ctl_card_info_free);
    1.97 -MAKE_FUNC(snd_ctl_card_info);
    1.98 -MAKE_FUNC(snd_ctl_card_info_get_name);
    1.99 -MAKE_FUNC(snd_ctl_card_info_get_id);
   1.100 -MAKE_FUNC(snd_card_next);
   1.101 -#undef MAKE_FUNC
   1.102 -
   1.103 -#define snd_strerror psnd_strerror
   1.104 -#define snd_pcm_open psnd_pcm_open
   1.105 -#define snd_pcm_close psnd_pcm_close
   1.106 -#define snd_pcm_nonblock psnd_pcm_nonblock
   1.107 -#define snd_pcm_frames_to_bytes psnd_pcm_frames_to_bytes
   1.108 -#define snd_pcm_bytes_to_frames psnd_pcm_bytes_to_frames
   1.109 -#define snd_pcm_hw_params_malloc psnd_pcm_hw_params_malloc
   1.110 -#define snd_pcm_hw_params_free psnd_pcm_hw_params_free
   1.111 -#define snd_pcm_hw_params_any psnd_pcm_hw_params_any
   1.112 -#define snd_pcm_hw_params_set_access psnd_pcm_hw_params_set_access
   1.113 -#define snd_pcm_hw_params_set_format psnd_pcm_hw_params_set_format
   1.114 -#define snd_pcm_hw_params_set_channels psnd_pcm_hw_params_set_channels
   1.115 -#define snd_pcm_hw_params_set_periods_near psnd_pcm_hw_params_set_periods_near
   1.116 -#define snd_pcm_hw_params_set_rate_near psnd_pcm_hw_params_set_rate_near
   1.117 -#define snd_pcm_hw_params_set_rate psnd_pcm_hw_params_set_rate
   1.118 -#define snd_pcm_hw_params_set_rate_resample psnd_pcm_hw_params_set_rate_resample
   1.119 -#define snd_pcm_hw_params_set_buffer_time_near psnd_pcm_hw_params_set_buffer_time_near
   1.120 -#define snd_pcm_hw_params_set_period_time_near psnd_pcm_hw_params_set_period_time_near
   1.121 -#define snd_pcm_hw_params_set_buffer_size_near psnd_pcm_hw_params_set_buffer_size_near
   1.122 -#define snd_pcm_hw_params_set_period_size_near psnd_pcm_hw_params_set_period_size_near
   1.123 -#define snd_pcm_hw_params_set_buffer_size_min psnd_pcm_hw_params_set_buffer_size_min
   1.124 -#define snd_pcm_hw_params_get_buffer_size psnd_pcm_hw_params_get_buffer_size
   1.125 -#define snd_pcm_hw_params_get_period_size psnd_pcm_hw_params_get_period_size
   1.126 -#define snd_pcm_hw_params_get_access psnd_pcm_hw_params_get_access
   1.127 -#define snd_pcm_hw_params_get_periods psnd_pcm_hw_params_get_periods
   1.128 -#define snd_pcm_hw_params psnd_pcm_hw_params
   1.129 -#define snd_pcm_sw_params_malloc psnd_pcm_sw_params_malloc
   1.130 -#define snd_pcm_sw_params_current psnd_pcm_sw_params_current
   1.131 -#define snd_pcm_sw_params_set_avail_min psnd_pcm_sw_params_set_avail_min
   1.132 -#define snd_pcm_sw_params psnd_pcm_sw_params
   1.133 -#define snd_pcm_sw_params_free psnd_pcm_sw_params_free
   1.134 -#define snd_pcm_prepare psnd_pcm_prepare
   1.135 -#define snd_pcm_start psnd_pcm_start
   1.136 -#define snd_pcm_resume psnd_pcm_resume
   1.137 -#define snd_pcm_wait psnd_pcm_wait
   1.138 -#define snd_pcm_state psnd_pcm_state
   1.139 -#define snd_pcm_avail_update psnd_pcm_avail_update
   1.140 -#define snd_pcm_areas_silence psnd_pcm_areas_silence
   1.141 -#define snd_pcm_mmap_begin psnd_pcm_mmap_begin
   1.142 -#define snd_pcm_mmap_commit psnd_pcm_mmap_commit
   1.143 -#define snd_pcm_readi psnd_pcm_readi
   1.144 -#define snd_pcm_writei psnd_pcm_writei
   1.145 -#define snd_pcm_drain psnd_pcm_drain
   1.146 -#define snd_pcm_recover psnd_pcm_recover
   1.147 -#define snd_pcm_info_malloc psnd_pcm_info_malloc
   1.148 -#define snd_pcm_info_free psnd_pcm_info_free
   1.149 -#define snd_pcm_info_set_device psnd_pcm_info_set_device
   1.150 -#define snd_pcm_info_set_subdevice psnd_pcm_info_set_subdevice
   1.151 -#define snd_pcm_info_set_stream psnd_pcm_info_set_stream
   1.152 -#define snd_pcm_info_get_name psnd_pcm_info_get_name
   1.153 -#define snd_ctl_pcm_next_device psnd_ctl_pcm_next_device
   1.154 -#define snd_ctl_pcm_info psnd_ctl_pcm_info
   1.155 -#define snd_ctl_open psnd_ctl_open
   1.156 -#define snd_ctl_close psnd_ctl_close
   1.157 -#define snd_ctl_card_info_malloc psnd_ctl_card_info_malloc
   1.158 -#define snd_ctl_card_info_free psnd_ctl_card_info_free
   1.159 -#define snd_ctl_card_info psnd_ctl_card_info
   1.160 -#define snd_ctl_card_info_get_name psnd_ctl_card_info_get_name
   1.161 -#define snd_ctl_card_info_get_id psnd_ctl_card_info_get_id
   1.162 -#define snd_card_next psnd_card_next
   1.163 -#endif
   1.164 -
   1.165 -
   1.166 -static ALCboolean alsa_load(void)
   1.167 -{
   1.168 -    if(!alsa_handle)
   1.169 -    {
   1.170 -#ifdef HAVE_DYNLOAD
   1.171 -        alsa_handle = LoadLib("libasound.so.2");
   1.172 -        if(!alsa_handle)
   1.173 -            return ALC_FALSE;
   1.174 -
   1.175 -#define LOAD_FUNC(f) do {                                                     \
   1.176 -    p##f = GetSymbol(alsa_handle, #f);                                        \
   1.177 -    if(p##f == NULL) {                                                        \
   1.178 -        CloseLib(alsa_handle);                                                \
   1.179 -        alsa_handle = NULL;                                                   \
   1.180 -        return ALC_FALSE;                                                     \
   1.181 -    }                                                                         \
   1.182 -} while(0)
   1.183 -        LOAD_FUNC(snd_strerror);
   1.184 -        LOAD_FUNC(snd_pcm_open);
   1.185 -        LOAD_FUNC(snd_pcm_close);
   1.186 -        LOAD_FUNC(snd_pcm_nonblock);
   1.187 -        LOAD_FUNC(snd_pcm_frames_to_bytes);
   1.188 -        LOAD_FUNC(snd_pcm_bytes_to_frames);
   1.189 -        LOAD_FUNC(snd_pcm_hw_params_malloc);
   1.190 -        LOAD_FUNC(snd_pcm_hw_params_free);
   1.191 -        LOAD_FUNC(snd_pcm_hw_params_any);
   1.192 -        LOAD_FUNC(snd_pcm_hw_params_set_access);
   1.193 -        LOAD_FUNC(snd_pcm_hw_params_set_format);
   1.194 -        LOAD_FUNC(snd_pcm_hw_params_set_channels);
   1.195 -        LOAD_FUNC(snd_pcm_hw_params_set_periods_near);
   1.196 -        LOAD_FUNC(snd_pcm_hw_params_set_rate_near);
   1.197 -        LOAD_FUNC(snd_pcm_hw_params_set_rate);
   1.198 -        LOAD_FUNC(snd_pcm_hw_params_set_rate_resample);
   1.199 -        LOAD_FUNC(snd_pcm_hw_params_set_buffer_time_near);
   1.200 -        LOAD_FUNC(snd_pcm_hw_params_set_period_time_near);
   1.201 -        LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_near);
   1.202 -        LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_min);
   1.203 -        LOAD_FUNC(snd_pcm_hw_params_set_period_size_near);
   1.204 -        LOAD_FUNC(snd_pcm_hw_params_get_buffer_size);
   1.205 -        LOAD_FUNC(snd_pcm_hw_params_get_period_size);
   1.206 -        LOAD_FUNC(snd_pcm_hw_params_get_access);
   1.207 -        LOAD_FUNC(snd_pcm_hw_params_get_periods);
   1.208 -        LOAD_FUNC(snd_pcm_hw_params);
   1.209 -        LOAD_FUNC(snd_pcm_sw_params_malloc);
   1.210 -        LOAD_FUNC(snd_pcm_sw_params_current);
   1.211 -        LOAD_FUNC(snd_pcm_sw_params_set_avail_min);
   1.212 -        LOAD_FUNC(snd_pcm_sw_params);
   1.213 -        LOAD_FUNC(snd_pcm_sw_params_free);
   1.214 -        LOAD_FUNC(snd_pcm_prepare);
   1.215 -        LOAD_FUNC(snd_pcm_start);
   1.216 -        LOAD_FUNC(snd_pcm_resume);
   1.217 -        LOAD_FUNC(snd_pcm_wait);
   1.218 -        LOAD_FUNC(snd_pcm_state);
   1.219 -        LOAD_FUNC(snd_pcm_avail_update);
   1.220 -        LOAD_FUNC(snd_pcm_areas_silence);
   1.221 -        LOAD_FUNC(snd_pcm_mmap_begin);
   1.222 -        LOAD_FUNC(snd_pcm_mmap_commit);
   1.223 -        LOAD_FUNC(snd_pcm_readi);
   1.224 -        LOAD_FUNC(snd_pcm_writei);
   1.225 -        LOAD_FUNC(snd_pcm_drain);
   1.226 -        LOAD_FUNC(snd_pcm_recover);
   1.227 -        LOAD_FUNC(snd_pcm_info_malloc);
   1.228 -        LOAD_FUNC(snd_pcm_info_free);
   1.229 -        LOAD_FUNC(snd_pcm_info_set_device);
   1.230 -        LOAD_FUNC(snd_pcm_info_set_subdevice);
   1.231 -        LOAD_FUNC(snd_pcm_info_set_stream);
   1.232 -        LOAD_FUNC(snd_pcm_info_get_name);
   1.233 -        LOAD_FUNC(snd_ctl_pcm_next_device);
   1.234 -        LOAD_FUNC(snd_ctl_pcm_info);
   1.235 -        LOAD_FUNC(snd_ctl_open);
   1.236 -        LOAD_FUNC(snd_ctl_close);
   1.237 -        LOAD_FUNC(snd_ctl_card_info_malloc);
   1.238 -        LOAD_FUNC(snd_ctl_card_info_free);
   1.239 -        LOAD_FUNC(snd_ctl_card_info);
   1.240 -        LOAD_FUNC(snd_ctl_card_info_get_name);
   1.241 -        LOAD_FUNC(snd_ctl_card_info_get_id);
   1.242 -        LOAD_FUNC(snd_card_next);
   1.243 -#undef LOAD_FUNC
   1.244 -#else
   1.245 -        alsa_handle = (void*)0xDEADBEEF;
   1.246 -#endif
   1.247 -    }
   1.248 -    return ALC_TRUE;
   1.249 -}
   1.250 -
   1.251 -
   1.252 -typedef struct {
   1.253 -    snd_pcm_t *pcmHandle;
   1.254 -
   1.255 -    ALvoid *buffer;
   1.256 -    ALsizei size;
   1.257 -
   1.258 -    ALboolean doCapture;
   1.259 -    RingBuffer *ring;
   1.260 -
   1.261 -    volatile int killNow;
   1.262 -    ALvoid *thread;
   1.263 -} alsa_data;
   1.264 -
   1.265 -typedef struct {
   1.266 -    ALCchar *name;
   1.267 -    char *card;
   1.268 -    int dev;
   1.269 -} DevMap;
   1.270 -
   1.271 -static DevMap *allDevNameMap;
   1.272 -static ALuint numDevNames;
   1.273 -static DevMap *allCaptureDevNameMap;
   1.274 -static ALuint numCaptureDevNames;
   1.275 -
   1.276 -static const char *device_prefix;
   1.277 -static const char *capture_prefix;
   1.278 -
   1.279 -
   1.280 -static DevMap *probe_devices(snd_pcm_stream_t stream, ALuint *count)
   1.281 -{
   1.282 -    snd_ctl_t *handle;
   1.283 -    int card, err, dev, idx;
   1.284 -    snd_ctl_card_info_t *info;
   1.285 -    snd_pcm_info_t *pcminfo;
   1.286 -    DevMap *DevList;
   1.287 -    char name[1024];
   1.288 -
   1.289 -    snd_ctl_card_info_malloc(&info);
   1.290 -    snd_pcm_info_malloc(&pcminfo);
   1.291 -
   1.292 -    card = -1;
   1.293 -    if((err=snd_card_next(&card)) < 0)
   1.294 -        ERR("Failed to find a card: %s\n", snd_strerror(err));
   1.295 -
   1.296 -    DevList = malloc(sizeof(DevMap) * 1);
   1.297 -    DevList[0].name = strdup("ALSA Default");
   1.298 -    DevList[0].card = NULL;
   1.299 -    DevList[0].dev = 0;
   1.300 -    idx = 1;
   1.301 -    while(card >= 0)
   1.302 -    {
   1.303 -        sprintf(name, "hw:%d", card);
   1.304 -        if((err = snd_ctl_open(&handle, name, 0)) < 0)
   1.305 -        {
   1.306 -            ERR("control open (%i): %s\n", card, snd_strerror(err));
   1.307 -            goto next_card;
   1.308 -        }
   1.309 -        if((err = snd_ctl_card_info(handle, info)) < 0)
   1.310 -        {
   1.311 -            ERR("control hardware info (%i): %s\n", card, snd_strerror(err));
   1.312 -            snd_ctl_close(handle);
   1.313 -            goto next_card;
   1.314 -        }
   1.315 -
   1.316 -        dev = -1;
   1.317 -        while(1)
   1.318 -        {
   1.319 -            const char *cname, *dname, *cid;
   1.320 -            void *temp;
   1.321 -
   1.322 -            if(snd_ctl_pcm_next_device(handle, &dev) < 0)
   1.323 -                ERR("snd_ctl_pcm_next_device failed\n");
   1.324 -            if(dev < 0)
   1.325 -                break;
   1.326 -
   1.327 -            snd_pcm_info_set_device(pcminfo, dev);
   1.328 -            snd_pcm_info_set_subdevice(pcminfo, 0);
   1.329 -            snd_pcm_info_set_stream(pcminfo, stream);
   1.330 -            if((err = snd_ctl_pcm_info(handle, pcminfo)) < 0) {
   1.331 -                if(err != -ENOENT)
   1.332 -                    ERR("control digital audio info (%i): %s\n", card, snd_strerror(err));
   1.333 -                continue;
   1.334 -            }
   1.335 -
   1.336 -            temp = realloc(DevList, sizeof(DevMap) * (idx+1));
   1.337 -            if(temp)
   1.338 -            {
   1.339 -                DevList = temp;
   1.340 -                cname = snd_ctl_card_info_get_name(info);
   1.341 -                dname = snd_pcm_info_get_name(pcminfo);
   1.342 -                cid = snd_ctl_card_info_get_id(info);
   1.343 -                snprintf(name, sizeof(name), "%s, %s (CARD=%s,DEV=%d)",
   1.344 -                         cname, dname, cid, dev);
   1.345 -                DevList[idx].name = strdup(name);
   1.346 -                DevList[idx].card = strdup(cid);
   1.347 -                DevList[idx].dev = dev;
   1.348 -                idx++;
   1.349 -            }
   1.350 -        }
   1.351 -        snd_ctl_close(handle);
   1.352 -    next_card:
   1.353 -        if(snd_card_next(&card) < 0) {
   1.354 -            ERR("snd_card_next failed\n");
   1.355 -            break;
   1.356 -        }
   1.357 -    }
   1.358 -
   1.359 -    snd_pcm_info_free(pcminfo);
   1.360 -    snd_ctl_card_info_free(info);
   1.361 -
   1.362 -    *count = idx;
   1.363 -    return DevList;
   1.364 -}
   1.365 -
   1.366 -
   1.367 -static int xrun_recovery(snd_pcm_t *handle, int err)
   1.368 -{
   1.369 -    err = snd_pcm_recover(handle, err, 1);
   1.370 -    if(err < 0)
   1.371 -        ERR("recover failed: %s\n", snd_strerror(err));
   1.372 -    return err;
   1.373 -}
   1.374 -
   1.375 -static int verify_state(snd_pcm_t *handle)
   1.376 -{
   1.377 -    snd_pcm_state_t state = snd_pcm_state(handle);
   1.378 -    if(state == SND_PCM_STATE_DISCONNECTED)
   1.379 -        return -ENODEV;
   1.380 -    if(state == SND_PCM_STATE_XRUN)
   1.381 -    {
   1.382 -        int err = xrun_recovery(handle, -EPIPE);
   1.383 -        if(err < 0) return err;
   1.384 -    }
   1.385 -    else if(state == SND_PCM_STATE_SUSPENDED)
   1.386 -    {
   1.387 -        int err = xrun_recovery(handle, -ESTRPIPE);
   1.388 -        if(err < 0) return err;
   1.389 -    }
   1.390 -
   1.391 -    return state;
   1.392 -}
   1.393 -
   1.394 -
   1.395 -static ALuint ALSAProc(ALvoid *ptr)
   1.396 -{
   1.397 -    ALCdevice *pDevice = (ALCdevice*)ptr;
   1.398 -    alsa_data *data = (alsa_data*)pDevice->ExtraData;
   1.399 -    const snd_pcm_channel_area_t *areas = NULL;
   1.400 -    snd_pcm_sframes_t avail, commitres;
   1.401 -    snd_pcm_uframes_t offset, frames;
   1.402 -    char *WritePtr;
   1.403 -    int err;
   1.404 -
   1.405 -    SetRTPriority();
   1.406 -
   1.407 -    while(!data->killNow)
   1.408 -    {
   1.409 -        int state = verify_state(data->pcmHandle);
   1.410 -        if(state < 0)
   1.411 -        {
   1.412 -            ERR("Invalid state detected: %s\n", snd_strerror(state));
   1.413 -            aluHandleDisconnect(pDevice);
   1.414 -            break;
   1.415 -        }
   1.416 -
   1.417 -        avail = snd_pcm_avail_update(data->pcmHandle);
   1.418 -        if(avail < 0)
   1.419 -        {
   1.420 -            ERR("available update failed: %s\n", snd_strerror(avail));
   1.421 -            continue;
   1.422 -        }
   1.423 -
   1.424 -        // make sure there's frames to process
   1.425 -        if((snd_pcm_uframes_t)avail < pDevice->UpdateSize)
   1.426 -        {
   1.427 -            if(state != SND_PCM_STATE_RUNNING)
   1.428 -            {
   1.429 -                err = snd_pcm_start(data->pcmHandle);
   1.430 -                if(err < 0)
   1.431 -                {
   1.432 -                    ERR("start failed: %s\n", snd_strerror(err));
   1.433 -                    continue;
   1.434 -                }
   1.435 -            }
   1.436 -            if(snd_pcm_wait(data->pcmHandle, 1000) == 0)
   1.437 -                ERR("Wait timeout... buffer size too low?\n");
   1.438 -            continue;
   1.439 -        }
   1.440 -        avail -= avail%pDevice->UpdateSize;
   1.441 -
   1.442 -        // it is possible that contiguous areas are smaller, thus we use a loop
   1.443 -        while(avail > 0)
   1.444 -        {
   1.445 -            frames = avail;
   1.446 -
   1.447 -            err = snd_pcm_mmap_begin(data->pcmHandle, &areas, &offset, &frames);
   1.448 -            if(err < 0)
   1.449 -            {
   1.450 -                ERR("mmap begin error: %s\n", snd_strerror(err));
   1.451 -                break;
   1.452 -            }
   1.453 -
   1.454 -            WritePtr = (char*)areas->addr + (offset * areas->step / 8);
   1.455 -            aluMixData(pDevice, WritePtr, frames);
   1.456 -
   1.457 -            commitres = snd_pcm_mmap_commit(data->pcmHandle, offset, frames);
   1.458 -            if(commitres < 0 || (commitres-frames) != 0)
   1.459 -            {
   1.460 -                ERR("mmap commit error: %s\n",
   1.461 -                    snd_strerror(commitres >= 0 ? -EPIPE : commitres));
   1.462 -                break;
   1.463 -            }
   1.464 -
   1.465 -            avail -= frames;
   1.466 -        }
   1.467 -    }
   1.468 -
   1.469 -    return 0;
   1.470 -}
   1.471 -
   1.472 -static ALuint ALSANoMMapProc(ALvoid *ptr)
   1.473 -{
   1.474 -    ALCdevice *pDevice = (ALCdevice*)ptr;
   1.475 -    alsa_data *data = (alsa_data*)pDevice->ExtraData;
   1.476 -    snd_pcm_sframes_t avail;
   1.477 -    char *WritePtr;
   1.478 -
   1.479 -    SetRTPriority();
   1.480 -
   1.481 -    while(!data->killNow)
   1.482 -    {
   1.483 -        int state = verify_state(data->pcmHandle);
   1.484 -        if(state < 0)
   1.485 -        {
   1.486 -            ERR("Invalid state detected: %s\n", snd_strerror(state));
   1.487 -            aluHandleDisconnect(pDevice);
   1.488 -            break;
   1.489 -        }
   1.490 -
   1.491 -        WritePtr = data->buffer;
   1.492 -        avail = data->size / snd_pcm_frames_to_bytes(data->pcmHandle, 1);
   1.493 -        aluMixData(pDevice, WritePtr, avail);
   1.494 -
   1.495 -        while(avail > 0)
   1.496 -        {
   1.497 -            int ret = snd_pcm_writei(data->pcmHandle, WritePtr, avail);
   1.498 -            switch (ret)
   1.499 -            {
   1.500 -            case -EAGAIN:
   1.501 -                continue;
   1.502 -            case -ESTRPIPE:
   1.503 -            case -EPIPE:
   1.504 -            case -EINTR:
   1.505 -                ret = snd_pcm_recover(data->pcmHandle, ret, 1);
   1.506 -                if(ret < 0)
   1.507 -                    avail = 0;
   1.508 -                break;
   1.509 -            default:
   1.510 -                if (ret >= 0)
   1.511 -                {
   1.512 -                    WritePtr += snd_pcm_frames_to_bytes(data->pcmHandle, ret);
   1.513 -                    avail -= ret;
   1.514 -                }
   1.515 -                break;
   1.516 -            }
   1.517 -            if (ret < 0)
   1.518 -            {
   1.519 -                ret = snd_pcm_prepare(data->pcmHandle);
   1.520 -                if(ret < 0)
   1.521 -                    break;
   1.522 -            }
   1.523 -        }
   1.524 -    }
   1.525 -
   1.526 -    return 0;
   1.527 -}
   1.528 -
   1.529 -static ALCboolean alsa_open_playback(ALCdevice *device, const ALCchar *deviceName)
   1.530 -{
   1.531 -    alsa_data *data;
   1.532 -    char driver[128];
   1.533 -    int i;
   1.534 -
   1.535 -    strncpy(driver, GetConfigValue("alsa", "device", "default"), sizeof(driver)-1);
   1.536 -    driver[sizeof(driver)-1] = 0;
   1.537 -
   1.538 -    if(!deviceName)
   1.539 -        deviceName = alsaDevice;
   1.540 -    else if(strcmp(deviceName, alsaDevice) != 0)
   1.541 -    {
   1.542 -        size_t idx;
   1.543 -
   1.544 -        if(!allDevNameMap)
   1.545 -            allDevNameMap = probe_devices(SND_PCM_STREAM_PLAYBACK, &numDevNames);
   1.546 -
   1.547 -        for(idx = 0;idx < numDevNames;idx++)
   1.548 -        {
   1.549 -            if(allDevNameMap[idx].name &&
   1.550 -               strcmp(deviceName, allDevNameMap[idx].name) == 0)
   1.551 -            {
   1.552 -                if(idx > 0)
   1.553 -                    snprintf(driver, sizeof(driver), "%sCARD=%s,DEV=%d", device_prefix,
   1.554 -                            allDevNameMap[idx].card, allDevNameMap[idx].dev);
   1.555 -                break;
   1.556 -            }
   1.557 -        }
   1.558 -        if(idx == numDevNames)
   1.559 -            return ALC_FALSE;
   1.560 -    }
   1.561 -
   1.562 -    data = (alsa_data*)calloc(1, sizeof(alsa_data));
   1.563 -
   1.564 -    i = snd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
   1.565 -    if(i >= 0)
   1.566 -    {
   1.567 -        i = snd_pcm_nonblock(data->pcmHandle, 0);
   1.568 -        if(i < 0)
   1.569 -            snd_pcm_close(data->pcmHandle);
   1.570 -    }
   1.571 -    if(i < 0)
   1.572 -    {
   1.573 -        free(data);
   1.574 -        ERR("Could not open playback device '%s': %s\n", driver, snd_strerror(i));
   1.575 -        return ALC_FALSE;
   1.576 -    }
   1.577 -
   1.578 -    device->szDeviceName = strdup(deviceName);
   1.579 -    device->ExtraData = data;
   1.580 -    return ALC_TRUE;
   1.581 -}
   1.582 -
   1.583 -static void alsa_close_playback(ALCdevice *device)
   1.584 -{
   1.585 -    alsa_data *data = (alsa_data*)device->ExtraData;
   1.586 -
   1.587 -    snd_pcm_close(data->pcmHandle);
   1.588 -    free(data);
   1.589 -    device->ExtraData = NULL;
   1.590 -}
   1.591 -
   1.592 -static ALCboolean alsa_reset_playback(ALCdevice *device)
   1.593 -{
   1.594 -    alsa_data *data = (alsa_data*)device->ExtraData;
   1.595 -    snd_pcm_uframes_t periodSizeInFrames;
   1.596 -    unsigned int periodLen, bufferLen;
   1.597 -    snd_pcm_sw_params_t *sp = NULL;
   1.598 -    snd_pcm_hw_params_t *p = NULL;
   1.599 -    snd_pcm_access_t access;
   1.600 -    snd_pcm_format_t format;
   1.601 -    unsigned int periods;
   1.602 -    unsigned int rate;
   1.603 -    int allowmmap;
   1.604 -    char *err;
   1.605 -    int i;
   1.606 -
   1.607 -
   1.608 -    format = -1;
   1.609 -    switch(device->FmtType)
   1.610 -    {
   1.611 -        case DevFmtByte:
   1.612 -            format = SND_PCM_FORMAT_S8;
   1.613 -            break;
   1.614 -        case DevFmtUByte:
   1.615 -            format = SND_PCM_FORMAT_U8;
   1.616 -            break;
   1.617 -        case DevFmtShort:
   1.618 -            format = SND_PCM_FORMAT_S16;
   1.619 -            break;
   1.620 -        case DevFmtUShort:
   1.621 -            format = SND_PCM_FORMAT_U16;
   1.622 -            break;
   1.623 -        case DevFmtFloat:
   1.624 -            format = SND_PCM_FORMAT_FLOAT;
   1.625 -            break;
   1.626 -    }
   1.627 -
   1.628 -    allowmmap = GetConfigValueBool("alsa", "mmap", 1);
   1.629 -    periods = device->NumUpdates;
   1.630 -    periodLen = (ALuint64)device->UpdateSize * 1000000 / device->Frequency;
   1.631 -    bufferLen = periodLen * periods;
   1.632 -    rate = device->Frequency;
   1.633 -
   1.634 -    err = NULL;
   1.635 -    snd_pcm_hw_params_malloc(&p);
   1.636 -
   1.637 -    if((i=snd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
   1.638 -        err = "any";
   1.639 -    /* set interleaved access */
   1.640 -    if(i >= 0 && (!allowmmap || (i=snd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED)) < 0))
   1.641 -    {
   1.642 -        if(periods > 2)
   1.643 -        {
   1.644 -            periods--;
   1.645 -            bufferLen = periodLen * periods;
   1.646 -        }
   1.647 -        if((i=snd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
   1.648 -            err = "set access";
   1.649 -    }
   1.650 -    /* set format (implicitly sets sample bits) */
   1.651 -    if(i >= 0 && (i=snd_pcm_hw_params_set_format(data->pcmHandle, p, format)) < 0)
   1.652 -    {
   1.653 -        device->FmtType = DevFmtFloat;
   1.654 -        if(format == SND_PCM_FORMAT_FLOAT ||
   1.655 -           (i=snd_pcm_hw_params_set_format(data->pcmHandle, p, SND_PCM_FORMAT_FLOAT)) < 0)
   1.656 -        {
   1.657 -            device->FmtType = DevFmtShort;
   1.658 -            if(format == SND_PCM_FORMAT_S16 ||
   1.659 -               (i=snd_pcm_hw_params_set_format(data->pcmHandle, p, SND_PCM_FORMAT_S16)) < 0)
   1.660 -            {
   1.661 -                device->FmtType = DevFmtUByte;
   1.662 -                if(format == SND_PCM_FORMAT_U8 ||
   1.663 -                   (i=snd_pcm_hw_params_set_format(data->pcmHandle, p, SND_PCM_FORMAT_U8)) < 0)
   1.664 -                    err = "set format";
   1.665 -            }
   1.666 -        }
   1.667 -    }
   1.668 -    /* set channels (implicitly sets frame bits) */
   1.669 -    if(i >= 0 && (i=snd_pcm_hw_params_set_channels(data->pcmHandle, p, ChannelsFromDevFmt(device->FmtChans))) < 0)
   1.670 -    {
   1.671 -        if((i=snd_pcm_hw_params_set_channels(data->pcmHandle, p, 2)) < 0)
   1.672 -        {
   1.673 -            if((i=snd_pcm_hw_params_set_channels(data->pcmHandle, p, 1)) < 0)
   1.674 -                err = "set channels";
   1.675 -            else
   1.676 -            {
   1.677 -                if((device->Flags&DEVICE_CHANNELS_REQUEST))
   1.678 -                    ERR("Failed to set %s, got Mono instead\n", DevFmtChannelsString(device->FmtChans));
   1.679 -                device->FmtChans = DevFmtMono;
   1.680 -            }
   1.681 -        }
   1.682 -        else
   1.683 -        {
   1.684 -            if((device->Flags&DEVICE_CHANNELS_REQUEST))
   1.685 -                ERR("Failed to set %s, got Stereo instead\n", DevFmtChannelsString(device->FmtChans));
   1.686 -            device->FmtChans = DevFmtStereo;
   1.687 -        }
   1.688 -        device->Flags &= ~DEVICE_CHANNELS_REQUEST;
   1.689 -    }
   1.690 -    if(i >= 0 && (i=snd_pcm_hw_params_set_rate_resample(data->pcmHandle, p, 0)) < 0)
   1.691 -    {
   1.692 -        ERR("Failed to disable ALSA resampler\n");
   1.693 -        i = 0;
   1.694 -    }
   1.695 -    /* set rate (implicitly constrains period/buffer parameters) */
   1.696 -    if(i >= 0 && (i=snd_pcm_hw_params_set_rate_near(data->pcmHandle, p, &rate, NULL)) < 0)
   1.697 -        err = "set rate near";
   1.698 -    /* set buffer time (implicitly constrains period/buffer parameters) */
   1.699 -    if(i >= 0 && (i=snd_pcm_hw_params_set_buffer_time_near(data->pcmHandle, p, &bufferLen, NULL)) < 0)
   1.700 -        err = "set buffer time near";
   1.701 -    /* set period time in frame units (implicitly sets buffer size/bytes/time and period size/bytes) */
   1.702 -    if(i >= 0 && (i=snd_pcm_hw_params_set_period_time_near(data->pcmHandle, p, &periodLen, NULL)) < 0)
   1.703 -        err = "set period time near";
   1.704 -    /* install and prepare hardware configuration */
   1.705 -    if(i >= 0 && (i=snd_pcm_hw_params(data->pcmHandle, p)) < 0)
   1.706 -        err = "set params";
   1.707 -    if(i >= 0 && (i=snd_pcm_hw_params_get_access(p, &access)) < 0)
   1.708 -        err = "get access";
   1.709 -    if(i >= 0 && (i=snd_pcm_hw_params_get_period_size(p, &periodSizeInFrames, NULL)) < 0)
   1.710 -        err = "get period size";
   1.711 -    if(i >= 0 && (i=snd_pcm_hw_params_get_periods(p, &periods, NULL)) < 0)
   1.712 -        err = "get periods";
   1.713 -    if(i < 0)
   1.714 -    {
   1.715 -        ERR("%s failed: %s\n", err, snd_strerror(i));
   1.716 -        snd_pcm_hw_params_free(p);
   1.717 -        return ALC_FALSE;
   1.718 -    }
   1.719 -
   1.720 -    snd_pcm_hw_params_free(p);
   1.721 -
   1.722 -    err = NULL;
   1.723 -    snd_pcm_sw_params_malloc(&sp);
   1.724 -
   1.725 -    if((i=snd_pcm_sw_params_current(data->pcmHandle, sp)) != 0)
   1.726 -        err = "sw current";
   1.727 -    if(i == 0 && (i=snd_pcm_sw_params_set_avail_min(data->pcmHandle, sp, periodSizeInFrames)) != 0)
   1.728 -        err = "sw set avail min";
   1.729 -    if(i == 0 && (i=snd_pcm_sw_params(data->pcmHandle, sp)) != 0)
   1.730 -        err = "sw set params";
   1.731 -    if(i != 0)
   1.732 -    {
   1.733 -        ERR("%s failed: %s\n", err, snd_strerror(i));
   1.734 -        snd_pcm_sw_params_free(sp);
   1.735 -        return ALC_FALSE;
   1.736 -    }
   1.737 -
   1.738 -    snd_pcm_sw_params_free(sp);
   1.739 -
   1.740 -    if(device->Frequency != rate)
   1.741 -    {
   1.742 -        if((device->Flags&DEVICE_FREQUENCY_REQUEST))
   1.743 -            ERR("Failed to set %dhz, got %dhz instead\n", device->Frequency, rate);
   1.744 -        device->Flags &= ~DEVICE_FREQUENCY_REQUEST;
   1.745 -        device->Frequency = rate;
   1.746 -    }
   1.747 -
   1.748 -    SetDefaultChannelOrder(device);
   1.749 -
   1.750 -    data->size = snd_pcm_frames_to_bytes(data->pcmHandle, periodSizeInFrames);
   1.751 -    if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
   1.752 -    {
   1.753 -        /* Increase periods by one, since the temp buffer counts as an extra
   1.754 -         * period */
   1.755 -        periods++;
   1.756 -        data->buffer = malloc(data->size);
   1.757 -        if(!data->buffer)
   1.758 -        {
   1.759 -            ERR("buffer malloc failed\n");
   1.760 -            return ALC_FALSE;
   1.761 -        }
   1.762 -        device->UpdateSize = periodSizeInFrames;
   1.763 -        device->NumUpdates = periods;
   1.764 -        data->thread = StartThread(ALSANoMMapProc, device);
   1.765 -    }
   1.766 -    else
   1.767 -    {
   1.768 -        i = snd_pcm_prepare(data->pcmHandle);
   1.769 -        if(i < 0)
   1.770 -        {
   1.771 -            ERR("prepare error: %s\n", snd_strerror(i));
   1.772 -            return ALC_FALSE;
   1.773 -        }
   1.774 -        device->UpdateSize = periodSizeInFrames;
   1.775 -        device->NumUpdates = periods;
   1.776 -        data->thread = StartThread(ALSAProc, device);
   1.777 -    }
   1.778 -    if(data->thread == NULL)
   1.779 -    {
   1.780 -        ERR("Could not create playback thread\n");
   1.781 -        free(data->buffer);
   1.782 -        data->buffer = NULL;
   1.783 -        return ALC_FALSE;
   1.784 -    }
   1.785 -
   1.786 -    return ALC_TRUE;
   1.787 -}
   1.788 -
   1.789 -static void alsa_stop_playback(ALCdevice *device)
   1.790 -{
   1.791 -    alsa_data *data = (alsa_data*)device->ExtraData;
   1.792 -
   1.793 -    if(data->thread)
   1.794 -    {
   1.795 -        data->killNow = 1;
   1.796 -        StopThread(data->thread);
   1.797 -        data->thread = NULL;
   1.798 -    }
   1.799 -    data->killNow = 0;
   1.800 -    free(data->buffer);
   1.801 -    data->buffer = NULL;
   1.802 -}
   1.803 -
   1.804 -
   1.805 -static ALCboolean alsa_open_capture(ALCdevice *pDevice, const ALCchar *deviceName)
   1.806 -{
   1.807 -    snd_pcm_hw_params_t *p;
   1.808 -    snd_pcm_uframes_t bufferSizeInFrames;
   1.809 -    snd_pcm_format_t format;
   1.810 -    ALuint frameSize;
   1.811 -    alsa_data *data;
   1.812 -    char driver[128];
   1.813 -    char *err;
   1.814 -    int i;
   1.815 -
   1.816 -    strncpy(driver, GetConfigValue("alsa", "capture", "default"), sizeof(driver)-1);
   1.817 -    driver[sizeof(driver)-1] = 0;
   1.818 -
   1.819 -    if(!allCaptureDevNameMap)
   1.820 -        allCaptureDevNameMap = probe_devices(SND_PCM_STREAM_CAPTURE, &numCaptureDevNames);
   1.821 -
   1.822 -    if(!deviceName)
   1.823 -        deviceName = allCaptureDevNameMap[0].name;
   1.824 -    else
   1.825 -    {
   1.826 -        size_t idx;
   1.827 -
   1.828 -        for(idx = 0;idx < numCaptureDevNames;idx++)
   1.829 -        {
   1.830 -            if(allCaptureDevNameMap[idx].name &&
   1.831 -               strcmp(deviceName, allCaptureDevNameMap[idx].name) == 0)
   1.832 -            {
   1.833 -                if(idx > 0)
   1.834 -                    snprintf(driver, sizeof(driver), "%sCARD=%s,DEV=%d", capture_prefix,
   1.835 -                             allCaptureDevNameMap[idx].card, allCaptureDevNameMap[idx].dev);
   1.836 -                break;
   1.837 -            }
   1.838 -        }
   1.839 -        if(idx == numCaptureDevNames)
   1.840 -            return ALC_FALSE;
   1.841 -    }
   1.842 -
   1.843 -    data = (alsa_data*)calloc(1, sizeof(alsa_data));
   1.844 -
   1.845 -    i = snd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
   1.846 -    if(i < 0)
   1.847 -    {
   1.848 -        ERR("Could not open capture device '%s': %s\n", driver, snd_strerror(i));
   1.849 -        free(data);
   1.850 -        return ALC_FALSE;
   1.851 -    }
   1.852 -
   1.853 -    format = -1;
   1.854 -    switch(pDevice->FmtType)
   1.855 -    {
   1.856 -        case DevFmtByte:
   1.857 -            format = SND_PCM_FORMAT_S8;
   1.858 -            break;
   1.859 -        case DevFmtUByte:
   1.860 -            format = SND_PCM_FORMAT_U8;
   1.861 -            break;
   1.862 -        case DevFmtShort:
   1.863 -            format = SND_PCM_FORMAT_S16;
   1.864 -            break;
   1.865 -        case DevFmtUShort:
   1.866 -            format = SND_PCM_FORMAT_U16;
   1.867 -            break;
   1.868 -        case DevFmtFloat:
   1.869 -            format = SND_PCM_FORMAT_FLOAT;
   1.870 -            break;
   1.871 -    }
   1.872 -
   1.873 -    err = NULL;
   1.874 -    bufferSizeInFrames = pDevice->UpdateSize * pDevice->NumUpdates;
   1.875 -    snd_pcm_hw_params_malloc(&p);
   1.876 -
   1.877 -    if((i=snd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
   1.878 -        err = "any";
   1.879 -    /* set interleaved access */
   1.880 -    if(i >= 0 && (i=snd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
   1.881 -        err = "set access";
   1.882 -    /* set format (implicitly sets sample bits) */
   1.883 -    if(i >= 0 && (i=snd_pcm_hw_params_set_format(data->pcmHandle, p, format)) < 0)
   1.884 -        err = "set format";
   1.885 -    /* set channels (implicitly sets frame bits) */
   1.886 -    if(i >= 0 && (i=snd_pcm_hw_params_set_channels(data->pcmHandle, p, ChannelsFromDevFmt(pDevice->FmtChans))) < 0)
   1.887 -        err = "set channels";
   1.888 -    /* set rate (implicitly constrains period/buffer parameters) */
   1.889 -    if(i >= 0 && (i=snd_pcm_hw_params_set_rate(data->pcmHandle, p, pDevice->Frequency, 0)) < 0)
   1.890 -        err = "set rate near";
   1.891 -    /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
   1.892 -    if(i >= 0 && (i=snd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames)) < 0)
   1.893 -        err = "set buffer size near";
   1.894 -    /* install and prepare hardware configuration */
   1.895 -    if(i >= 0 && (i=snd_pcm_hw_params(data->pcmHandle, p)) < 0)
   1.896 -        err = "set params";
   1.897 -    if(i < 0)
   1.898 -    {
   1.899 -        ERR("%s failed: %s\n", err, snd_strerror(i));
   1.900 -        snd_pcm_hw_params_free(p);
   1.901 -        goto error;
   1.902 -    }
   1.903 -
   1.904 -    if((i=snd_pcm_hw_params_get_period_size(p, &bufferSizeInFrames, NULL)) < 0)
   1.905 -    {
   1.906 -        ERR("get size failed: %s\n", snd_strerror(i));
   1.907 -        snd_pcm_hw_params_free(p);
   1.908 -        goto error;
   1.909 -    }
   1.910 -
   1.911 -    snd_pcm_hw_params_free(p);
   1.912 -
   1.913 -    frameSize = FrameSizeFromDevFmt(pDevice->FmtChans, pDevice->FmtType);
   1.914 -
   1.915 -    data->ring = CreateRingBuffer(frameSize, pDevice->UpdateSize*pDevice->NumUpdates);
   1.916 -    if(!data->ring)
   1.917 -    {
   1.918 -        ERR("ring buffer create failed\n");
   1.919 -        goto error;
   1.920 -    }
   1.921 -
   1.922 -    data->size = snd_pcm_frames_to_bytes(data->pcmHandle, bufferSizeInFrames);
   1.923 -    data->buffer = malloc(data->size);
   1.924 -    if(!data->buffer)
   1.925 -    {
   1.926 -        ERR("buffer malloc failed\n");
   1.927 -        goto error;
   1.928 -    }
   1.929 -
   1.930 -    pDevice->szDeviceName = strdup(deviceName);
   1.931 -
   1.932 -    pDevice->ExtraData = data;
   1.933 -    return ALC_TRUE;
   1.934 -
   1.935 -error:
   1.936 -    free(data->buffer);
   1.937 -    DestroyRingBuffer(data->ring);
   1.938 -    snd_pcm_close(data->pcmHandle);
   1.939 -    free(data);
   1.940 -
   1.941 -    pDevice->ExtraData = NULL;
   1.942 -    return ALC_FALSE;
   1.943 -}
   1.944 -
   1.945 -static void alsa_close_capture(ALCdevice *pDevice)
   1.946 -{
   1.947 -    alsa_data *data = (alsa_data*)pDevice->ExtraData;
   1.948 -
   1.949 -    snd_pcm_close(data->pcmHandle);
   1.950 -    DestroyRingBuffer(data->ring);
   1.951 -
   1.952 -    free(data->buffer);
   1.953 -    free(data);
   1.954 -    pDevice->ExtraData = NULL;
   1.955 -}
   1.956 -
   1.957 -static void alsa_start_capture(ALCdevice *Device)
   1.958 -{
   1.959 -    alsa_data *data = (alsa_data*)Device->ExtraData;
   1.960 -    int err;
   1.961 -
   1.962 -    err = snd_pcm_start(data->pcmHandle);
   1.963 -    if(err < 0)
   1.964 -    {
   1.965 -        ERR("start failed: %s\n", snd_strerror(err));
   1.966 -        aluHandleDisconnect(Device);
   1.967 -    }
   1.968 -    else
   1.969 -        data->doCapture = AL_TRUE;
   1.970 -}
   1.971 -
   1.972 -static void alsa_stop_capture(ALCdevice *Device)
   1.973 -{
   1.974 -    alsa_data *data = (alsa_data*)Device->ExtraData;
   1.975 -    snd_pcm_drain(data->pcmHandle);
   1.976 -    data->doCapture = AL_FALSE;
   1.977 -}
   1.978 -
   1.979 -static ALCuint alsa_available_samples(ALCdevice *Device)
   1.980 -{
   1.981 -    alsa_data *data = (alsa_data*)Device->ExtraData;
   1.982 -    snd_pcm_sframes_t avail;
   1.983 -
   1.984 -    avail = (Device->Connected ? snd_pcm_avail_update(data->pcmHandle) : 0);
   1.985 -    if(avail < 0)
   1.986 -    {
   1.987 -        ERR("avail update failed: %s\n", snd_strerror(avail));
   1.988 -
   1.989 -        if((avail=snd_pcm_recover(data->pcmHandle, avail, 1)) >= 0)
   1.990 -        {
   1.991 -            if(data->doCapture)
   1.992 -                avail = snd_pcm_start(data->pcmHandle);
   1.993 -            if(avail >= 0)
   1.994 -                avail = snd_pcm_avail_update(data->pcmHandle);
   1.995 -        }
   1.996 -        if(avail < 0)
   1.997 -        {
   1.998 -            ERR("restore error: %s\n", snd_strerror(avail));
   1.999 -            aluHandleDisconnect(Device);
  1.1000 -        }
  1.1001 -    }
  1.1002 -    while(avail > 0)
  1.1003 -    {
  1.1004 -        snd_pcm_sframes_t amt;
  1.1005 -
  1.1006 -        amt = snd_pcm_bytes_to_frames(data->pcmHandle, data->size);
  1.1007 -        if(avail < amt) amt = avail;
  1.1008 -
  1.1009 -        amt = snd_pcm_readi(data->pcmHandle, data->buffer, amt);
  1.1010 -        if(amt < 0)
  1.1011 -        {
  1.1012 -            ERR("read error: %s\n", snd_strerror(amt));
  1.1013 -
  1.1014 -            if(amt == -EAGAIN)
  1.1015 -                continue;
  1.1016 -            if((amt=snd_pcm_recover(data->pcmHandle, amt, 1)) >= 0)
  1.1017 -            {
  1.1018 -                if(data->doCapture)
  1.1019 -                    amt = snd_pcm_start(data->pcmHandle);
  1.1020 -                if(amt >= 0)
  1.1021 -                    amt = snd_pcm_avail_update(data->pcmHandle);
  1.1022 -            }
  1.1023 -            if(amt < 0)
  1.1024 -            {
  1.1025 -                ERR("restore error: %s\n", snd_strerror(amt));
  1.1026 -                aluHandleDisconnect(Device);
  1.1027 -                break;
  1.1028 -            }
  1.1029 -            avail = amt;
  1.1030 -            continue;
  1.1031 -        }
  1.1032 -
  1.1033 -        WriteRingBuffer(data->ring, data->buffer, amt);
  1.1034 -        avail -= amt;
  1.1035 -    }
  1.1036 -
  1.1037 -    return RingBufferSize(data->ring);
  1.1038 -}
  1.1039 -
  1.1040 -static void alsa_capture_samples(ALCdevice *Device, ALCvoid *Buffer, ALCuint Samples)
  1.1041 -{
  1.1042 -    alsa_data *data = (alsa_data*)Device->ExtraData;
  1.1043 -
  1.1044 -    if(Samples <= alsa_available_samples(Device))
  1.1045 -        ReadRingBuffer(data->ring, Buffer, Samples);
  1.1046 -    else
  1.1047 -        alcSetError(Device, ALC_INVALID_VALUE);
  1.1048 -}
  1.1049 -
  1.1050 -
  1.1051 -static const BackendFuncs alsa_funcs = {
  1.1052 -    alsa_open_playback,
  1.1053 -    alsa_close_playback,
  1.1054 -    alsa_reset_playback,
  1.1055 -    alsa_stop_playback,
  1.1056 -    alsa_open_capture,
  1.1057 -    alsa_close_capture,
  1.1058 -    alsa_start_capture,
  1.1059 -    alsa_stop_capture,
  1.1060 -    alsa_capture_samples,
  1.1061 -    alsa_available_samples
  1.1062 -};
  1.1063 -
  1.1064 -ALCboolean alc_alsa_init(BackendFuncs *func_list)
  1.1065 -{
  1.1066 -    if(!alsa_load())
  1.1067 -        return ALC_FALSE;
  1.1068 -    device_prefix = GetConfigValue("alsa", "device-prefix", "plughw:");
  1.1069 -    capture_prefix = GetConfigValue("alsa", "capture-prefix", "plughw:");
  1.1070 -    *func_list = alsa_funcs;
  1.1071 -    return ALC_TRUE;
  1.1072 -}
  1.1073 -
  1.1074 -void alc_alsa_deinit(void)
  1.1075 -{
  1.1076 -    ALuint i;
  1.1077 -
  1.1078 -    for(i = 0;i < numDevNames;++i)
  1.1079 -    {
  1.1080 -        free(allDevNameMap[i].name);
  1.1081 -        free(allDevNameMap[i].card);
  1.1082 -    }
  1.1083 -    free(allDevNameMap);
  1.1084 -    allDevNameMap = NULL;
  1.1085 -    numDevNames = 0;
  1.1086 -
  1.1087 -    for(i = 0;i < numCaptureDevNames;++i)
  1.1088 -    {
  1.1089 -        free(allCaptureDevNameMap[i].name);
  1.1090 -        free(allCaptureDevNameMap[i].card);
  1.1091 -    }
  1.1092 -    free(allCaptureDevNameMap);
  1.1093 -    allCaptureDevNameMap = NULL;
  1.1094 -    numCaptureDevNames = 0;
  1.1095 -
  1.1096 -#ifdef HAVE_DYNLOAD
  1.1097 -    if(alsa_handle)
  1.1098 -        CloseLib(alsa_handle);
  1.1099 -    alsa_handle = NULL;
  1.1100 -#endif
  1.1101 -}
  1.1102 -
  1.1103 -void alc_alsa_probe(enum DevProbe type)
  1.1104 -{
  1.1105 -    ALuint i;
  1.1106 -
  1.1107 -    switch(type)
  1.1108 -    {
  1.1109 -        case DEVICE_PROBE:
  1.1110 -            AppendDeviceList(alsaDevice);
  1.1111 -            break;
  1.1112 -
  1.1113 -        case ALL_DEVICE_PROBE:
  1.1114 -            for(i = 0;i < numDevNames;++i)
  1.1115 -            {
  1.1116 -                free(allDevNameMap[i].name);
  1.1117 -                free(allDevNameMap[i].card);
  1.1118 -            }
  1.1119 -
  1.1120 -            free(allDevNameMap);
  1.1121 -            allDevNameMap = probe_devices(SND_PCM_STREAM_PLAYBACK, &numDevNames);
  1.1122 -
  1.1123 -            for(i = 0;i < numDevNames;++i)
  1.1124 -                AppendAllDeviceList(allDevNameMap[i].name);
  1.1125 -            break;
  1.1126 -
  1.1127 -        case CAPTURE_DEVICE_PROBE:
  1.1128 -            for(i = 0;i < numCaptureDevNames;++i)
  1.1129 -            {
  1.1130 -                free(allCaptureDevNameMap[i].name);
  1.1131 -                free(allCaptureDevNameMap[i].card);
  1.1132 -            }
  1.1133 -
  1.1134 -            free(allCaptureDevNameMap);
  1.1135 -            allCaptureDevNameMap = probe_devices(SND_PCM_STREAM_CAPTURE, &numCaptureDevNames);
  1.1136 -
  1.1137 -            for(i = 0;i < numCaptureDevNames;++i)
  1.1138 -                AppendCaptureDeviceList(allCaptureDevNameMap[i].name);
  1.1139 -            break;
  1.1140 -    }
  1.1141 -}

     2.1 --- a/Alc/backends/coreaudio.c	Tue Oct 25 13:03:35 2011 -0700
     2.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.3 @@ -1,719 +0,0 @@
     2.4 -/**
     2.5 - * OpenAL cross platform audio library
     2.6 - * Copyright (C) 1999-2007 by authors.
     2.7 - * This library is free software; you can redistribute it and/or
     2.8 - *  modify it under the terms of the GNU Library General Public
     2.9 - *  License as published by the Free Software Foundation; either
    2.10 - *  version 2 of the License, or (at your option) any later version.
    2.11 - *
    2.12 - * This library is distributed in the hope that it will be useful,
    2.13 - *  but WITHOUT ANY WARRANTY; without even the implied warranty of
    2.14 - *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    2.15 - *  Library General Public License for more details.
    2.16 - *
    2.17 - * You should have received a copy of the GNU Library General Public
    2.18 - *  License along with this library; if not, write to the
    2.19 - *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    2.20 - *  Boston, MA  02111-1307, USA.
    2.21 - * Or go to http://www.gnu.org/copyleft/lgpl.html
    2.22 - */
    2.23 -
    2.24 -#include "config.h"
    2.25 -
    2.26 -#include <stdio.h>
    2.27 -#include <stdlib.h>
    2.28 -#include <string.h>
    2.29 -
    2.30 -#include "alMain.h"
    2.31 -#include "AL/al.h"
    2.32 -#include "AL/alc.h"
    2.33 -
    2.34 -#include <CoreServices/CoreServices.h>
    2.35 -#include <unistd.h>
    2.36 -#include <AudioUnit/AudioUnit.h>
    2.37 -#include <AudioToolbox/AudioToolbox.h>
    2.38 -
    2.39 -
    2.40 -typedef struct {
    2.41 -    AudioUnit audioUnit;
    2.42 -
    2.43 -    ALuint frameSize;
    2.44 -    ALdouble sampleRateRatio;              // Ratio of hardware sample rate / requested sample rate
    2.45 -    AudioStreamBasicDescription format;    // This is the OpenAL format as a CoreAudio ASBD
    2.46 -
    2.47 -    AudioConverterRef audioConverter;      // Sample rate converter if needed
    2.48 -    AudioBufferList *bufferList;           // Buffer for data coming from the input device
    2.49 -    ALCvoid *resampleBuffer;               // Buffer for returned RingBuffer data when resampling
    2.50 -
    2.51 -    RingBuffer *ring;
    2.52 -} ca_data;
    2.53 -
    2.54 -static const ALCchar ca_device[] = "CoreAudio Default";
    2.55 -
    2.56 -
    2.57 -static void destroy_buffer_list(AudioBufferList* list)
    2.58 -{
    2.59 -    if(list)
    2.60 -    {
    2.61 -        UInt32 i;
    2.62 -        for(i = 0;i < list->mNumberBuffers;i++)
    2.63 -            free(list->mBuffers[i].mData);
    2.64 -        free(list);
    2.65 -    }
    2.66 -}
    2.67 -
    2.68 -static AudioBufferList* allocate_buffer_list(UInt32 channelCount, UInt32 byteSize)
    2.69 -{
    2.70 -    AudioBufferList *list;
    2.71 -
    2.72 -    list = calloc(1, sizeof(AudioBufferList) + sizeof(AudioBuffer));
    2.73 -    if(list)
    2.74 -    {
    2.75 -        list->mNumberBuffers = 1;
    2.76 -
    2.77 -        list->mBuffers[0].mNumberChannels = channelCount;
    2.78 -        list->mBuffers[0].mDataByteSize = byteSize;
    2.79 -        list->mBuffers[0].mData = malloc(byteSize);
    2.80 -        if(list->mBuffers[0].mData == NULL)
    2.81 -        {
    2.82 -            free(list);
    2.83 -            list = NULL;
    2.84 -        }
    2.85 -    }
    2.86 -    return list;
    2.87 -}
    2.88 -
    2.89 -static OSStatus ca_callback(void *inRefCon, AudioUnitRenderActionFlags *ioActionFlags, const AudioTimeStamp *inTimeStamp,
    2.90 -                            UInt32 inBusNumber, UInt32 inNumberFrames, AudioBufferList *ioData)
    2.91 -{
    2.92 -    ALCdevice *device = (ALCdevice*)inRefCon;
    2.93 -    ca_data *data = (ca_data*)device->ExtraData;
    2.94 -
    2.95 -    aluMixData(device, ioData->mBuffers[0].mData,
    2.96 -               ioData->mBuffers[0].mDataByteSize / data->frameSize);
    2.97 -
    2.98 -    return noErr;
    2.99 -}
   2.100 -
   2.101 -static OSStatus ca_capture_conversion_callback(AudioConverterRef inAudioConverter, UInt32 *ioNumberDataPackets,
   2.102 -        AudioBufferList *ioData, AudioStreamPacketDescription **outDataPacketDescription, void* inUserData)
   2.103 -{
   2.104 -    ALCdevice *device = (ALCdevice*)inUserData;
   2.105 -    ca_data *data = (ca_data*)device->ExtraData;
   2.106 -
   2.107 -    // Read from the ring buffer and store temporarily in a large buffer
   2.108 -    ReadRingBuffer(data->ring, data->resampleBuffer, (ALsizei)(*ioNumberDataPackets));
   2.109 -
   2.110 -    // Set the input data
   2.111 -    ioData->mNumberBuffers = 1;
   2.112 -    ioData->mBuffers[0].mNumberChannels = data->format.mChannelsPerFrame;
   2.113 -    ioData->mBuffers[0].mData = data->resampleBuffer;
   2.114 -    ioData->mBuffers[0].mDataByteSize = (*ioNumberDataPackets) * data->format.mBytesPerFrame;
   2.115 -
   2.116 -    return noErr;
   2.117 -}
   2.118 -
   2.119 -static OSStatus ca_capture_callback(void *inRefCon, AudioUnitRenderActionFlags *ioActionFlags,
   2.120 -                                    const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber,
   2.121 -                                    UInt32 inNumberFrames, AudioBufferList *ioData)
   2.122 -{
   2.123 -    ALCdevice *device = (ALCdevice*)inRefCon;
   2.124 -    ca_data *data = (ca_data*)device->ExtraData;
   2.125 -    AudioUnitRenderActionFlags flags = 0;
   2.126 -    OSStatus err;
   2.127 -
   2.128 -    // fill the bufferList with data from the input device
   2.129 -    err = AudioUnitRender(data->audioUnit, &flags, inTimeStamp, 1, inNumberFrames, data->bufferList);
   2.130 -    if(err != noErr)
   2.131 -    {
   2.132 -        ERR("AudioUnitRender error: %d\n", err);
   2.133 -        return err;
   2.134 -    }
   2.135 -
   2.136 -    WriteRingBuffer(data->ring, data->bufferList->mBuffers[0].mData, inNumberFrames);
   2.137 -
   2.138 -    return noErr;
   2.139 -}
   2.140 -
   2.141 -static ALCboolean ca_open_playback(ALCdevice *device, const ALCchar *deviceName)
   2.142 -{
   2.143 -    ComponentDescription desc;
   2.144 -    Component comp;
   2.145 -    ca_data *data;
   2.146 -    OSStatus err;
   2.147 -
   2.148 -    if(!deviceName)
   2.149 -        deviceName = ca_device;
   2.150 -    else if(strcmp(deviceName, ca_device) != 0)
   2.151 -        return ALC_FALSE;
   2.152 -
   2.153 -    /* open the default output unit */
   2.154 -    desc.componentType = kAudioUnitType_Output;
   2.155 -    desc.componentSubType = kAudioUnitSubType_DefaultOutput;
   2.156 -    desc.componentManufacturer = kAudioUnitManufacturer_Apple;
   2.157 -    desc.componentFlags = 0;
   2.158 -    desc.componentFlagsMask = 0;
   2.159 -
   2.160 -    comp = FindNextComponent(NULL, &desc);
   2.161 -    if(comp == NULL)
   2.162 -    {
   2.163 -        ERR("FindNextComponent failed\n");
   2.164 -        return ALC_FALSE;
   2.165 -    }
   2.166 -
   2.167 -    data = calloc(1, sizeof(*data));
   2.168 -    device->ExtraData = data;
   2.169 -
   2.170 -    err = OpenAComponent(comp, &data->audioUnit);
   2.171 -    if(err != noErr)
   2.172 -    {
   2.173 -        ERR("OpenAComponent failed\n");
   2.174 -        free(data);
   2.175 -        device->ExtraData = NULL;
   2.176 -        return ALC_FALSE;
   2.177 -    }
   2.178 -
   2.179 -    return ALC_TRUE;
   2.180 -}
   2.181 -
   2.182 -static void ca_close_playback(ALCdevice *device)
   2.183 -{
   2.184 -    ca_data *data = (ca_data*)device->ExtraData;
   2.185 -
   2.186 -    CloseComponent(data->audioUnit);
   2.187 -
   2.188 -    free(data);
   2.189 -    device->ExtraData = NULL;
   2.190 -}
   2.191 -
   2.192 -static ALCboolean ca_reset_playback(ALCdevice *device)
   2.193 -{
   2.194 -    ca_data *data = (ca_data*)device->ExtraData;
   2.195 -    AudioStreamBasicDescription streamFormat;
   2.196 -    AURenderCallbackStruct input;
   2.197 -    OSStatus err;
   2.198 -    UInt32 size;
   2.199 -
   2.200 -    /* init and start the default audio unit... */
   2.201 -    err = AudioUnitInitialize(data->audioUnit);
   2.202 -    if(err != noErr)
   2.203 -    {
   2.204 -        ERR("AudioUnitInitialize failed\n");
   2.205 -        return ALC_FALSE;
   2.206 -    }
   2.207 -
   2.208 -    err = AudioOutputUnitStart(data->audioUnit);
   2.209 -    if(err != noErr)
   2.210 -    {
   2.211 -        ERR("AudioOutputUnitStart failed\n");
   2.212 -        return ALC_FALSE;
   2.213 -    }
   2.214 -
   2.215 -    /* retrieve default output unit's properties (output side) */
   2.216 -    size = sizeof(AudioStreamBasicDescription);
   2.217 -    err = AudioUnitGetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 0, &streamFormat, &size);
   2.218 -    if(err != noErr || size != sizeof(AudioStreamBasicDescription))
   2.219 -    {
   2.220 -        ERR("AudioUnitGetProperty failed\n");
   2.221 -        return ALC_FALSE;
   2.222 -    }
   2.223 -
   2.224 -#if 0
   2.225 -    TRACE("Output streamFormat of default output unit -\n");
   2.226 -    TRACE("  streamFormat.mFramesPerPacket = %d\n", streamFormat.mFramesPerPacket);
   2.227 -    TRACE("  streamFormat.mChannelsPerFrame = %d\n", streamFormat.mChannelsPerFrame);
   2.228 -    TRACE("  streamFormat.mBitsPerChannel = %d\n", streamFormat.mBitsPerChannel);
   2.229 -    TRACE("  streamFormat.mBytesPerPacket = %d\n", streamFormat.mBytesPerPacket);
   2.230 -    TRACE("  streamFormat.mBytesPerFrame = %d\n", streamFormat.mBytesPerFrame);
   2.231 -    TRACE("  streamFormat.mSampleRate = %5.0f\n", streamFormat.mSampleRate);
   2.232 -#endif
   2.233 -
   2.234 -    /* set default output unit's input side to match output side */
   2.235 -    err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &streamFormat, size);
   2.236 -    if(err != noErr)
   2.237 -    {
   2.238 -        ERR("AudioUnitSetProperty failed\n");
   2.239 -        return ALC_FALSE;
   2.240 -    }
   2.241 -
   2.242 -    if(device->Frequency != streamFormat.mSampleRate)
   2.243 -    {
   2.244 -        if((device->Flags&DEVICE_FREQUENCY_REQUEST))
   2.245 -            ERR("CoreAudio does not support changing sample rates (wanted %dhz, got %dhz)\n", device->Frequency, streamFormat.mSampleRate);
   2.246 -        device->Flags &= ~DEVICE_FREQUENCY_REQUEST;
   2.247 -
   2.248 -        device->UpdateSize = (ALuint)((ALuint64)device->UpdateSize *
   2.249 -                                      streamFormat.mSampleRate /
   2.250 -                                      device->Frequency);
   2.251 -        device->Frequency = streamFormat.mSampleRate;
   2.252 -    }
   2.253 -
   2.254 -    /* FIXME: How to tell what channels are what in the output device, and how
   2.255 -     * to specify what we're giving?  eg, 6.0 vs 5.1 */
   2.256 -    switch(streamFormat.mChannelsPerFrame)
   2.257 -    {
   2.258 -        case 1:
   2.259 -            if((device->Flags&DEVICE_CHANNELS_REQUEST) &&
   2.260 -               device->FmtChans != DevFmtMono)
   2.261 -            {
   2.262 -                ERR("Failed to set %s, got Mono instead\n", DevFmtChannelsString(device->FmtChans));
   2.263 -                device->Flags &= ~DEVICE_CHANNELS_REQUEST;
   2.264 -            }
   2.265 -            device->FmtChans = DevFmtMono;
   2.266 -            break;
   2.267 -        case 2:
   2.268 -            if((device->Flags&DEVICE_CHANNELS_REQUEST) &&
   2.269 -               device->FmtChans != DevFmtStereo)
   2.270 -            {
   2.271 -                ERR("Failed to set %s, got Stereo instead\n", DevFmtChannelsString(device->FmtChans));
   2.272 -                device->Flags &= ~DEVICE_CHANNELS_REQUEST;
   2.273 -            }
   2.274 -            device->FmtChans = DevFmtStereo;
   2.275 -            break;
   2.276 -        case 4:
   2.277 -            if((device->Flags&DEVICE_CHANNELS_REQUEST) &&
   2.278 -               device->FmtChans != DevFmtQuad)
   2.279 -            {
   2.280 -                ERR("Failed to set %s, got Quad instead\n", DevFmtChannelsString(device->FmtChans));
   2.281 -                device->Flags &= ~DEVICE_CHANNELS_REQUEST;
   2.282 -            }
   2.283 -            device->FmtChans = DevFmtQuad;
   2.284 -            break;
   2.285 -        case 6:
   2.286 -            if((device->Flags&DEVICE_CHANNELS_REQUEST) &&
   2.287 -               device->FmtChans != DevFmtX51)
   2.288 -            {
   2.289 -                ERR("Failed to set %s, got 5.1 Surround instead\n", DevFmtChannelsString(device->FmtChans));
   2.290 -                device->Flags &= ~DEVICE_CHANNELS_REQUEST;
   2.291 -            }
   2.292 -            device->FmtChans = DevFmtX51;
   2.293 -            break;
   2.294 -        case 7:
   2.295 -            if((device->Flags&DEVICE_CHANNELS_REQUEST) &&
   2.296 -               device->FmtChans != DevFmtX61)
   2.297 -            {
   2.298 -                ERR("Failed to set %s, got 6.1 Surround instead\n", DevFmtChannelsString(device->FmtChans));
   2.299 -                device->Flags &= ~DEVICE_CHANNELS_REQUEST;
   2.300 -            }
   2.301 -            device->FmtChans = DevFmtX61;
   2.302 -            break;
   2.303 -        case 8:
   2.304 -            if((device->Flags&DEVICE_CHANNELS_REQUEST) &&
   2.305 -               device->FmtChans != DevFmtX71)
   2.306 -            {
   2.307 -                ERR("Failed to set %s, got 7.1 Surround instead\n", DevFmtChannelsString(device->FmtChans));
   2.308 -                device->Flags &= ~DEVICE_CHANNELS_REQUEST;
   2.309 -            }
   2.310 -            device->FmtChans = DevFmtX71;
   2.311 -            break;
   2.312 -        default:
   2.313 -            ERR("Unhandled channel count (%d), using Stereo\n", streamFormat.mChannelsPerFrame);
   2.314 -            device->Flags &= ~DEVICE_CHANNELS_REQUEST;
   2.315 -            device->FmtChans = DevFmtStereo;
   2.316 -            streamFormat.mChannelsPerFrame = 2;
   2.317 -            break;
   2.318 -    }
   2.319 -    SetDefaultWFXChannelOrder(device);
   2.320 -
   2.321 -    /* use channel count and sample rate from the default output unit's current
   2.322 -     * parameters, but reset everything else */
   2.323 -    streamFormat.mFramesPerPacket = 1;
   2.324 -    switch(device->FmtType)
   2.325 -    {
   2.326 -        case DevFmtUByte:
   2.327 -            device->FmtType = DevFmtByte;
   2.328 -            /* fall-through */
   2.329 -        case DevFmtByte:
   2.330 -            streamFormat.mBitsPerChannel = 8;
   2.331 -            streamFormat.mBytesPerPacket = streamFormat.mChannelsPerFrame;
   2.332 -            streamFormat.mBytesPerFrame = streamFormat.mChannelsPerFrame;
   2.333 -            break;
   2.334 -        case DevFmtUShort:
   2.335 -        case DevFmtFloat:
   2.336 -            device->FmtType = DevFmtShort;
   2.337 -            /* fall-through */
   2.338 -        case DevFmtShort:
   2.339 -            streamFormat.mBitsPerChannel = 16;
   2.340 -            streamFormat.mBytesPerPacket = 2 * streamFormat.mChannelsPerFrame;
   2.341 -            streamFormat.mBytesPerFrame = 2 * streamFormat.mChannelsPerFrame;
   2.342 -            break;
   2.343 -    }
   2.344 -    streamFormat.mFormatID = kAudioFormatLinearPCM;
   2.345 -    streamFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger |
   2.346 -                                kAudioFormatFlagsNativeEndian |
   2.347 -                                kLinearPCMFormatFlagIsPacked;
   2.348 -
   2.349 -    err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &streamFormat, sizeof(AudioStreamBasicDescription));
   2.350 -    if(err != noErr)
   2.351 -    {
   2.352 -        ERR("AudioUnitSetProperty failed\n");
   2.353 -        return ALC_FALSE;
   2.354 -    }
   2.355 -
   2.356 -    /* setup callback */
   2.357 -    data->frameSize = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
   2.358 -    input.inputProc = ca_callback;
   2.359 -    input.inputProcRefCon = device;
   2.360 -
   2.361 -    err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &input, sizeof(AURenderCallbackStruct));
   2.362 -    if(err != noErr)
   2.363 -    {
   2.364 -        ERR("AudioUnitSetProperty failed\n");
   2.365 -        return ALC_FALSE;
   2.366 -    }
   2.367 -
   2.368 -    return ALC_TRUE;
   2.369 -}
   2.370 -
   2.371 -static void ca_stop_playback(ALCdevice *device)
   2.372 -{
   2.373 -    ca_data *data = (ca_data*)device->ExtraData;
   2.374 -    OSStatus err;
   2.375 -
   2.376 -    AudioOutputUnitStop(data->audioUnit);
   2.377 -    err = AudioUnitUninitialize(data->audioUnit);
   2.378 -    if(err != noErr)
   2.379 -        ERR("-- AudioUnitUninitialize failed.\n");
   2.380 -}
   2.381 -
   2.382 -static ALCboolean ca_open_capture(ALCdevice *device, const ALCchar *deviceName)
   2.383 -{
   2.384 -    AudioStreamBasicDescription requestedFormat;  // The application requested format
   2.385 -    AudioStreamBasicDescription hardwareFormat;   // The hardware format
   2.386 -    AudioStreamBasicDescription outputFormat;     // The AudioUnit output format
   2.387 -    AURenderCallbackStruct input;
   2.388 -    ComponentDescription desc;
   2.389 -    AudioDeviceID inputDevice;
   2.390 -    UInt32 outputFrameCount;
   2.391 -    UInt32 propertySize;
   2.392 -    UInt32 enableIO;
   2.393 -    Component comp;
   2.394 -    ca_data *data;
   2.395 -    OSStatus err;
   2.396 -
   2.397 -    desc.componentType = kAudioUnitType_Output;
   2.398 -    desc.componentSubType = kAudioUnitSubType_HALOutput;
   2.399 -    desc.componentManufacturer = kAudioUnitManufacturer_Apple;
   2.400 -    desc.componentFlags = 0;
   2.401 -    desc.componentFlagsMask = 0;
   2.402 -
   2.403 -    // Search for component with given description
   2.404 -    comp = FindNextComponent(NULL, &desc);
   2.405 -    if(comp == NULL)
   2.406 -    {
   2.407 -        ERR("FindNextComponent failed\n");
   2.408 -        return ALC_FALSE;
   2.409 -    }
   2.410 -
   2.411 -    data = calloc(1, sizeof(*data));
   2.412 -    device->ExtraData = data;
   2.413 -
   2.414 -    // Open the component
   2.415 -    err = OpenAComponent(comp, &data->audioUnit);
   2.416 -    if(err != noErr)
   2.417 -    {
   2.418 -        ERR("OpenAComponent failed\n");
   2.419 -        goto error;
   2.420 -    }
   2.421 -
   2.422 -    // Turn off AudioUnit output
   2.423 -    enableIO = 0;
   2.424 -    err = AudioUnitSetProperty(data->audioUnit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output, 0, &enableIO, sizeof(ALuint));
   2.425 -    if(err != noErr)
   2.426 -    {
   2.427 -        ERR("AudioUnitSetProperty failed\n");
   2.428 -        goto error;
   2.429 -    }
   2.430 -
   2.431 -    // Turn on AudioUnit input
   2.432 -    enableIO = 1;
   2.433 -    err = AudioUnitSetProperty(data->audioUnit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, 1, &enableIO, sizeof(ALuint));
   2.434 -    if(err != noErr)
   2.435 -    {
   2.436 -        ERR("AudioUnitSetProperty failed\n");
   2.437 -        goto error;
   2.438 -    }
   2.439 -
   2.440 -    // Get the default input device
   2.441 -    propertySize = sizeof(AudioDeviceID);
   2.442 -    err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &propertySize, &inputDevice);
   2.443 -    if(err != noErr)
   2.444 -    {
   2.445 -        ERR("AudioHardwareGetProperty failed\n");
   2.446 -        goto error;
   2.447 -    }
   2.448 -
   2.449 -    if(inputDevice == kAudioDeviceUnknown)
   2.450 -    {
   2.451 -        ERR("No input device found\n");
   2.452 -        goto error;
   2.453 -    }
   2.454 -
   2.455 -    // Track the input device
   2.456 -    err = AudioUnitSetProperty(data->audioUnit, kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, 0, &inputDevice, sizeof(AudioDeviceID));
   2.457 -    if(err != noErr)
   2.458 -    {
   2.459 -        ERR("AudioUnitSetProperty failed\n");
   2.460 -        goto error;
   2.461 -    }
   2.462 -
   2.463 -    // set capture callback
   2.464 -    input.inputProc = ca_capture_callback;
   2.465 -    input.inputProcRefCon = device;
   2.466 -
   2.467 -    err = AudioUnitSetProperty(data->audioUnit, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 0, &input, sizeof(AURenderCallbackStruct));
   2.468 -    if(err != noErr)
   2.469 -    {
   2.470 -        ERR("AudioUnitSetProperty failed\n");
   2.471 -        goto error;
   2.472 -    }
   2.473 -
   2.474 -    // Initialize the device
   2.475 -    err = AudioUnitInitialize(data->audioUnit);
   2.476 -    if(err != noErr)
   2.477 -    {
   2.478 -        ERR("AudioUnitInitialize failed\n");
   2.479 -        goto error;
   2.480 -    }
   2.481 -
   2.482 -    // Get the hardware format
   2.483 -    propertySize = sizeof(AudioStreamBasicDescription);
   2.484 -    err = AudioUnitGetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 1, &hardwareFormat, &propertySize);
   2.485 -    if(err != noErr || propertySize != sizeof(AudioStreamBasicDescription))
   2.486 -    {
   2.487 -        ERR("AudioUnitGetProperty failed\n");
   2.488 -        goto error;
   2.489 -    }
   2.490 -
   2.491 -    // Set up the requested format description
   2.492 -    switch(device->FmtType)
   2.493 -    {
   2.494 -        case DevFmtUByte:
   2.495 -            requestedFormat.mBitsPerChannel = 8;
   2.496 -            requestedFormat.mFormatFlags = kAudioFormatFlagIsPacked;
   2.497 -            break;
   2.498 -        case DevFmtShort:
   2.499 -            requestedFormat.mBitsPerChannel = 16;
   2.500 -            requestedFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
   2.501 -            break;
   2.502 -        case DevFmtFloat:
   2.503 -            requestedFormat.mBitsPerChannel = 32;
   2.504 -            requestedFormat.mFormatFlags = kAudioFormatFlagIsPacked;
   2.505 -            break;
   2.506 -        case DevFmtByte:
   2.507 -        case DevFmtUShort:
   2.508 -            ERR("%s samples not supported\n", DevFmtTypeString(device->FmtType));
   2.509 -            goto error;
   2.510 -    }
   2.511 -
   2.512 -    switch(device->FmtChans)
   2.513 -    {
   2.514 -        case DevFmtMono:
   2.515 -            requestedFormat.mChannelsPerFrame = 1;
   2.516 -            break;
   2.517 -        case DevFmtStereo:
   2.518 -            requestedFormat.mChannelsPerFrame = 2;
   2.519 -            break;
   2.520 -
   2.521 -        case DevFmtQuad:
   2.522 -        case DevFmtX51:
   2.523 -        case DevFmtX51Side:
   2.524 -        case DevFmtX61:
   2.525 -        case DevFmtX71:
   2.526 -            ERR("%s not supported\n", DevFmtChannelsString(device->FmtChans));
   2.527 -            goto error;
   2.528 -    }
   2.529 -
   2.530 -    requestedFormat.mBytesPerFrame = requestedFormat.mChannelsPerFrame * requestedFormat.mBitsPerChannel / 8;
   2.531 -    requestedFormat.mBytesPerPacket = requestedFormat.mBytesPerFrame;
   2.532 -    requestedFormat.mSampleRate = device->Frequency;
   2.533 -    requestedFormat.mFormatID = kAudioFormatLinearPCM;
   2.534 -    requestedFormat.mReserved = 0;
   2.535 -    requestedFormat.mFramesPerPacket = 1;
   2.536 -
   2.537 -    // save requested format description for later use
   2.538 -    data->format = requestedFormat;
   2.539 -    data->frameSize = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
   2.540 -
   2.541 -    // Use intermediate format for sample rate conversion (outputFormat)
   2.542 -    // Set sample rate to the same as hardware for resampling later
   2.543 -    outputFormat = requestedFormat;
   2.544 -    outputFormat.mSampleRate = hardwareFormat.mSampleRate;
   2.545 -
   2.546 -    // Determine sample rate ratio for resampling
   2.547 -    data->sampleRateRatio = outputFormat.mSampleRate / device->Frequency;
   2.548 -
   2.549 -    // The output format should be the requested format, but using the hardware sample rate
   2.550 -    // This is because the AudioUnit will automatically scale other properties, except for sample rate
   2.551 -    err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, (void *)&outputFormat, sizeof(outputFormat));
   2.552 -    if(err != noErr)
   2.553 -    {
   2.554 -        ERR("AudioUnitSetProperty failed\n");
   2.555 -        goto error;
   2.556 -    }
   2.557 -
   2.558 -    // Set the AudioUnit output format frame count
   2.559 -    outputFrameCount = device->UpdateSize * data->sampleRateRatio;
   2.560 -    err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Output, 0, &outputFrameCount, sizeof(outputFrameCount));
   2.561 -    if(err != noErr)
   2.562 -    {
   2.563 -        ERR("AudioUnitSetProperty failed: %d\n", err);
   2.564 -        goto error;
   2.565 -    }
   2.566 -
   2.567 -    // Set up sample converter
   2.568 -    err = AudioConverterNew(&outputFormat, &requestedFormat, &data->audioConverter);
   2.569 -    if(err != noErr)
   2.570 -    {
   2.571 -        ERR("AudioConverterNew failed: %d\n", err);
   2.572 -        goto error;
   2.573 -    }
   2.574 -
   2.575 -    // Create a buffer for use in the resample callback
   2.576 -    data->resampleBuffer = malloc(device->UpdateSize * data->frameSize * data->sampleRateRatio);
   2.577 -
   2.578 -    // Allocate buffer for the AudioUnit output
   2.579 -    data->bufferList = allocate_buffer_list(outputFormat.mChannelsPerFrame, device->UpdateSize * data->frameSize * data->sampleRateRatio);
   2.580 -    if(data->bufferList == NULL)
   2.581 -    {
   2.582 -        alcSetError(device, ALC_OUT_OF_MEMORY);
   2.583 -        goto error;
   2.584 -    }
   2.585 -
   2.586 -    data->ring = CreateRingBuffer(data->frameSize, (device->UpdateSize * data->sampleRateRatio) * device->NumUpdates);
   2.587 -    if(data->ring == NULL)
   2.588 -    {
   2.589 -        alcSetError(device, ALC_OUT_OF_MEMORY);
   2.590 -        goto error;
   2.591 -    }
   2.592 -
   2.593 -    return ALC_TRUE;
   2.594 -
   2.595 -error:
   2.596 -    DestroyRingBuffer(data->ring);
   2.597 -    free(data->resampleBuffer);
   2.598 -    destroy_buffer_list(data->bufferList);
   2.599 -
   2.600 -    if(data->audioConverter)
   2.601 -        AudioConverterDispose(data->audioConverter);
   2.602 -    if(data->audioUnit)
   2.603 -        CloseComponent(data->audioUnit);
   2.604 -
   2.605 -    free(data);
   2.606 -    device->ExtraData = NULL;
   2.607 -
   2.608 -    return ALC_FALSE;
   2.609 -}
   2.610 -
   2.611 -static void ca_close_capture(ALCdevice *device)
   2.612 -{
   2.613 -    ca_data *data = (ca_data*)device->ExtraData;
   2.614 -
   2.615 -    DestroyRingBuffer(data->ring);
   2.616 -    free(data->resampleBuffer);
   2.617 -    destroy_buffer_list(data->bufferList);
   2.618 -
   2.619 -    AudioConverterDispose(data->audioConverter);
   2.620 -    CloseComponent(data->audioUnit);
   2.621 -
   2.622 -    free(data);
   2.623 -    device->ExtraData = NULL;
   2.624 -}
   2.625 -
   2.626 -static void ca_start_capture(ALCdevice *device)
   2.627 -{
   2.628 -    ca_data *data = (ca_data*)device->ExtraData;
   2.629 -    OSStatus err = AudioOutputUnitStart(data->audioUnit);
   2.630 -    if(err != noErr)
   2.631 -        ERR("AudioOutputUnitStart failed\n");
   2.632 -}
   2.633 -
   2.634 -static void ca_stop_capture(ALCdevice *device)
   2.635 -{
   2.636 -    ca_data *data = (ca_data*)device->ExtraData;
   2.637 -    OSStatus err = AudioOutputUnitStop(data->audioUnit);
   2.638 -    if(err != noErr)
   2.639 -        ERR("AudioOutputUnitStop failed\n");
   2.640 -}
   2.641 -
   2.642 -static ALCuint ca_available_samples(ALCdevice *device)
   2.643 -{
   2.644 -    ca_data *data = device->ExtraData;
   2.645 -    return RingBufferSize(data->ring) / data->sampleRateRatio;
   2.646 -}
   2.647 -
   2.648 -static void ca_capture_samples(ALCdevice *device, ALCvoid *buffer, ALCuint samples)
   2.649 -{
   2.650 -    ca_data *data = (ca_data*)device->ExtraData;
   2.651 -
   2.652 -    if(samples <= ca_available_samples(device))
   2.653 -    {
   2.654 -        AudioBufferList *list;
   2.655 -        UInt32 frameCount;
   2.656 -        OSStatus err;
   2.657 -
   2.658 -        // If no samples are requested, just return
   2.659 -        if(samples == 0)
   2.660 -            return;
   2.661 -
   2.662 -        // Allocate a temporary AudioBufferList to use as the return resamples data
   2.663 -        list = alloca(sizeof(AudioBufferList) + sizeof(AudioBuffer));
   2.664 -
   2.665 -        // Point the resampling buffer to the capture buffer
   2.666 -        list->mNumberBuffers = 1;
   2.667 -        list->mBuffers[0].mNumberChannels = data->format.mChannelsPerFrame;
   2.668 -        list->mBuffers[0].mDataByteSize = samples * data->frameSize;
   2.669 -        list->mBuffers[0].mData = buffer;
   2.670 -
   2.671 -        // Resample into another AudioBufferList
   2.672 -        frameCount = samples;
   2.673 -        err = AudioConverterFillComplexBuffer(data->audioConverter, ca_capture_conversion_callback, device,
   2.674 -                                              &frameCount, list, NULL);
   2.675 -        if(err != noErr)
   2.676 -        {
   2.677 -            ERR("AudioConverterFillComplexBuffer error: %d\n", err);
   2.678 -            alcSetError(device, ALC_INVALID_VALUE);
   2.679 -        }
   2.680 -    }
   2.681 -    else
   2.682 -        alcSetError(device, ALC_INVALID_VALUE);
   2.683 -}
   2.684 -
   2.685 -static const BackendFuncs ca_funcs = {
   2.686 -    ca_open_playback,
   2.687 -    ca_close_playback,
   2.688 -    ca_reset_playback,
   2.689 -    ca_stop_playback,
   2.690 -    ca_open_capture,
   2.691 -    ca_close_capture,
   2.692 -    ca_start_capture,
   2.693 -    ca_stop_capture,
   2.694 -    ca_capture_samples,
   2.695 -    ca_available_samples
   2.696 -};
   2.697 -
   2.698 -ALCboolean alc_ca_init(BackendFuncs *func_list)
   2.699 -{
   2.700 -    *func_list = ca_funcs;
   2.701 -    return ALC_TRUE;
   2.702 -}
   2.703 -
   2.704 -void alc_ca_deinit(void)
   2.705 -{
   2.706 -}
   2.707 -
   2.708 -void alc_ca_probe(enum DevProbe type)
   2.709 -{
   2.710 -    switch(type)
   2.711 -    {
   2.712 -        case DEVICE_PROBE:
   2.713 -            AppendDeviceList(ca_device);
   2.714 -            break;
   2.715 -        case ALL_DEVICE_PROBE:
   2.716 -            AppendAllDeviceList(ca_device);
   2.717 -            break;
   2.718 -        case CAPTURE_DEVICE_PROBE:
   2.719 -            AppendCaptureDeviceList(ca_device);
   2.720 -            break;
   2.721 -    }
   2.722 -}

     3.1 --- a/Alc/backends/dsound.c	Tue Oct 25 13:03:35 2011 -0700
     3.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.3 @@ -1,614 +0,0 @@
     3.4 -/**
     3.5 - * OpenAL cross platform audio library
     3.6 - * Copyright (C) 1999-2007 by authors.
     3.7 - * This library is free software; you can redistribute it and/or
     3.8 - *  modify it under the terms of the GNU Library General Public
     3.9 - *  License as published by the Free Software Foundation; either
    3.10 - *  version 2 of the License, or (at your option) any later version.
    3.11 - *
    3.12 - * This library is distributed in the hope that it will be useful,
    3.13 - *  but WITHOUT ANY WARRANTY; without even the implied warranty of
    3.14 - *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    3.15 - *  Library General Public License for more details.
    3.16 - *
    3.17 - * You should have received a copy of the GNU Library General Public
    3.18 - *  License along with this library; if not, write to the
    3.19 - *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    3.20 - *  Boston, MA  02111-1307, USA.
    3.21 - * Or go to http://www.gnu.org/copyleft/lgpl.html
    3.22 - */
    3.23 -
    3.24 -#include "config.h"
    3.25 -
    3.26 -#define _WIN32_WINNT 0x0500
    3.27 -#include <stdlib.h>
    3.28 -#include <stdio.h>
    3.29 -#include <memory.h>
    3.30 -
    3.31 -#include <dsound.h>
    3.32 -#include <cguid.h>
    3.33 -#include <mmreg.h>
    3.34 -#ifndef _WAVEFORMATEXTENSIBLE_
    3.35 -#include <ks.h>
    3.36 -#include <ksmedia.h>
    3.37 -#endif
    3.38 -
    3.39 -#include "alMain.h"
    3.40 -#include "AL/al.h"
    3.41 -#include "AL/alc.h"
    3.42 -
    3.43 -#ifndef DSSPEAKER_5POINT1
    3.44 -#define DSSPEAKER_5POINT1       6
    3.45 -#endif
    3.46 -#ifndef DSSPEAKER_7POINT1
    3.47 -#define DSSPEAKER_7POINT1       7
    3.48 -#endif
    3.49 -
    3.50 -DEFINE_GUID(KSDATAFORMAT_SUBTYPE_PCM, 0x00000001, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
    3.51 -DEFINE_GUID(KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, 0x00000003, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
    3.52 -
    3.53 -
    3.54 -static HMODULE ds_handle;
    3.55 -static HRESULT (WINAPI *pDirectSoundCreate)(LPCGUID pcGuidDevice, IDirectSound **ppDS, IUnknown *pUnkOuter);
    3.56 -static HRESULT (WINAPI *pDirectSoundEnumerateA)(LPDSENUMCALLBACKA pDSEnumCallback, void *pContext);
    3.57 -
    3.58 -#define DirectSoundCreate     pDirectSoundCreate
    3.59 -#define DirectSoundEnumerateA pDirectSoundEnumerateA
    3.60 -
    3.61 -
    3.62 -typedef struct {
    3.63 -    // DirectSound Playback Device
    3.64 -    IDirectSound       *lpDS;
    3.65 -    IDirectSoundBuffer *DSpbuffer;
    3.66 -    IDirectSoundBuffer *DSsbuffer;
    3.67 -    IDirectSoundNotify *DSnotify;
    3.68 -    HANDLE             hNotifyEvent;
    3.69 -
    3.70 -    volatile int killNow;
    3.71 -    ALvoid *thread;
    3.72 -} DSoundData;
    3.73 -
    3.74 -
    3.75 -typedef struct {
    3.76 -    ALCchar *name;
    3.77 -    GUID guid;
    3.78 -} DevMap;
    3.79 -
    3.80 -static const ALCchar dsDevice[] = "DirectSound Default";
    3.81 -static DevMap *DeviceList;
    3.82 -static ALuint NumDevices;
    3.83 -
    3.84 -#define MAX_UPDATES 128
    3.85 -
    3.86 -static ALCboolean DSoundLoad(void)
    3.87 -{
    3.88 -    ALCboolean ok = ALC_TRUE;
    3.89 -    if(!ds_handle)
    3.90 -    {
    3.91 -        ds_handle = LoadLibraryA("dsound.dll");
    3.92 -        if(ds_handle == NULL)
    3.93 -        {
    3.94 -            ERR("Failed to load dsound.dll\n");
    3.95 -            return ALC_FALSE;
    3.96 -        }
    3.97 -
    3.98 -#define LOAD_FUNC(x) do {                                                     \
    3.99 -    if((p##x = (void*)GetProcAddress(ds_handle, #x)) == NULL) {               \
   3.100 -        ERR("Could not load %s from dsound.dll\n", #x);                       \
   3.101 -        ok = ALC_FALSE;                                                       \
   3.102 -    }                                                                         \
   3.103 -} while(0)
   3.104 -        LOAD_FUNC(DirectSoundCreate);
   3.105 -        LOAD_FUNC(DirectSoundEnumerateA);
   3.106 -#undef LOAD_FUNC
   3.107 -
   3.108 -        if(!ok)
   3.109 -        {
   3.110 -            FreeLibrary(ds_handle);
   3.111 -            ds_handle = NULL;
   3.112 -        }
   3.113 -    }
   3.114 -    return ok;
   3.115 -}
   3.116 -
   3.117 -
   3.118 -static BOOL CALLBACK DSoundEnumDevices(LPGUID guid, LPCSTR desc, LPCSTR drvname, LPVOID data)
   3.119 -{
   3.120 -    char str[1024];
   3.121 -    void *temp;
   3.122 -    int count;
   3.123 -    ALuint i;
   3.124 -
   3.125 -    (void)data;
   3.126 -    (void)drvname;
   3.127 -
   3.128 -    if(!guid)
   3.129 -        return TRUE;
   3.130 -
   3.131 -    count = 0;
   3.132 -    do {
   3.133 -        if(count == 0)
   3.134 -            snprintf(str, sizeof(str), "%s", desc);
   3.135 -        else
   3.136 -            snprintf(str, sizeof(str), "%s #%d", desc, count+1);
   3.137 -        count++;
   3.138 -
   3.139 -        for(i = 0;i < NumDevices;i++)
   3.140 -        {
   3.141 -            if(strcmp(str, DeviceList[i].name) == 0)
   3.142 -                break;
   3.143 -        }
   3.144 -    } while(i != NumDevices);
   3.145 -
   3.146 -    temp = realloc(DeviceList, sizeof(DevMap) * (NumDevices+1));
   3.147 -    if(temp)
   3.148 -    {
   3.149 -        DeviceList = temp;
   3.150 -        DeviceList[NumDevices].name = strdup(str);
   3.151 -        DeviceList[NumDevices].guid = *guid;
   3.152 -        NumDevices++;
   3.153 -    }
   3.154 -
   3.155 -    return TRUE;
   3.156 -}
   3.157 -
   3.158 -
   3.159 -static ALuint DSoundProc(ALvoid *ptr)
   3.160 -{
   3.161 -    ALCdevice *pDevice = (ALCdevice*)ptr;
   3.162 -    DSoundData *pData = (DSoundData*)pDevice->ExtraData;
   3.163 -    DSBCAPS DSBCaps;
   3.164 -    DWORD LastCursor = 0;
   3.165 -    DWORD PlayCursor;
   3.166 -    VOID *WritePtr1, *WritePtr2;
   3.167 -    DWORD WriteCnt1,  WriteCnt2;
   3.168 -    BOOL Playing = FALSE;
   3.169 -    DWORD FrameSize;
   3.170 -    DWORD FragSize;
   3.171 -    DWORD avail;
   3.172 -    HRESULT err;
   3.173 -
   3.174 -    SetRTPriority();
   3.175 -
   3.176 -    memset(&DSBCaps, 0, sizeof(DSBCaps));
   3.177 -    DSBCaps.dwSize = sizeof(DSBCaps);
   3.178 -    err = IDirectSoundBuffer_GetCaps(pData->DSsbuffer, &DSBCaps);
   3.179 -    if(FAILED(err))
   3.180 -    {
   3.181 -        ERR("Failed to get buffer caps: 0x%lx\n", err);
   3.182 -        aluHandleDisconnect(pDevice);
   3.183 -        return 1;
   3.184 -    }
   3.185 -
   3.186 -    FrameSize = FrameSizeFromDevFmt(pDevice->FmtChans, pDevice->FmtType);
   3.187 -    FragSize = pDevice->UpdateSize * FrameSize;
   3.188 -
   3.189 -    IDirectSoundBuffer_GetCurrentPosition(pData->DSsbuffer, &LastCursor, NULL);
   3.190 -    while(!pData->killNow)
   3.191 -    {
   3.192 -        // Get current play cursor
   3.193 -        IDirectSoundBuffer_GetCurrentPosition(pData->DSsbuffer, &PlayCursor, NULL);
   3.194 -        avail = (PlayCursor-LastCursor+DSBCaps.dwBufferBytes) % DSBCaps.dwBufferBytes;
   3.195 -
   3.196 -        if(avail < FragSize)
   3.197 -        {
   3.198 -            if(!Playing)
   3.199 -            {
   3.200 -                err = IDirectSoundBuffer_Play(pData->DSsbuffer, 0, 0, DSBPLAY_LOOPING);
   3.201 -                if(FAILED(err))
   3.202 -                {
   3.203 -                    ERR("Failed to play buffer: 0x%lx\n", err);
   3.204 -                    aluHandleDisconnect(pDevice);
   3.205 -                    return 1;
   3.206 -                }
   3.207 -                Playing = TRUE;
   3.208 -            }
   3.209 -
   3.210 -            avail = WaitForSingleObjectEx(pData->hNotifyEvent, 2000, FALSE);
   3.211 -            if(avail != WAIT_OBJECT_0)
   3.212 -                ERR("WaitForSingleObjectEx error: 0x%lx\n", avail);
   3.213 -            continue;
   3.214 -        }
   3.215 -        avail -= avail%FragSize;
   3.216 -
   3.217 -        // Lock output buffer
   3.218 -        WriteCnt1 = 0;
   3.219 -        WriteCnt2 = 0;
   3.220 -        err = IDirectSoundBuffer_Lock(pData->DSsbuffer, LastCursor, avail, &WritePtr1, &WriteCnt1, &WritePtr2, &WriteCnt2, 0);
   3.221 -
   3.222 -        // If the buffer is lost, restore it and lock
   3.223 -        if(err == DSERR_BUFFERLOST)
   3.224 -        {
   3.225 -            WARN("Buffer lost, restoring...\n");
   3.226 -            err = IDirectSoundBuffer_Restore(pData->DSsbuffer);
   3.227 -            if(SUCCEEDED(err))
   3.228 -            {
   3.229 -                Playing = FALSE;
   3.230 -                LastCursor = 0;
   3.231 -                err = IDirectSoundBuffer_Lock(pData->DSsbuffer, 0, DSBCaps.dwBufferBytes, &WritePtr1, &WriteCnt1, &WritePtr2, &WriteCnt2, 0);
   3.232 -            }
   3.233 -        }
   3.234 -
   3.235 -        // Successfully locked the output buffer
   3.236 -        if(SUCCEEDED(err))
   3.237 -        {
   3.238 -            // If we have an active context, mix data directly into output buffer otherwise fill with silence
   3.239 -            aluMixData(pDevice, WritePtr1, WriteCnt1/FrameSize);
   3.240 -            aluMixData(pDevice, WritePtr2, WriteCnt2/FrameSize);
   3.241 -
   3.242 -            // Unlock output buffer only when successfully locked
   3.243 -            IDirectSoundBuffer_Unlock(pData->DSsbuffer, WritePtr1, WriteCnt1, WritePtr2, WriteCnt2);
   3.244 -        }
   3.245 -        else
   3.246 -        {
   3.247 -            ERR("Buffer lock error: %#lx\n", err);
   3.248 -            aluHandleDisconnect(pDevice);
   3.249 -            return 1;
   3.250 -        }
   3.251 -
   3.252 -        // Update old write cursor location
   3.253 -        LastCursor += WriteCnt1+WriteCnt2;
   3.254 -        LastCursor %= DSBCaps.dwBufferBytes;
   3.255 -    }
   3.256 -
   3.257 -    return 0;
   3.258 -}
   3.259 -
   3.260 -static ALCboolean DSoundOpenPlayback(ALCdevice *device, const ALCchar *deviceName)
   3.261 -{
   3.262 -    DSoundData *pData = NULL;
   3.263 -    LPGUID guid = NULL;
   3.264 -    HRESULT hr;
   3.265 -
   3.266 -    if(!deviceName)
   3.267 -        deviceName = dsDevice;
   3.268 -    else if(strcmp(deviceName, dsDevice) != 0)
   3.269 -    {
   3.270 -        ALuint i;
   3.271 -
   3.272 -        if(!DeviceList)
   3.273 -        {
   3.274 -            hr = DirectSoundEnumerateA(DSoundEnumDevices, NULL);
   3.275 -            if(FAILED(hr))
   3.276 -                ERR("Error enumerating DirectSound devices (%#x)!\n", (unsigned int)hr);
   3.277 -        }
   3.278 -
   3.279 -        for(i = 0;i < NumDevices;i++)
   3.280 -        {
   3.281 -            if(strcmp(deviceName, DeviceList[i].name) == 0)
   3.282 -            {
   3.283 -                guid = &DeviceList[i].guid;
   3.284 -                break;
   3.285 -            }
   3.286 -        }
   3.287 -        if(i == NumDevices)
   3.288 -            return ALC_FALSE;
   3.289 -    }
   3.290 -
   3.291 -    //Initialise requested device
   3.292 -    pData = calloc(1, sizeof(DSoundData));
   3.293 -    if(!pData)
   3.294 -    {
   3.295 -        alcSetError(device, ALC_OUT_OF_MEMORY);
   3.296 -        return ALC_FALSE;
   3.297 -    }
   3.298 -
   3.299 -    hr = DS_OK;
   3.300 -    pData->hNotifyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
   3.301 -    if(pData->hNotifyEvent == NULL)
   3.302 -        hr = E_FAIL;
   3.303 -
   3.304 -    //DirectSound Init code
   3.305 -    if(SUCCEEDED(hr))
   3.306 -        hr = DirectSoundCreate(guid, &pData->lpDS, NULL);
   3.307 -    if(SUCCEEDED(hr))
   3.308 -        hr = IDirectSound_SetCooperativeLevel(pData->lpDS, GetForegroundWindow(), DSSCL_PRIORITY);
   3.309 -    if(FAILED(hr))
   3.310 -    {
   3.311 -        if(pData->lpDS)
   3.312 -            IDirectSound_Release(pData->lpDS);
   3.313 -        if(pData->hNotifyEvent)
   3.314 -            CloseHandle(pData->hNotifyEvent);
   3.315 -        free(pData);
   3.316 -        ERR("Device init failed: 0x%08lx\n", hr);
   3.317 -        return ALC_FALSE;
   3.318 -    }
   3.319 -
   3.320 -    device->szDeviceName = strdup(deviceName);
   3.321 -    device->ExtraData = pData;
   3.322 -    return ALC_TRUE;
   3.323 -}
   3.324 -
   3.325 -static void DSoundClosePlayback(ALCdevice *device)
   3.326 -{
   3.327 -    DSoundData *pData = device->ExtraData;
   3.328 -
   3.329 -    IDirectSound_Release(pData->lpDS);
   3.330 -    CloseHandle(pData->hNotifyEvent);
   3.331 -    free(pData);
   3.332 -    device->ExtraData = NULL;
   3.333 -}
   3.334 -
   3.335 -static ALCboolean DSoundResetPlayback(ALCdevice *device)
   3.336 -{
   3.337 -    DSoundData *pData = (DSoundData*)device->ExtraData;
   3.338 -    DSBUFFERDESC DSBDescription;
   3.339 -    WAVEFORMATEXTENSIBLE OutputType;
   3.340 -    DWORD speakers;
   3.341 -    HRESULT hr;
   3.342 -
   3.343 -    memset(&OutputType, 0, sizeof(OutputType));
   3.344 -
   3.345 -    switch(device->FmtType)
   3.346 -    {
   3.347 -        case DevFmtByte:
   3.348 -            device->FmtType = DevFmtUByte;
   3.349 -            break;
   3.350 -        case DevFmtUShort:
   3.351 -            device->FmtType = DevFmtShort;
   3.352 -            break;
   3.353 -        case DevFmtUByte:
   3.354 -        case DevFmtShort:
   3.355 -        case DevFmtFloat:
   3.356 -            break;
   3.357 -    }
   3.358 -
   3.359 -    hr = IDirectSound_GetSpeakerConfig(pData->lpDS, &speakers);
   3.360 -    if(SUCCEEDED(hr))
   3.361 -    {
   3.362 -        if(!(device->Flags&DEVICE_CHANNELS_REQUEST))
   3.363 -        {
   3.364 -            speakers = DSSPEAKER_CONFIG(speakers);
   3.365 -            if(speakers == DSSPEAKER_MONO)
   3.366 -                device->FmtChans = DevFmtMono;
   3.367 -            else if(speakers == DSSPEAKER_STEREO || speakers == DSSPEAKER_HEADPHONE)
   3.368 -                device->FmtChans = DevFmtStereo;
   3.369 -            else if(speakers == DSSPEAKER_QUAD)
   3.370 -                device->FmtChans = DevFmtQuad;
   3.371 -            else if(speakers == DSSPEAKER_5POINT1)
   3.372 -                device->FmtChans = DevFmtX51;
   3.373 -            else if(speakers == DSSPEAKER_7POINT1)
   3.374 -                device->FmtChans = DevFmtX71;
   3.375 -            else
   3.376 -                ERR("Unknown system speaker config: 0x%lx\n", speakers);
   3.377 -        }
   3.378 -
   3.379 -        switch(device->FmtChans)
   3.380 -        {
   3.381 -            case DevFmtMono:
   3.382 -                OutputType.dwChannelMask = SPEAKER_FRONT_CENTER;
   3.383 -                break;
   3.384 -            case DevFmtStereo:
   3.385 -                OutputType.dwChannelMask = SPEAKER_FRONT_LEFT |
   3.386 -                                           SPEAKER_FRONT_RIGHT;
   3.387 -                break;
   3.388 -            case DevFmtQuad:
   3.389 -                OutputType.dwChannelMask = SPEAKER_FRONT_LEFT |
   3.390 -                                           SPEAKER_FRONT_RIGHT |
   3.391 -                                           SPEAKER_BACK_LEFT |
   3.392 -                                           SPEAKER_BACK_RIGHT;
   3.393 -                break;
   3.394 -            case DevFmtX51:
   3.395 -                OutputType.dwChannelMask = SPEAKER_FRONT_LEFT |
   3.396 -                                           SPEAKER_FRONT_RIGHT |
   3.397 -                                           SPEAKER_FRONT_CENTER |
   3.398 -                                           SPEAKER_LOW_FREQUENCY |
   3.399 -                                           SPEAKER_BACK_LEFT |
   3.400 -                                           SPEAKER_BACK_RIGHT;
   3.401 -                break;
   3.402 -            case DevFmtX51Side:
   3.403 -                OutputType.dwChannelMask = SPEAKER_FRONT_LEFT |
   3.404 -                                           SPEAKER_FRONT_RIGHT |
   3.405 -                                           SPEAKER_FRONT_CENTER |
   3.406 -                                           SPEAKER_LOW_FREQUENCY |
   3.407 -                                           SPEAKER_SIDE_LEFT |
   3.408 -                                           SPEAKER_SIDE_RIGHT;
   3.409 -                break;
   3.410 -            case DevFmtX61:
   3.411 -                OutputType.dwChannelMask = SPEAKER_FRONT_LEFT |
   3.412 -                                           SPEAKER_FRONT_RIGHT |
   3.413 -                                           SPEAKER_FRONT_CENTER |
   3.414 -                                           SPEAKER_LOW_FREQUENCY |
   3.415 -                                           SPEAKER_BACK_CENTER |
   3.416 -                                           SPEAKER_SIDE_LEFT |
   3.417 -                                           SPEAKER_SIDE_RIGHT;
   3.418 -                break;
   3.419 -            case DevFmtX71:
   3.420 -                OutputType.dwChannelMask = SPEAKER_FRONT_LEFT |
   3.421 -                                           SPEAKER_FRONT_RIGHT |
   3.422 -                                           SPEAKER_FRONT_CENTER |
   3.423 -                                           SPEAKER_LOW_FREQUENCY |
   3.424 -                                           SPEAKER_BACK_LEFT |
   3.425 -                                           SPEAKER_BACK_RIGHT |
   3.426 -                                           SPEAKER_SIDE_LEFT |
   3.427 -                                           SPEAKER_SIDE_RIGHT;
   3.428 -                break;
   3.429 -        }
   3.430 -
   3.431 -        OutputType.Format.wFormatTag = WAVE_FORMAT_PCM;
   3.432 -        OutputType.Format.nChannels = ChannelsFromDevFmt(device->FmtChans);
   3.433 -        OutputType.Format.wBitsPerSample = BytesFromDevFmt(device->FmtType) * 8;
   3.434 -        OutputType.Format.nBlockAlign = OutputType.Format.nChannels*OutputType.Format.wBitsPerSample/8;
   3.435 -        OutputType.Format.nSamplesPerSec = device->Frequency;
   3.436 -        OutputType.Format.nAvgBytesPerSec = OutputType.Format.nSamplesPerSec*OutputType.Format.nBlockAlign;
   3.437 -        OutputType.Format.cbSize = 0;
   3.438 -    }
   3.439 -
   3.440 -    if(OutputType.Format.nChannels > 2 || device->FmtType == DevFmtFloat)
   3.441 -    {
   3.442 -        OutputType.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
   3.443 -        OutputType.Samples.wValidBitsPerSample = OutputType.Format.wBitsPerSample;
   3.444 -        OutputType.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
   3.445 -        if(device->FmtType == DevFmtFloat)
   3.446 -            OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
   3.447 -        else
   3.448 -            OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
   3.449 -    }
   3.450 -    else
   3.451 -    {
   3.452 -        if(SUCCEEDED(hr))
   3.453 -        {
   3.454 -            memset(&DSBDescription,0,sizeof(DSBUFFERDESC));
   3.455 -            DSBDescription.dwSize=sizeof(DSBUFFERDESC);
   3.456 -            DSBDescription.dwFlags=DSBCAPS_PRIMARYBUFFER;
   3.457 -            hr = IDirectSound_CreateSoundBuffer(pData->lpDS, &DSBDescription, &pData->DSpbuffer, NULL);
   3.458 -        }
   3.459 -        if(SUCCEEDED(hr))
   3.460 -            hr = IDirectSoundBuffer_SetFormat(pData->DSpbuffer,&OutputType.Format);
   3.461 -    }
   3.462 -
   3.463 -    if(SUCCEEDED(hr))
   3.464 -    {
   3.465 -        if(device->NumUpdates > MAX_UPDATES)
   3.466 -        {
   3.467 -            device->UpdateSize = (device->UpdateSize*device->NumUpdates +
   3.468 -                                  MAX_UPDATES-1) / MAX_UPDATES;
   3.469 -            device->NumUpdates = MAX_UPDATES;
   3.470 -        }
   3.471 -
   3.472 -        memset(&DSBDescription,0,sizeof(DSBUFFERDESC));
   3.473 -        DSBDescription.dwSize=sizeof(DSBUFFERDESC);
   3.474 -        DSBDescription.dwFlags=DSBCAPS_CTRLPOSITIONNOTIFY|DSBCAPS_GETCURRENTPOSITION2|DSBCAPS_GLOBALFOCUS;
   3.475 -        DSBDescription.dwBufferBytes=device->UpdateSize * device->NumUpdates *
   3.476 -                                     OutputType.Format.nBlockAlign;
   3.477 -        DSBDescription.lpwfxFormat=&OutputType.Format;
   3.478 -        hr = IDirectSound_CreateSoundBuffer(pData->lpDS, &DSBDescription, &pData->DSsbuffer, NULL);
   3.479 -    }
   3.480 -
   3.481 -    if(SUCCEEDED(hr))
   3.482 -    {
   3.483 -        hr = IDirectSoundBuffer_QueryInterface(pData->DSsbuffer, &IID_IDirectSoundNotify, (LPVOID *)&pData->DSnotify);
   3.484 -        if(SUCCEEDED(hr))
   3.485 -        {
   3.486 -            DSBPOSITIONNOTIFY notifies[MAX_UPDATES];
   3.487 -            ALuint i;
   3.488 -
   3.489 -            for(i = 0;i < device->NumUpdates;++i)
   3.490 -            {
   3.491 -                notifies[i].dwOffset = i * device->UpdateSize *
   3.492 -                                       OutputType.Format.nBlockAlign;
   3.493 -                notifies[i].hEventNotify = pData->hNotifyEvent;
   3.494 -            }
   3.495 -            if(IDirectSoundNotify_SetNotificationPositions(pData->DSnotify, device->NumUpdates, notifies) != DS_OK)
   3.496 -                hr = E_FAIL;
   3.497 -        }
   3.498 -    }
   3.499 -
   3.500 -    if(SUCCEEDED(hr))
   3.501 -    {
   3.502 -        ResetEvent(pData->hNotifyEvent);
   3.503 -        SetDefaultWFXChannelOrder(device);
   3.504 -        pData->thread = StartThread(DSoundProc, device);
   3.505 -        if(pData->thread == NULL)
   3.506 -            hr = E_FAIL;
   3.507 -    }
   3.508 -
   3.509 -    if(FAILED(hr))
   3.510 -    {
   3.511 -        if(pData->DSnotify != NULL)
   3.512 -            IDirectSoundNotify_Release(pData->DSnotify);
   3.513 -        pData->DSnotify = NULL;
   3.514 -        if(pData->DSsbuffer != NULL)
   3.515 -            IDirectSoundBuffer_Release(pData->DSsbuffer);
   3.516 -        pData->DSsbuffer = NULL;
   3.517 -        if(pData->DSpbuffer != NULL)
   3.518 -            IDirectSoundBuffer_Release(pData->DSpbuffer);
   3.519 -        pData->DSpbuffer = NULL;
   3.520 -        return ALC_FALSE;
   3.521 -    }
   3.522 -
   3.523 -    return ALC_TRUE;
   3.524 -}
   3.525 -
   3.526 -static void DSoundStopPlayback(ALCdevice *device)
   3.527 -{
   3.528 -    DSoundData *pData = device->ExtraData;
   3.529 -
   3.530 -    if(!pData->thread)
   3.531 -        return;
   3.532 -
   3.533 -    pData->killNow = 1;
   3.534 -    StopThread(pData->thread);
   3.535 -    pData->thread = NULL;
   3.536 -
   3.537 -    pData->killNow = 0;
   3.538 -
   3.539 -    IDirectSoundNotify_Release(pData->DSnotify);
   3.540 -    pData->DSnotify = NULL;
   3.541 -    IDirectSoundBuffer_Release(pData->DSsbuffer);
   3.542 -    pData->DSsbuffer = NULL;
   3.543 -    if(pData->DSpbuffer != NULL)
   3.544 -        IDirectSoundBuffer_Release(pData->DSpbuffer);
   3.545 -    pData->DSpbuffer = NULL;
   3.546 -}
   3.547 -
   3.548 -
   3.549 -static const BackendFuncs DSoundFuncs = {
   3.550 -    DSoundOpenPlayback,
   3.551 -    DSoundClosePlayback,
   3.552 -    DSoundResetPlayback,
   3.553 -    DSoundStopPlayback,
   3.554 -    NULL,
   3.555 -    NULL,
   3.556 -    NULL,
   3.557 -    NULL,
   3.558 -    NULL,
   3.559 -    NULL
   3.560 -};
   3.561 -
   3.562 -
   3.563 -ALCboolean alcDSoundInit(BackendFuncs *FuncList)
   3.564 -{
   3.565 -    if(!DSoundLoad())
   3.566 -        return ALC_FALSE;
   3.567 -    *FuncList = DSoundFuncs;
   3.568 -    return ALC_TRUE;
   3.569 -}
   3.570 -
   3.571 -void alcDSoundDeinit(void)
   3.572 -{
   3.573 -    ALuint i;
   3.574 -
   3.575 -    for(i = 0;i < NumDevices;++i)
   3.576 -        free(DeviceList[i].name);
   3.577 -    free(DeviceList);
   3.578 -    DeviceList = NULL;
   3.579 -    NumDevices = 0;
   3.580 -
   3.581 -    if(ds_handle)
   3.582 -        FreeLibrary(ds_handle);
   3.583 -    ds_handle = NULL;
   3.584 -}
   3.585 -
   3.586 -void alcDSoundProbe(enum DevProbe type)
   3.587 -{
   3.588 -    HRESULT hr;
   3.589 -    ALuint i;
   3.590 -
   3.591 -    switch(type)
   3.592 -    {
   3.593 -        case DEVICE_PROBE:
   3.594 -            AppendDeviceList(dsDevice);
   3.595 -            break;
   3.596 -
   3.597 -        case ALL_DEVICE_PROBE:
   3.598 -            for(i = 0;i < NumDevices;++i)
   3.599 -                free(DeviceList[i].name);
   3.600 -            free(DeviceList);
   3.601 -            DeviceList = NULL;
   3.602 -            NumDevices = 0;
   3.603 -
   3.604 -            hr = DirectSoundEnumerateA(DSoundEnumDevices, NULL);
   3.605 -            if(FAILED(hr))
   3.606 -                ERR("Error enumerating DirectSound devices (%#x)!\n", (unsigned int)hr);
   3.607 -            else
   3.608 -            {
   3.609 -                for(i = 0;i < NumDevices;i++)
   3.610 -                    AppendAllDeviceList(DeviceList[i].name);
   3.611 -            }
   3.612 -            break;
   3.613 -
   3.614 -        case CAPTURE_DEVICE_PROBE:
   3.615 -            break;
   3.616 -    }
   3.617 -}

     4.1 --- a/Alc/backends/mmdevapi.c	Tue Oct 25 13:03:35 2011 -0700
     4.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.3 @@ -1,775 +0,0 @@
     4.4 -/**
     4.5 - * OpenAL cross platform audio library
     4.6 - * Copyright (C) 2011 by authors.
     4.7 - * This library is free software; you can redistribute it and/or
     4.8 - *  modify it under the terms of the GNU Library General Public
     4.9 - *  License as published by the Free Software Foundation; either
    4.10 - *  version 2 of the License, or (at your option) any later version.
    4.11 - *
    4.12 - * This library is distributed in the hope that it will be useful,
    4.13 - *  but WITHOUT ANY WARRANTY; without even the implied warranty of
    4.14 - *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    4.15 - *  Library General Public License for more details.
    4.16 - *
    4.17 - * You should have received a copy of the GNU Library General Public
    4.18 - *  License along with this library; if not, write to the
    4.19 - *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    4.20 - *  Boston, MA  02111-1307, USA.
    4.21 - * Or go to http://www.gnu.org/copyleft/lgpl.html
    4.22 - */
    4.23 -
    4.24 -#include "config.h"
    4.25 -
    4.26 -#define COBJMACROS
    4.27 -#define _WIN32_WINNT 0x0500
    4.28 -#include <stdlib.h>
    4.29 -#include <stdio.h>
    4.30 -#include <memory.h>
    4.31 -
    4.32 -#include <mmdeviceapi.h>
    4.33 -#include <audioclient.h>
    4.34 -#include <cguid.h>
    4.35 -#include <mmreg.h>
    4.36 -#ifndef _WAVEFORMATEXTENSIBLE_
    4.37 -#include <ks.h>
    4.38 -#include <ksmedia.h>
    4.39 -#endif
    4.40 -
    4.41 -#include "alMain.h"
    4.42 -#include "AL/al.h"
    4.43 -#include "AL/alc.h"
    4.44 -
    4.45 -
    4.46 -DEFINE_GUID(KSDATAFORMAT_SUBTYPE_PCM, 0x00000001, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
    4.47 -DEFINE_GUID(KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, 0x00000003, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
    4.48 -
    4.49 -#define MONO SPEAKER_FRONT_CENTER
    4.50 -#define STEREO (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT)
    4.51 -#define QUAD (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)
    4.52 -#define X5DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)
    4.53 -#define X5DOT1SIDE (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)
    4.54 -#define X6DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_CENTER|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)
    4.55 -#define X7DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)
    4.56 -
    4.57 -
    4.58 -typedef struct {
    4.59 -    IMMDevice *mmdev;
    4.60 -    IAudioClient *client;
    4.61 -    HANDLE hNotifyEvent;
    4.62 -
    4.63 -    HANDLE MsgEvent;
    4.64 -
    4.65 -    volatile int killNow;
    4.66 -    ALvoid *thread;
    4.67 -} MMDevApiData;
    4.68 -
    4.69 -
    4.70 -static const ALCchar mmDevice[] = "WASAPI Default";
    4.71 -
    4.72 -
    4.73 -static HANDLE ThreadHdl;
    4.74 -static DWORD ThreadID;
    4.75 -
    4.76 -typedef struct {
    4.77 -    HANDLE FinishedEvt;
    4.78 -    HRESULT result;
    4.79 -} ThreadRequest;
    4.80 -
    4.81 -#define WM_USER_OpenDevice  (WM_USER+0)
    4.82 -#define WM_USER_ResetDevice (WM_USER+1)
    4.83 -#define WM_USER_StopDevice  (WM_USER+2)
    4.84 -#define WM_USER_CloseDevice (WM_USER+3)
    4.85 -
    4.86 -static HRESULT WaitForResponse(ThreadRequest *req)
    4.87 -{
    4.88 -    if(WaitForSingleObject(req->FinishedEvt, INFINITE) == WAIT_OBJECT_0)
    4.89 -        return req->result;
    4.90 -    ERR("Message response error: %lu\n", GetLastError());
    4.91 -    return E_FAIL;
    4.92 -}
    4.93 -
    4.94 -
    4.95 -static ALuint MMDevApiProc(ALvoid *ptr)
    4.96 -{
    4.97 -    ALCdevice *device = ptr;
    4.98 -    MMDevApiData *data = device->ExtraData;
    4.99 -    union {
   4.100 -        IAudioRenderClient *iface;
   4.101 -        void *ptr;
   4.102 -    } render;
   4.103 -    UINT32 written, len;
   4.104 -    BYTE *buffer;
   4.105 -    HRESULT hr;
   4.106 -
   4.107 -    hr = CoInitialize(NULL);
   4.108 -    if(FAILED(hr))
   4.109 -    {
   4.110 -        ERR("CoInitialize(NULL) failed: 0x%08lx\n", hr);
   4.111 -        aluHandleDisconnect(device);
   4.112 -        return 0;
   4.113 -    }
   4.114 -
   4.115 -    hr = IAudioClient_GetService(data->client, &IID_IAudioRenderClient, &render.ptr);
   4.116 -    if(FAILED(hr))
   4.117 -    {
   4.118 -        ERR("Failed to get AudioRenderClient service: 0x%08lx\n", hr);
   4.119 -        aluHandleDisconnect(device);
   4.120 -        return 0;
   4.121 -    }
   4.122 -
   4.123 -    SetRTPriority();
   4.124 -
   4.125 -    while(!data->killNow)
   4.126 -    {
   4.127 -        hr = IAudioClient_GetCurrentPadding(data->client, &written);
   4.128 -        if(FAILED(hr))
   4.129 -        {
   4.130 -            ERR("Failed to get padding: 0x%08lx\n", hr);
   4.131 -            aluHandleDisconnect(device);
   4.132 -            break;
   4.133 -        }
   4.134 -
   4.135 -        len = device->UpdateSize*device->NumUpdates - written;
   4.136 -        if(len < device->UpdateSize)
   4.137 -        {
   4.138 -            DWORD res;
   4.139 -            res = WaitForSingleObjectEx(data->hNotifyEvent, 2000, FALSE);
   4.140 -            if(res != WAIT_OBJECT_0)
   4.141 -                ERR("WaitForSingleObjectEx error: 0x%lx\n", res);
   4.142 -            continue;
   4.143 -        }
   4.144 -        len -= len%device->UpdateSize;
   4.145 -
   4.146 -        hr = IAudioRenderClient_GetBuffer(render.iface, len, &buffer);
   4.147 -        if(SUCCEEDED(hr))
   4.148 -        {
   4.149 -            aluMixData(device, buffer, len);
   4.150 -            hr = IAudioRenderClient_ReleaseBuffer(render.iface, len, 0);
   4.151 -        }
   4.152 -        if(FAILED(hr))
   4.153 -        {
   4.154 -            ERR("Failed to buffer data: 0x%08lx\n", hr);
   4.155 -            aluHandleDisconnect(device);
   4.156 -            break;
   4.157 -        }
   4.158 -    }
   4.159 -
   4.160 -    IAudioRenderClient_Release(render.iface);
   4.161 -
   4.162 -    CoUninitialize();
   4.163 -    return 0;
   4.164 -}
   4.165 -
   4.166 -
   4.167 -static ALCboolean MakeExtensible(WAVEFORMATEXTENSIBLE *out, const WAVEFORMATEX *in)
   4.168 -{
   4.169 -    memset(out, 0, sizeof(*out));
   4.170 -    if(in->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
   4.171 -        *out = *(WAVEFORMATEXTENSIBLE*)in;
   4.172 -    else if(in->wFormatTag == WAVE_FORMAT_PCM)
   4.173 -    {
   4.174 -        out->Format = *in;
   4.175 -        out->Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
   4.176 -        out->Format.cbSize = sizeof(*out) - sizeof(*in);
   4.177 -        if(out->Format.nChannels == 1)
   4.178 -            out->dwChannelMask = MONO;
   4.179 -        else if(out->Format.nChannels == 2)
   4.180 -            out->dwChannelMask = STEREO;
   4.181 -        else
   4.182 -            ERR("Unhandled PCM channel count: %d\n", out->Format.nChannels);
   4.183 -        out->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
   4.184 -    }
   4.185 -    else if(in->wFormatTag == WAVE_FORMAT_IEEE_FLOAT)
   4.186 -    {
   4.187 -        out->Format = *in;
   4.188 -        out->Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
   4.189 -        out->Format.cbSize = sizeof(*out) - sizeof(*in);
   4.190 -        if(out->Format.nChannels == 1)
   4.191 -            out->dwChannelMask = MONO;
   4.192 -        else if(out->Format.nChannels == 2)
   4.193 -            out->dwChannelMask = STEREO;
   4.194 -        else
   4.195 -            ERR("Unhandled IEEE float channel count: %d\n", out->Format.nChannels);
   4.196 -        out->SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
   4.197 -    }
   4.198 -    else
   4.199 -    {
   4.200 -        ERR("Unhandled format tag: 0x%04x\n", in->wFormatTag);
   4.201 -        return ALC_FALSE;
   4.202 -    }
   4.203 -    return ALC_TRUE;
   4.204 -}
   4.205 -
   4.206 -static HRESULT DoReset(ALCdevice *device)
   4.207 -{
   4.208 -    MMDevApiData *data = device->ExtraData;
   4.209 -    WAVEFORMATEXTENSIBLE OutputType;
   4.210 -    WAVEFORMATEX *wfx = NULL;
   4.211 -    REFERENCE_TIME min_per;
   4.212 -    UINT32 buffer_len, min_len;
   4.213 -    HRESULT hr;
   4.214 -
   4.215 -    hr = IAudioClient_GetMixFormat(data->client, &wfx);
   4.216 -    if(FAILED(hr))
   4.217 -    {
   4.218 -        ERR("Failed to get mix format: 0x%08lx\n", hr);
   4.219 -        return hr;
   4.220 -    }
   4.221 -
   4.222 -    if(!MakeExtensible(&OutputType, wfx))
   4.223 -    {
   4.224 -        CoTaskMemFree(wfx);
   4.225 -        return E_FAIL;
   4.226 -    }
   4.227 -    CoTaskMemFree(wfx);
   4.228 -    wfx = NULL;
   4.229 -
   4.230 -    if(!(device->Flags&DEVICE_FREQUENCY_REQUEST))
   4.231 -        device->Frequency = OutputType.Format.nSamplesPerSec;
   4.232 -    if(!(device->Flags&DEVICE_CHANNELS_REQUEST))
   4.233 -    {
   4.234 -        if(OutputType.Format.nChannels == 1 && OutputType.dwChannelMask == MONO)
   4.235 -            device->FmtChans = DevFmtMono;
   4.236 -        else if(OutputType.Format.nChannels == 2 && OutputType.dwChannelMask == STEREO)
   4.237 -            device->FmtChans = DevFmtStereo;
   4.238 -        else if(OutputType.Format.nChannels == 4 && OutputType.dwChannelMask == QUAD)
   4.239 -            device->FmtChans = DevFmtQuad;
   4.240 -        else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1)
   4.241 -            device->FmtChans = DevFmtX51;
   4.242 -        else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1SIDE)
   4.243 -            device->FmtChans = DevFmtX51Side;
   4.244 -        else if(OutputType.Format.nChannels == 7 && OutputType.dwChannelMask == X6DOT1)
   4.245 -            device->FmtChans = DevFmtX61;
   4.246 -        else if(OutputType.Format.nChannels == 8 && OutputType.dwChannelMask == X7DOT1)
   4.247 -            device->FmtChans = DevFmtX71;
   4.248 -        else
   4.249 -            ERR("Unhandled channel config: %d -- 0x%08lx\n", OutputType.Format.nChannels, OutputType.dwChannelMask);
   4.250 -    }
   4.251 -
   4.252 -    switch(device->FmtChans)
   4.253 -    {
   4.254 -        case DevFmtMono:
   4.255 -            OutputType.Format.nChannels = 1;
   4.256 -            OutputType.dwChannelMask = MONO;
   4.257 -            break;
   4.258 -        case DevFmtStereo:
   4.259 -            OutputType.Format.nChannels = 2;
   4.260 -            OutputType.dwChannelMask = STEREO;
   4.261 -            break;
   4.262 -        case DevFmtQuad:
   4.263 -            OutputType.Format.nChannels = 4;
   4.264 -            OutputType.dwChannelMask = QUAD;
   4.265 -            break;
   4.266 -        case DevFmtX51:
   4.267 -            OutputType.Format.nChannels = 6;
   4.268 -            OutputType.dwChannelMask = X5DOT1;
   4.269 -            break;
   4.270 -        case DevFmtX51Side:
   4.271 -            OutputType.Format.nChannels = 6;
   4.272 -            OutputType.dwChannelMask = X5DOT1SIDE;
   4.273 -            break;
   4.274 -        case DevFmtX61:
   4.275 -            OutputType.Format.nChannels = 7;
   4.276 -            OutputType.dwChannelMask = X6DOT1;
   4.277 -            break;
   4.278 -        case DevFmtX71:
   4.279 -            OutputType.Format.nChannels = 8;
   4.280 -            OutputType.dwChannelMask = X7DOT1;
   4.281 -            break;
   4.282 -    }
   4.283 -    switch(device->FmtType)
   4.284 -    {
   4.285 -        case DevFmtByte:
   4.286 -            device->FmtType = DevFmtUByte;
   4.287 -            /* fall-through */
   4.288 -        case DevFmtUByte:
   4.289 -            OutputType.Format.wBitsPerSample = 8;
   4.290 -            OutputType.Samples.wValidBitsPerSample = 8;
   4.291 -            OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
   4.292 -            break;
   4.293 -        case DevFmtUShort:
   4.294 -            device->FmtType = DevFmtShort;
   4.295 -            /* fall-through */
   4.296 -        case DevFmtShort:
   4.297 -            OutputType.Format.wBitsPerSample = 16;
   4.298 -            OutputType.Samples.wValidBitsPerSample = 16;
   4.299 -            OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
   4.300 -            break;
   4.301 -        case DevFmtFloat:
   4.302 -            OutputType.Format.wBitsPerSample = 32;
   4.303 -            OutputType.Samples.wValidBitsPerSample = 32;
   4.304 -            OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
   4.305 -            break;
   4.306 -    }
   4.307 -    OutputType.Format.nSamplesPerSec = device->Frequency;
   4.308 -
   4.309 -    OutputType.Format.nBlockAlign = OutputType.Format.nChannels *
   4.310 -                                    OutputType.Format.wBitsPerSample / 8;
   4.311 -    OutputType.Format.nAvgBytesPerSec = OutputType.Format.nSamplesPerSec *
   4.312 -                                        OutputType.Format.nBlockAlign;
   4.313 -
   4.314 -    hr = IAudioClient_IsFormatSupported(data->client, AUDCLNT_SHAREMODE_SHARED, &OutputType.Format, &wfx);
   4.315 -    if(FAILED(hr))
   4.316 -    {
   4.317 -        ERR("Failed to check format support: 0x%08lx\n", hr);
   4.318 -        hr = IAudioClient_GetMixFormat(data->client, &wfx);
   4.319 -    }
   4.320 -    if(FAILED(hr))
   4.321 -    {
   4.322 -        ERR("Failed to find a supported format: 0x%08lx\n", hr);
   4.323 -        return hr;
   4.324 -    }
   4.325 -
   4.326 -    if(wfx != NULL)
   4.327 -    {
   4.328 -        if(!MakeExtensible(&OutputType, wfx))
   4.329 -        {
   4.330 -            CoTaskMemFree(wfx);
   4.331 -            return E_FAIL;
   4.332 -        }
   4.333 -        CoTaskMemFree(wfx);
   4.334 -        wfx = NULL;
   4.335 -
   4.336 -        if(device->Frequency != OutputType.Format.nSamplesPerSec)
   4.337 -        {
   4.338 -            if((device->Flags&DEVICE_FREQUENCY_REQUEST))
   4.339 -                ERR("Failed to set %dhz, got %ldhz instead\n", device->Frequency, OutputType.Format.nSamplesPerSec);
   4.340 -            device->Flags &= ~DEVICE_FREQUENCY_REQUEST;
   4.341 -            device->Frequency = OutputType.Format.nSamplesPerSec;
   4.342 -        }
   4.343 -
   4.344 -        if(!((device->FmtChans == DevFmtMono && OutputType.Format.nChannels == 1 && OutputType.dwChannelMask == MONO) ||
   4.345 -             (device->FmtChans == DevFmtStereo && OutputType.Format.nChannels == 2 && OutputType.dwChannelMask == STEREO) ||
   4.346 -             (device->FmtChans == DevFmtQuad && OutputType.Format.nChannels == 4 && OutputType.dwChannelMask == QUAD) ||
   4.347 -             (device->FmtChans == DevFmtX51 && OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1) ||
   4.348 -             (device->FmtChans == DevFmtX51Side && OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1SIDE) ||
   4.349 -             (device->FmtChans == DevFmtX61 && OutputType.Format.nChannels == 7 && OutputType.dwChannelMask == X6DOT1) ||
   4.350 -             (device->FmtChans == DevFmtX71 && OutputType.Format.nChannels == 8 && OutputType.dwChannelMask == X7DOT1)))
   4.351 -        {
   4.352 -            if((device->Flags&DEVICE_CHANNELS_REQUEST))
   4.353 -                ERR("Failed to set %s, got %d channels (0x%08lx) instead\n", DevFmtChannelsString(device->FmtChans), OutputType.Format.nChannels, OutputType.dwChannelMask);
   4.354 -            device->Flags &= ~DEVICE_CHANNELS_REQUEST;
   4.355 -
   4.356 -            if(OutputType.Format.nChannels == 1 && OutputType.dwChannelMask == MONO)
   4.357 -                device->FmtChans = DevFmtMono;
   4.358 -            else if(OutputType.Format.nChannels == 2 && OutputType.dwChannelMask == STEREO)
   4.359 -                device->FmtChans = DevFmtStereo;
   4.360 -            else if(OutputType.Format.nChannels == 4 && OutputType.dwChannelMask == QUAD)
   4.361 -                device->FmtChans = DevFmtQuad;
   4.362 -            else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1)
   4.363 -                device->FmtChans = DevFmtX51;
   4.364 -            else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1SIDE)
   4.365 -                device->FmtChans = DevFmtX51Side;
   4.366 -            else if(OutputType.Format.nChannels == 7 && OutputType.dwChannelMask == X6DOT1)
   4.367 -                device->FmtChans = DevFmtX61;
   4.368 -            else if(OutputType.Format.nChannels == 8 && OutputType.dwChannelMask == X7DOT1)
   4.369 -                device->FmtChans = DevFmtX71;
   4.370 -            else
   4.371 -            {
   4.372 -                ERR("Unhandled extensible channels: %d -- 0x%08lx\n", OutputType.Format.nChannels, OutputType.dwChannelMask);
   4.373 -                device->FmtChans = DevFmtStereo;
   4.374 -                OutputType.Format.nChannels = 2;
   4.375 -                OutputType.dwChannelMask = STEREO;
   4.376 -            }
   4.377 -        }
   4.378 -
   4.379 -        if(IsEqualGUID(&OutputType.SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))
   4.380 -        {
   4.381 -            if(OutputType.Samples.wValidBitsPerSample == 0)
   4.382 -                OutputType.Samples.wValidBitsPerSample = OutputType.Format.wBitsPerSample;
   4.383 -            if(OutputType.Samples.wValidBitsPerSample != OutputType.Format.wBitsPerSample ||
   4.384 -               !((device->FmtType == DevFmtUByte && OutputType.Format.wBitsPerSample == 8) ||
   4.385 -                 (device->FmtType == DevFmtShort && OutputType.Format.wBitsPerSample == 16)))
   4.386 -            {
   4.387 -                ERR("Failed to set %s samples, got %d/%d-bit instead\n", DevFmtTypeString(device->FmtType), OutputType.Samples.wValidBitsPerSample, OutputType.Format.wBitsPerSample);
   4.388 -                if(OutputType.Format.wBitsPerSample == 8)
   4.389 -                    device->FmtType = DevFmtUByte;
   4.390 -                else if(OutputType.Format.wBitsPerSample == 16)
   4.391 -                    device->FmtType = DevFmtShort;
   4.392 -                else
   4.393 -                {
   4.394 -                    device->FmtType = DevFmtShort;
   4.395 -                    OutputType.Format.wBitsPerSample = 16;
   4.396 -                }
   4.397 -                OutputType.Samples.wValidBitsPerSample = OutputType.Format.wBitsPerSample;
   4.398 -            }
   4.399 -        }
   4.400 -        else if(IsEqualGUID(&OutputType.SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))
   4.401 -        {
   4.402 -            if(OutputType.Samples.wValidBitsPerSample == 0)
   4.403 -                OutputType.Samples.wValidBitsPerSample = OutputType.Format.wBitsPerSample;
   4.404 -            if(OutputType.Samples.wValidBitsPerSample != OutputType.Format.wBitsPerSample ||
   4.405 -               !((device->FmtType == DevFmtFloat && OutputType.Format.wBitsPerSample == 32)))
   4.406 -            {
   4.407 -                ERR("Failed to set %s samples, got %d/%d-bit instead\n", DevFmtTypeString(device->FmtType), OutputType.Samples.wValidBitsPerSample, OutputType.Format.wBitsPerSample);
   4.408 -                if(OutputType.Format.wBitsPerSample != 32)
   4.409 -                {
   4.410 -                    device->FmtType = DevFmtFloat;
   4.411 -                    OutputType.Format.wBitsPerSample = 32;
   4.412 -                }
   4.413 -                OutputType.Samples.wValidBitsPerSample = OutputType.Format.wBitsPerSample;
   4.414 -            }
   4.415 -        }
   4.416 -        else
   4.417 -        {
   4.418 -            ERR("Unhandled format sub-type\n");
   4.419 -            device->FmtType = DevFmtShort;
   4.420 -            OutputType.Format.wBitsPerSample = 16;
   4.421 -            OutputType.Samples.wValidBitsPerSample = OutputType.Format.wBitsPerSample;
   4.422 -            OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
   4.423 -        }
   4.424 -    }
   4.425 -
   4.426 -    SetDefaultWFXChannelOrder(device);
   4.427 -
   4.428 -    hr = IAudioClient_GetDevicePeriod(data->client, &min_per, NULL);
   4.429 -    if(SUCCEEDED(hr))
   4.430 -    {
   4.431 -        min_len = (min_per*device->Frequency + 10000000-1) / 10000000;
   4.432 -        if(min_len < device->UpdateSize)
   4.433 -            min_len *= (device->UpdateSize + min_len/2)/min_len;
   4.434 -
   4.435 -        device->NumUpdates = (device->NumUpdates*device->UpdateSize + min_len/2) /
   4.436 -                             min_len;
   4.437 -        device->NumUpdates = maxu(device->NumUpdates, 2);
   4.438 -        device->UpdateSize = min_len;
   4.439 -
   4.440 -        hr = IAudioClient_Initialize(data->client, AUDCLNT_SHAREMODE_SHARED,
   4.441 -                                     AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
   4.442 -                                     ((REFERENCE_TIME)device->UpdateSize*
   4.443 -                                      device->NumUpdates*10000000 +
   4.444 -                                      device->Frequency-1) / device->Frequency,
   4.445 -                                     0, &OutputType.Format, NULL);
   4.446 -    }
   4.447 -    if(FAILED(hr))
   4.448 -    {
   4.449 -        ERR("Failed to initialize audio client: 0x%08lx\n", hr);
   4.450 -        return hr;
   4.451 -    }
   4.452 -
   4.453 -    hr = IAudioClient_GetBufferSize(data->client, &buffer_len);
   4.454 -    if(FAILED(hr))
   4.455 -    {
   4.456 -        ERR("Failed to get audio buffer info: 0x%08lx\n", hr);
   4.457 -        return hr;
   4.458 -    }
   4.459 -
   4.460 -    device->NumUpdates = buffer_len / device->UpdateSize;
   4.461 -    if(device->NumUpdates <= 1)
   4.462 -    {
   4.463 -        device->NumUpdates = 1;
   4.464 -        ERR("Audio client returned buffer_len < period*2; expect break up\n");
   4.465 -    }
   4.466 -
   4.467 -    ResetEvent(data->hNotifyEvent);
   4.468 -    hr = IAudioClient_SetEventHandle(data->client, data->hNotifyEvent);
   4.469 -    if(SUCCEEDED(hr))
   4.470 -        hr = IAudioClient_Start(data->client);
   4.471 -    if(FAILED(hr))
   4.472 -    {
   4.473 -        ERR("Failed to start audio client: 0x%08lx\n", hr);
   4.474 -        return hr;
   4.475 -    }
   4.476 -
   4.477 -    data->thread = StartThread(MMDevApiProc, device);
   4.478 -    if(!data->thread)
   4.479 -    {
   4.480 -        IAudioClient_Stop(data->client);
   4.481 -        ERR("Failed to start thread\n");
   4.482 -        return E_FAIL;
   4.483 -    }
   4.484 -
   4.485 -    return hr;
   4.486 -}
   4.487 -
   4.488 -
   4.489 -static DWORD CALLBACK MessageProc(void *ptr)
   4.490 -{
   4.491 -    ThreadRequest *req = ptr;
   4.492 -    IMMDeviceEnumerator *Enumerator;
   4.493 -    MMDevApiData *data;
   4.494 -    ALCdevice *device;
   4.495 -    HRESULT hr;
   4.496 -    MSG msg;
   4.497 -
   4.498 -    TRACE("Starting message thread\n");
   4.499 -
   4.500 -    hr = CoInitialize(NULL);
   4.501 -    if(FAILED(hr))
   4.502 -    {
   4.503 -        WARN("Failed to initialize COM: 0x%08lx\n", hr);
   4.504 -        req->result = hr;
   4.505 -        SetEvent(req->FinishedEvt);
   4.506 -        return 0;
   4.507 -    }
   4.508 -
   4.509 -    hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, &ptr);
   4.510 -    if(FAILED(hr))
   4.511 -    {
   4.512 -        WARN("Failed to create IMMDeviceEnumerator instance: 0x%08lx\n", hr);
   4.513 -        CoUninitialize();
   4.514 -        req->result = hr;
   4.515 -        SetEvent(req->FinishedEvt);
   4.516 -        return 0;
   4.517 -    }
   4.518 -    Enumerator = ptr;
   4.519 -    IMMDeviceEnumerator_Release(Enumerator);
   4.520 -    Enumerator = NULL;
   4.521 -
   4.522 -    req->result = S_OK;
   4.523 -    SetEvent(req->FinishedEvt);
   4.524 -
   4.525 -    TRACE("Starting message loop\n");
   4.526 -    while(GetMessage(&msg, NULL, 0, 0))
   4.527 -    {
   4.528 -        TRACE("Got message %u\n", msg.message);
   4.529 -        switch(msg.message)
   4.530 -        {
   4.531 -        case WM_USER_OpenDevice:
   4.532 -            req = (ThreadRequest*)msg.wParam;
   4.533 -            device = (ALCdevice*)msg.lParam;
   4.534 -            data = device->ExtraData;
   4.535 -
   4.536 -            hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, &ptr);
   4.537 -            if(SUCCEEDED(hr))
   4.538 -            {
   4.539 -                Enumerator = ptr;
   4.540 -                hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(Enumerator, eRender, eMultimedia, &data->mmdev);
   4.541 -                IMMDeviceEnumerator_Release(Enumerator);
   4.542 -                Enumerator = NULL;
   4.543 -            }
   4.544 -            if(SUCCEEDED(hr))
   4.545 -                hr = IMMDevice_Activate(data->mmdev, &IID_IAudioClient, CLSCTX_INPROC_SERVER, NULL, &ptr);
   4.546 -            if(SUCCEEDED(hr))
   4.547 -                data->client = ptr;
   4.548 -
   4.549 -            if(FAILED(hr))
   4.550 -            {
   4.551 -                if(data->mmdev)
   4.552 -                    IMMDevice_Release(data->mmdev);
   4.553 -                data->mmdev = NULL;
   4.554 -            }
   4.555 -
   4.556 -            req->result = hr;
   4.557 -            SetEvent(req->FinishedEvt);
   4.558 -            continue;
   4.559 -
   4.560 -        case WM_USER_ResetDevice:
   4.561 -            req = (ThreadRequest*)msg.wParam;
   4.562 -            device = (ALCdevice*)msg.lParam;
   4.563 -
   4.564 -            req->result = DoReset(device);
   4.565 -            SetEvent(req->FinishedEvt);
   4.566 -            continue;
   4.567 -
   4.568 -        case WM_USER_StopDevice:
   4.569 -            req = (ThreadRequest*)msg.wParam;
   4.570 -            device = (ALCdevice*)msg.lParam;
   4.571 -            data = device->ExtraData;
   4.572 -
   4.573 -            if(data->thread)
   4.574 -            {
   4.575 -                data->killNow = 1;
   4.576 -                StopThread(data->thread);
   4.577 -                data->thread = NULL;
   4.578 -
   4.579 -                data->killNow = 0;
   4.580 -
   4.581 -                IAudioClient_Stop(data->client);
   4.582 -            }
   4.583 -
   4.584 -            req->result = S_OK;
   4.585 -            SetEvent(req->FinishedEvt);
   4.586 -            continue;
   4.587 -
   4.588 -        case WM_USER_CloseDevice:
   4.589 -            req = (ThreadRequest*)msg.wParam;
   4.590 -            device = (ALCdevice*)msg.lParam;
   4.591 -            data = device->ExtraData;
   4.592 -
   4.593 -            IAudioClient_Release(data->client);
   4.594 -            data->client = NULL;
   4.595 -
   4.596 -            IMMDevice_Release(data->mmdev);
   4.597 -            data->mmdev = NULL;
   4.598 -
   4.599 -            req->result = S_OK;
   4.600 -            SetEvent(req->FinishedEvt);
   4.601 -            continue;
   4.602 -
   4.603 -        default:
   4.604 -            ERR("Unexpected message: %u\n", msg.message);
   4.605 -            continue;
   4.606 -        }
   4.607 -    }
   4.608 -    TRACE("Message loop finished\n");
   4.609 -
   4.610 -    CoUninitialize();
   4.611 -    return 0;
   4.612 -}
   4.613 -
   4.614 -
   4.615 -static BOOL MMDevApiLoad(void)
   4.616 -{
   4.617 -    static HRESULT InitResult;
   4.618 -    if(!ThreadHdl)
   4.619 -    {
   4.620 -        ThreadRequest req;
   4.621 -        InitResult = E_FAIL;
   4.622 -
   4.623 -        req.FinishedEvt = CreateEvent(NULL, FALSE, FALSE, NULL);
   4.624 -        if(req.FinishedEvt == NULL)
   4.625 -            ERR("Failed to create event: %lu\n", GetLastError());
   4.626 -        else
   4.627 -        {
   4.628 -            ThreadHdl = CreateThread(NULL, 0, MessageProc, &req, 0, &ThreadID);
   4.629 -            if(ThreadHdl != NULL)
   4.630 -                InitResult = WaitForResponse(&req);
   4.631 -            CloseHandle(req.FinishedEvt);
   4.632 -        }
   4.633 -    }
   4.634 -    return SUCCEEDED(InitResult);
   4.635 -}
   4.636 -
   4.637 -
   4.638 -static ALCboolean MMDevApiOpenPlayback(ALCdevice *device, const ALCchar *deviceName)
   4.639 -{
   4.640 -    MMDevApiData *data = NULL;
   4.641 -    HRESULT hr;
   4.642 -
   4.643 -    if(!deviceName)
   4.644 -        deviceName = mmDevice;
   4.645 -    else if(strcmp(deviceName, mmDevice) != 0)
   4.646 -        return ALC_FALSE;
   4.647 -
   4.648 -    //Initialise requested device
   4.649 -    data = calloc(1, sizeof(MMDevApiData));
   4.650 -    if(!data)
   4.651 -    {
   4.652 -        alcSetError(device, ALC_OUT_OF_MEMORY);
   4.653 -        return ALC_FALSE;
   4.654 -    }
   4.655 -    device->ExtraData = data;
   4.656 -
   4.657 -    hr = S_OK;
   4.658 -    data->hNotifyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
   4.659 -    data->MsgEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
   4.660 -    if(data->hNotifyEvent == NULL || data->MsgEvent == NULL)
   4.661 -        hr = E_FAIL;
   4.662 -
   4.663 -    if(SUCCEEDED(hr))
   4.664 -    {
   4.665 -        ThreadRequest req = { data->MsgEvent, 0 };
   4.666 -
   4.667 -        hr = E_FAIL;
   4.668 -        if(PostThreadMessage(ThreadID, WM_USER_OpenDevice, (WPARAM)&req, (LPARAM)device))
   4.669 -            hr = WaitForResponse(&req);
   4.670 -    }
   4.671 -
   4.672 -    if(FAILED(hr))
   4.673 -    {
   4.674 -        if(data->hNotifyEvent != NULL)
   4.675 -            CloseHandle(data->hNotifyEvent);
   4.676 -        data->hNotifyEvent = NULL;
   4.677 -        if(data->MsgEvent != NULL)
   4.678 -            CloseHandle(data->MsgEvent);
   4.679 -        data->MsgEvent = NULL;
   4.680 -
   4.681 -        free(data);
   4.682 -        device->ExtraData = NULL;
   4.683 -
   4.684 -        ERR("Device init failed: 0x%08lx\n", hr);
   4.685 -        return ALC_FALSE;
   4.686 -    }
   4.687 -
   4.688 -    device->szDeviceName = strdup(deviceName);
   4.689 -    return ALC_TRUE;
   4.690 -}
   4.691 -
   4.692 -static void MMDevApiClosePlayback(ALCdevice *device)
   4.693 -{
   4.694 -    MMDevApiData *data = device->ExtraData;
   4.695 -    ThreadRequest req = { data->MsgEvent, 0 };
   4.696 -
   4.697 -    if(PostThreadMessage(ThreadID, WM_USER_CloseDevice, (WPARAM)&req, (LPARAM)device))
   4.698 -        (void)WaitForResponse(&req);
   4.699 -
   4.700 -    CloseHandle(data->MsgEvent);
   4.701 -    data->MsgEvent = NULL;
   4.702 -
   4.703 -    CloseHandle(data->hNotifyEvent);
   4.704 -    data->hNotifyEvent = NULL;
   4.705 -
   4.706 -    free(data);
   4.707 -    device->ExtraData = NULL;
   4.708 -}
   4.709 -
   4.710 -static ALCboolean MMDevApiResetPlayback(ALCdevice *device)
   4.711 -{
   4.712 -    MMDevApiData *data = device->ExtraData;
   4.713 -    ThreadRequest req = { data->MsgEvent, 0 };
   4.714 -    HRESULT hr = E_FAIL;
   4.715 -
   4.716 -    if(PostThreadMessage(ThreadID, WM_USER_ResetDevice, (WPARAM)&req, (LPARAM)device))
   4.717 -        hr = WaitForResponse(&req);
   4.718 -
   4.719 -    return SUCCEEDED(hr) ? ALC_TRUE : ALC_FALSE;
   4.720 -}
   4.721 -
   4.722 -static void MMDevApiStopPlayback(ALCdevice *device)
   4.723 -{
   4.724 -    MMDevApiData *data = device->ExtraData;
   4.725 -    ThreadRequest req = { data->MsgEvent, 0 };
   4.726 -
   4.727 -    if(PostThreadMessage(ThreadID, WM_USER_StopDevice, (WPARAM)&req, (LPARAM)device))
   4.728 -        (void)WaitForResponse(&req);
   4.729 -}
   4.730 -
   4.731 -
   4.732 -static const BackendFuncs MMDevApiFuncs = {
   4.733 -    MMDevApiOpenPlayback,
   4.734 -    MMDevApiClosePlayback,
   4.735 -    MMDevApiResetPlayback,
   4.736 -    MMDevApiStopPlayback,
   4.737 -    NULL,
   4.738 -    NULL,
   4.739 -    NULL,
   4.740 -    NULL,
   4.741 -    NULL,
   4.742 -    NULL
   4.743 -};
   4.744 -
   4.745 -
   4.746 -ALCboolean alcMMDevApiInit(BackendFuncs *FuncList)
   4.747 -{
   4.748 -    if(!MMDevApiLoad())
   4.749 -        return ALC_FALSE;
   4.750 -    *FuncList = MMDevApiFuncs;
   4.751 -    return ALC_TRUE;
   4.752 -}
   4.753 -
   4.754 -void alcMMDevApiDeinit(void)
   4.755 -{
   4.756 -    if(ThreadHdl)
   4.757 -    {
   4.758 -        TRACE("Sending WM_QUIT to Thread %04lx\n", ThreadID);
   4.759 -        PostThreadMessage(ThreadID, WM_QUIT, 0, 0);
   4.760 -        CloseHandle(ThreadHdl);
   4.761 -        ThreadHdl = NULL;
   4.762 -    }
   4.763 -}
   4.764 -
   4.765 -void alcMMDevApiProbe(enum DevProbe type)
   4.766 -{
   4.767 -    switch(type)
   4.768 -    {
   4.769 -        case DEVICE_PROBE:
   4.770 -            AppendDeviceList(mmDevice);
   4.771 -            break;
   4.772 -        case ALL_DEVICE_PROBE:
   4.773 -            AppendAllDeviceList(mmDevice);
   4.774 -            break;
   4.775 -        case CAPTURE_DEVICE_PROBE:
   4.776 -            break;
   4.777 -    }
   4.778 -}

     5.1 --- a/Alc/backends/opensl.c	Tue Oct 25 13:03:35 2011 -0700
     5.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.3 @@ -1,425 +0,0 @@
     5.4 -/*
     5.5 - * Copyright (C) 2011 The Android Open Source Project
     5.6 - *
     5.7 - * Licensed under the Apache License, Version 2.0 (the "License");
     5.8 - * you may not use this file except in compliance with the License.
     5.9 - * You may obtain a copy of the License at
    5.10 - *
    5.11 - *      http://www.apache.org/licenses/LICENSE-2.0
    5.12 - *
    5.13 - * Unless required by applicable law or agreed to in writing, software
    5.14 - * distributed under the License is distributed on an "AS IS" BASIS,
    5.15 - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    5.16 - * See the License for the specific language governing permissions and
    5.17 - * limitations under the License.
    5.18 - */
    5.19 -
    5.20 -/* This is an OpenAL backend for Android using the native audio APIs based on
    5.21 - * OpenSL ES 1.0.1. It is based on source code for the native-audio sample app
    5.22 - * bundled with NDK.
    5.23 - */
    5.24 -
    5.25 -#include "config.h"
    5.26 -
    5.27 -#include <stdlib.h>
    5.28 -#include "alMain.h"
    5.29 -#include "AL/al.h"
    5.30 -#include "AL/alc.h"
    5.31 -
    5.32 -
    5.33 -#include <SLES/OpenSLES.h>
    5.34 -#if 1
    5.35 -#include <SLES/OpenSLES_Android.h>
    5.36 -#else
    5.37 -extern SLAPIENTRY const SLInterfaceID SL_IID_ANDROIDSIMPLEBUFFERQUEUE;
    5.38 -
    5.39 -struct SLAndroidSimpleBufferQueueItf_;
    5.40 -typedef const struct SLAndroidSimpleBufferQueueItf_ * const * SLAndroidSimpleBufferQueueItf;
    5.41 -
    5.42 -typedef void (*slAndroidSimpleBufferQueueCallback)(SLAndroidSimpleBufferQueueItf caller, void *pContext);
    5.43 -
    5.44 -typedef struct SLAndroidSimpleBufferQueueState_ {
    5.45 -    SLuint32 count;
    5.46 -    SLuint32 index;
    5.47 -} SLAndroidSimpleBufferQueueState;
    5.48 -
    5.49 -
    5.50 -struct SLAndroidSimpleBufferQueueItf_ {
    5.51 -    SLresult (*Enqueue) (
    5.52 -        SLAndroidSimpleBufferQueueItf self,
    5.53 -        const void *pBuffer,
    5.54 -        SLuint32 size
    5.55 -    );
    5.56 -    SLresult (*Clear) (
    5.57 -        SLAndroidSimpleBufferQueueItf self
    5.58 -    );
    5.59 -    SLresult (*GetState) (
    5.60 -        SLAndroidSimpleBufferQueueItf self,
    5.61 -        SLAndroidSimpleBufferQueueState *pState
    5.62 -    );
    5.63 -    SLresult (*RegisterCallback) (
    5.64 -        SLAndroidSimpleBufferQueueItf self,
    5.65 -        slAndroidSimpleBufferQueueCallback callback,
    5.66 -        void* pContext
    5.67 -    );
    5.68 -};
    5.69 -
    5.70 -#define SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE ((SLuint32) 0x800007BD)
    5.71 -
    5.72 -typedef struct SLDataLocator_AndroidSimpleBufferQueue {
    5.73 -    SLuint32 locatorType;
    5.74 -    SLuint32 numBuffers;
    5.75 -} SLDataLocator_AndroidSimpleBufferQueue;
    5.76 -
    5.77 -#endif
    5.78 -
    5.79 -/* Helper macros */
    5.80 -#define SLObjectItf_Realize(a,b)        ((*(a))->Realize((a),(b)))
    5.81 -#define SLObjectItf_GetInterface(a,b,c) ((*(a))->GetInterface((a),(b),(c)))
    5.82 -#define SLObjectItf_Destroy(a)          ((*(a))->Destroy((a)))
    5.83 -
    5.84 -#define SLEngineItf_CreateOutputMix(a,b,c,d,e)       ((*(a))->CreateOutputMix((a),(b),(c),(d),(e)))
    5.85 -#define SLEngineItf_CreateAudioPlayer(a,b,c,d,e,f,g) ((*(a))->CreateAudioPlayer((a),(b),(c),(d),(e),(f),(g)))
    5.86 -
    5.87 -#define SLPlayItf_SetPlayState(a,b) ((*(a))->SetPlayState((a),(b)))
    5.88 -
    5.89 -
    5.90 -typedef struct {
    5.91 -    /* engine interfaces */
    5.92 -    SLObjectItf engineObject;
    5.93 -    SLEngineItf engine;
    5.94 -
    5.95 -    /* output mix interfaces */
    5.96 -    SLObjectItf outputMix;
    5.97 -
    5.98 -    /* buffer queue player interfaces */
    5.99 -    SLObjectItf bufferQueueObject;
   5.100 -
   5.101 -    void *buffer;
   5.102 -    ALuint bufferSize;
   5.103 -
   5.104 -    ALuint frameSize;
   5.105 -} osl_data;
   5.106 -
   5.107 -
   5.108 -static const ALCchar opensl_device[] = "OpenSL";
   5.109 -
   5.110 -
   5.111 -static SLuint32 GetChannelMask(enum DevFmtChannels chans)
   5.112 -{
   5.113 -    switch(chans)
   5.114 -    {
   5.115 -        case DevFmtMono: return SL_SPEAKER_FRONT_CENTER;
   5.116 -        case DevFmtStereo: return SL_SPEAKER_FRONT_LEFT|SL_SPEAKER_FRONT_RIGHT;
   5.117 -        case DevFmtQuad: return SL_SPEAKER_FRONT_LEFT|SL_SPEAKER_FRONT_RIGHT|
   5.118 -                                SL_SPEAKER_BACK_LEFT|SL_SPEAKER_BACK_RIGHT;
   5.119 -        case DevFmtX51: return SL_SPEAKER_FRONT_LEFT|SL_SPEAKER_FRONT_RIGHT|
   5.120 -                               SL_SPEAKER_FRONT_CENTER|SL_SPEAKER_LOW_FREQUENCY|
   5.121 -                               SL_SPEAKER_BACK_LEFT|SL_SPEAKER_BACK_RIGHT;
   5.122 -        case DevFmtX61: return SL_SPEAKER_FRONT_LEFT|SL_SPEAKER_FRONT_RIGHT|
   5.123 -                               SL_SPEAKER_FRONT_CENTER|SL_SPEAKER_LOW_FREQUENCY|
   5.124 -                               SL_SPEAKER_BACK_CENTER|
   5.125 -                               SL_SPEAKER_SIDE_LEFT|SL_SPEAKER_SIDE_RIGHT;
   5.126 -        case DevFmtX71: return SL_SPEAKER_FRONT_LEFT|SL_SPEAKER_FRONT_RIGHT|
   5.127 -                               SL_SPEAKER_FRONT_CENTER|SL_SPEAKER_LOW_FREQUENCY|
   5.128 -                               SL_SPEAKER_BACK_LEFT|SL_SPEAKER_BACK_RIGHT|
   5.129 -                               SL_SPEAKER_SIDE_LEFT|SL_SPEAKER_SIDE_RIGHT;
   5.130 -        case DevFmtX51Side: return SL_SPEAKER_FRONT_LEFT|SL_SPEAKER_FRONT_RIGHT|
   5.131 -                                   SL_SPEAKER_FRONT_CENTER|SL_SPEAKER_LOW_FREQUENCY|
   5.132 -                                   SL_SPEAKER_SIDE_LEFT|SL_SPEAKER_SIDE_RIGHT;
   5.133 -    }
   5.134 -    return 0;
   5.135 -}
   5.136 -
   5.137 -static const char *res_str(SLresult result)
   5.138 -{
   5.139 -    switch(result)
   5.140 -    {
   5.141 -        case SL_RESULT_SUCCESS: return "Success";
   5.142 -        case SL_RESULT_PRECONDITIONS_VIOLATED: return "Preconditions violated";
   5.143 -        case SL_RESULT_PARAMETER_INVALID: return "Parameter invalid";
   5.144 -        case SL_RESULT_MEMORY_FAILURE: return "Memory failure";
   5.145 -        case SL_RESULT_RESOURCE_ERROR: return "Resource error";
   5.146 -        case SL_RESULT_RESOURCE_LOST: return "Resource lost";
   5.147 -        case SL_RESULT_IO_ERROR: return "I/O error";
   5.148 -        case SL_RESULT_BUFFER_INSUFFICIENT: return "Buffer insufficient";
   5.149 -        case SL_RESULT_CONTENT_CORRUPTED: return "Content corrupted";
   5.150 -        case SL_RESULT_CONTENT_UNSUPPORTED: return "Content unsupported";
   5.151 -        case SL_RESULT_CONTENT_NOT_FOUND: return "Content not found";
   5.152 -        case SL_RESULT_PERMISSION_DENIED: return "Permission denied";
   5.153 -        case SL_RESULT_FEATURE_UNSUPPORTED: return "Feature unsupported";
   5.154 -        case SL_RESULT_INTERNAL_ERROR: return "Internal error";
   5.155 -        case SL_RESULT_UNKNOWN_ERROR: return "Unknown error";
   5.156 -        case SL_RESULT_OPERATION_ABORTED: return "Operation aborted";
   5.157 -        case SL_RESULT_CONTROL_LOST: return "Control lost";
   5.158 -        case SL_RESULT_READONLY: return "ReadOnly";
   5.159 -        case SL_RESULT_ENGINEOPTION_UNSUPPORTED: return "Engine option unsupported";
   5.160 -        case SL_RESULT_SOURCE_SINK_INCOMPATIBLE: return "Source/Sink incompatible";
   5.161 -    }
   5.162 -    return "Unknown error code";
   5.163 -}
   5.164 -
   5.165 -#define PRINTERR(x, s) do {                                                      \
   5.166 -    if((x) != SL_RESULT_SUCCESS)                                                 \
   5.167 -        ERR("%s: %s\n", (s), res_str((x)));                                      \
   5.168 -} while(0)
   5.169 -
   5.170 -/* this callback handler is called every time a buffer finishes playing */
   5.171 -static void opensl_callback(SLAndroidSimpleBufferQueueItf bq, void *context)
   5.172 -{
   5.173 -    ALCdevice *Device = context;
   5.174 -    osl_data *data = Device->ExtraData;
   5.175 -    SLresult result;
   5.176 -
   5.177 -    aluMixData(Device, data->buffer, data->bufferSize/data->frameSize);
   5.178 -
   5.179 -    result = (*bq)->Enqueue(bq, data->buffer, data->bufferSize);
   5.180 -    PRINTERR(result, "bq->Enqueue");
   5.181 -}
   5.182 -
   5.183 -
   5.184 -static ALCboolean opensl_open_playback(ALCdevice *Device, const ALCchar *deviceName)
   5.185 -{
   5.186 -    osl_data *data = NULL;
   5.187 -    SLresult result;
   5.188 -
   5.189 -    if(!deviceName)
   5.190 -        deviceName = opensl_device;
   5.191 -    else if(strcmp(deviceName, opensl_device) != 0)
   5.192 -        return ALC_FALSE;
   5.193 -
   5.194 -    data = calloc(1, sizeof(*data));
   5.195 -    if(!data)
   5.196 -    {
   5.197 -        alcSetError(Device, ALC_OUT_OF_MEMORY);
   5.198 -        return ALC_FALSE;
   5.199 -    }
   5.200 -
   5.201 -    // create engine
   5.202 -    result = slCreateEngine(&data->engineObject, 0, NULL, 0, NULL, NULL);
   5.203 -    PRINTERR(result, "slCreateEngine");
   5.204 -    if(SL_RESULT_SUCCESS == result)
   5.205 -    {
   5.206 -        result = SLObjectItf_Realize(data->engineObject, SL_BOOLEAN_FALSE);
   5.207 -        PRINTERR(result, "engine->Realize");
   5.208 -    }
   5.209 -    if(SL_RESULT_SUCCESS == result)
   5.210 -    {
   5.211 -        result = SLObjectItf_GetInterface(data->engineObject, SL_IID_ENGINE, &data->engine);
   5.212 -        PRINTERR(result, "engine->GetInterface");
   5.213 -    }
   5.214 -    if(SL_RESULT_SUCCESS == result)
   5.215 -    {
   5.216 -        result = SLEngineItf_CreateOutputMix(data->engine, &data->outputMix, 0, NULL, NULL);
   5.217 -        PRINTERR(result, "engine->CreateOutputMix");
   5.218 -    }
   5.219 -    if(SL_RESULT_SUCCESS == result)
   5.220 -    {
   5.221 -        result = SLObjectItf_Realize(data->outputMix, SL_BOOLEAN_FALSE);
   5.222 -        PRINTERR(result, "outputMix->Realize");
   5.223 -    }
   5.224 -
   5.225 -    if(SL_RESULT_SUCCESS != result)
   5.226 -    {
   5.227 -        if(data->outputMix != NULL)
   5.228 -            SLObjectItf_Destroy(data->outputMix);
   5.229 -        data->outputMix = NULL;
   5.230 -
   5.231 -        if(data->engineObject != NULL)
   5.232 -            SLObjectItf_Destroy(data->engineObject);
   5.233 -        data->engineObject = NULL;
   5.234 -        data->engine = NULL;
   5.235 -
   5.236 -        free(data);
   5.237 -        return ALC_FALSE;
   5.238 -    }
   5.239 -
   5.240 -    Device->szDeviceName = strdup(deviceName);
   5.241 -    Device->ExtraData = data;
   5.242 -
   5.243 -    return ALC_TRUE;
   5.244 -}
   5.245 -
   5.246 -
   5.247 -static void opensl_close_playback(ALCdevice *Device)
   5.248 -{
   5.249 -    osl_data *data = Device->ExtraData;
   5.250 -
   5.251 -    SLObjectItf_Destroy(data->outputMix);
   5.252 -    data->outputMix = NULL;
   5.253 -
   5.254 -    SLObjectItf_Destroy(data->engineObject);
   5.255 -    data->engineObject = NULL;
   5.256 -    data->engine = NULL;
   5.257 -
   5.258 -    free(data);
   5.259 -    Device->ExtraData = NULL;
   5.260 -}
   5.261 -
   5.262 -static ALCboolean opensl_reset_playback(ALCdevice *Device)
   5.263 -{
   5.264 -    osl_data *data = Device->ExtraData;
   5.265 -    SLDataLocator_AndroidSimpleBufferQueue loc_bufq;
   5.266 -    SLAndroidSimpleBufferQueueItf bufferQueue;
   5.267 -    SLDataLocator_OutputMix loc_outmix;
   5.268 -    SLDataFormat_PCM format_pcm;
   5.269 -    SLDataSource audioSrc;
   5.270 -    SLDataSink audioSnk;
   5.271 -    SLPlayItf player;
   5.272 -    SLInterfaceID id;
   5.273 -    SLboolean req;
   5.274 -    SLresult result;
   5.275 -    ALuint i;
   5.276 -
   5.277 -
   5.278 -    Device->UpdateSize = (ALuint64)Device->UpdateSize * 44100 / Device->Frequency;
   5.279 -    Device->UpdateSize = Device->UpdateSize * Device->NumUpdates / 2;
   5.280 -    Device->NumUpdates = 2;
   5.281 -
   5.282 -    Device->Frequency = 44100;
   5.283 -    Device->FmtChans = DevFmtStereo;
   5.284 -    Device->FmtType = DevFmtShort;
   5.285 -
   5.286 -    SetDefaultWFXChannelOrder(Device);
   5.287 -
   5.288 -
   5.289 -    id  = SL_IID_ANDROIDSIMPLEBUFFERQUEUE;
   5.290 -    req = SL_BOOLEAN_TRUE;
   5.291 -
   5.292 -    loc_bufq.locatorType = SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE;
   5.293 -    loc_bufq.numBuffers = Device->NumUpdates;
   5.294 -
   5.295 -    format_pcm.formatType = SL_DATAFORMAT_PCM;
   5.296 -    format_pcm.numChannels = ChannelsFromDevFmt(Device->FmtChans);
   5.297 -    format_pcm.samplesPerSec = Device->Frequency * 1000;
   5.298 -    format_pcm.bitsPerSample = BytesFromDevFmt(Device->FmtType) * 8;
   5.299 -    format_pcm.containerSize = format_pcm.bitsPerSample;
   5.300 -    format_pcm.channelMask = GetChannelMask(Device->FmtChans);
   5.301 -    format_pcm.endianness = SL_BYTEORDER_NATIVE;
   5.302 -
   5.303 -    audioSrc.pLocator = &loc_bufq;
   5.304 -    audioSrc.pFormat = &format_pcm;
   5.305 -
   5.306 -    loc_outmix.locatorType = SL_DATALOCATOR_OUTPUTMIX;
   5.307 -    loc_outmix.outputMix = data->outputMix;
   5.308 -    audioSnk.pLocator = &loc_outmix;
   5.309 -    audioSnk.pFormat = NULL;
   5.310 -
   5.311 -
   5.312 -    result = SLEngineItf_CreateAudioPlayer(data->engine, &data->bufferQueueObject, &audioSrc, &audioSnk, 1, &id, &req);
   5.313 -    PRINTERR(result, "engine->CreateAudioPlayer");
   5.314 -    if(SL_RESULT_SUCCESS == result)
   5.315 -    {
   5.316 -        result = SLObjectItf_Realize(data->bufferQueueObject, SL_BOOLEAN_FALSE);
   5.317 -        PRINTERR(result, "bufferQueue->Realize");
   5.318 -    }
   5.319 -    if(SL_RESULT_SUCCESS == result)
   5.320 -    {
   5.321 -        result = SLObjectItf_GetInterface(data->bufferQueueObject, SL_IID_BUFFERQUEUE, &bufferQueue);
   5.322 -        PRINTERR(result, "bufferQueue->GetInterface");
   5.323 -    }
   5.324 -    if(SL_RESULT_SUCCESS == result)
   5.325 -    {
   5.326 -        result = (*bufferQueue)->RegisterCallback(bufferQueue, opensl_callback, Device);
   5.327 -        PRINTERR(result, "bufferQueue->RegisterCallback");
   5.328 -    }
   5.329 -    if(SL_RESULT_SUCCESS == result)
   5.330 -    {
   5.331 -        data->frameSize = FrameSizeFromDevFmt(Device->FmtChans, Device->FmtType);
   5.332 -        data->bufferSize = Device->UpdateSize * data->frameSize;
   5.333 -        data->buffer = calloc(1, data->bufferSize);
   5.334 -        if(!data->buffer)
   5.335 -        {
   5.336 -            result = SL_RESULT_MEMORY_FAILURE;
   5.337 -            PRINTERR(result, "calloc");
   5.338 -        }
   5.339 -    }
   5.340 -    /* enqueue the first buffer to kick off the callbacks */
   5.341 -    for(i = 0;i < Device->NumUpdates;i++)
   5.342 -    {
   5.343 -        if(SL_RESULT_SUCCESS == result)
   5.344 -        {
   5.345 -            result = (*bufferQueue)->Enqueue(bufferQueue, data->buffer, data->bufferSize);
   5.346 -            PRINTERR(result, "bufferQueue->Enqueue");
   5.347 -        }
   5.348 -    }
   5.349 -    if(SL_RESULT_SUCCESS == result)
   5.350 -    {
   5.351 -        result = SLObjectItf_GetInterface(data->bufferQueueObject, SL_IID_PLAY, &player);
   5.352 -        PRINTERR(result, "bufferQueue->GetInterface");
   5.353 -    }
   5.354 -    if(SL_RESULT_SUCCESS == result)
   5.355 -    {
   5.356 -        result = SLPlayItf_SetPlayState(player, SL_PLAYSTATE_PLAYING);
   5.357 -        PRINTERR(result, "player->SetPlayState");
   5.358 -    }
   5.359 -
   5.360 -    if(SL_RESULT_SUCCESS != result)
   5.361 -    {
   5.362 -        if(data->bufferQueueObject != NULL)
   5.363 -            SLObjectItf_Destroy(data->bufferQueueObject);
   5.364 -        data->bufferQueueObject = NULL;
   5.365 -
   5.366 -        free(data->buffer);
   5.367 -        data->buffer = NULL;
   5.368 -        data->bufferSize = 0;
   5.369 -
   5.370 -        return ALC_FALSE;
   5.371 -    }
   5.372 -
   5.373 -    return ALC_TRUE;
   5.374 -}
   5.375 -
   5.376 -
   5.377 -static void opensl_stop_playback(ALCdevice *Device)
   5.378 -{
   5.379 -    osl_data *data = Device->ExtraData;
   5.380 -
   5.381 -    if(data->bufferQueueObject != NULL)
   5.382 -        SLObjectItf_Destroy(data->bufferQueueObject);
   5.383 -    data->bufferQueueObject = NULL;
   5.384 -
   5.385 -    free(data->buffer);
   5.386 -    data->buffer = NULL;
   5.387 -    data->bufferSize = 0;
   5.388 -}
   5.389 -
   5.390 -
   5.391 -static const BackendFuncs opensl_funcs = {
   5.392 -    opensl_open_playback,
   5.393 -    opensl_close_playback,
   5.394 -    opensl_reset_playback,
   5.395 -    opensl_stop_playback,
   5.396 -    NULL,
   5.397 -    NULL,
   5.398 -    NULL,
   5.399 -    NULL,
   5.400 -    NULL,
   5.401 -    NULL
   5.402 -};
   5.403 -
   5.404 -
   5.405 -ALCboolean alc_opensl_init(BackendFuncs *func_list)
   5.406 -{
   5.407 -    *func_list = opensl_funcs;
   5.408 -    return ALC_TRUE;
   5.409 -}
   5.410 -
   5.411 -void alc_opensl_deinit(void)
   5.412 -{
   5.413 -}
   5.414 -
   5.415 -void alc_opensl_probe(enum DevProbe type)
   5.416 -{
   5.417 -    switch(type)
   5.418 -    {
   5.419 -        case DEVICE_PROBE:
   5.420 -            AppendDeviceList(opensl_device);
   5.421 -            break;
   5.422 -        case ALL_DEVICE_PROBE:
   5.423 -            AppendAllDeviceList(opensl_device);
   5.424 -            break;
   5.425 -        case CAPTURE_DEVICE_PROBE:
   5.426 -            break;
   5.427 -    }
   5.428 -}

     6.1 --- a/Alc/backends/oss.c	Tue Oct 25 13:03:35 2011 -0700
     6.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.3 @@ -1,536 +0,0 @@
     6.4 -/**
     6.5 - * OpenAL cross platform audio library
     6.6 - * Copyright (C) 1999-2007 by authors.
     6.7 - * This library is free software; you can redistribute it and/or
     6.8 - *  modify it under the terms of the GNU Library General Public
     6.9 - *  License as published by the Free Software Foundation; either
    6.10 - *  version 2 of the License, or (at your option) any later version.
    6.11 - *
    6.12 - * This library is distributed in the hope that it will be useful,
    6.13 - *  but WITHOUT ANY WARRANTY; without even the implied warranty of
    6.14 - *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    6.15 - *  Library General Public License for more details.
    6.16 - *
    6.17 - * You should have received a copy of the GNU Library General Public
    6.18 - *  License along with this library; if not, write to the
    6.19 - *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    6.20 - *  Boston, MA  02111-1307, USA.
    6.21 - * Or go to http://www.gnu.org/copyleft/lgpl.html
    6.22 - */
    6.23 -
    6.24 -#include "config.h"
    6.25 -
    6.26 -#include <sys/ioctl.h>
    6.27 -#include <sys/types.h>
    6.28 -#include <sys/stat.h>
    6.29 -#include <fcntl.h>
    6.30 -#include <stdlib.h>
    6.31 -#include <stdio.h>
    6.32 -#include <memory.h>
    6.33 -#include <unistd.h>
    6.34 -#include <errno.h>
    6.35 -#include <math.h>
    6.36 -#include "alMain.h"
    6.37 -#include "AL/al.h"
    6.38 -#include "AL/alc.h"
    6.39 -
    6.40 -#include <sys/soundcard.h>
    6.41 -
    6.42 -/*
    6.43 - * The OSS documentation talks about SOUND_MIXER_READ, but the header
    6.44 - * only contains MIXER_READ. Play safe. Same for WRITE.
    6.45 - */
    6.46 -#ifndef SOUND_MIXER_READ
    6.47 -#define SOUND_MIXER_READ MIXER_READ
    6.48 -#endif
    6.49 -#ifndef SOUND_MIXER_WRITE
    6.50 -#define SOUND_MIXER_WRITE MIXER_WRITE
    6.51 -#endif
    6.52 -
    6.53 -static const ALCchar oss_device[] = "OSS Default";
    6.54 -
    6.55 -typedef struct {
    6.56 -    int fd;
    6.57 -    volatile int killNow;
    6.58 -    ALvoid *thread;
    6.59 -
    6.60 -    ALubyte *mix_data;
    6.61 -    int data_size;
    6.62 -
    6.63 -    RingBuffer *ring;
    6.64 -    int doCapture;
    6.65 -} oss_data;
    6.66 -
    6.67 -
    6.68 -static int log2i(ALCuint x)
    6.69 -{
    6.70 -    int y = 0;
    6.71 -    while (x > 1)
    6.72 -    {
    6.73 -        x >>= 1;
    6.74 -        y++;
    6.75 -    }
    6.76 -    return y;
    6.77 -}
    6.78 -
    6.79 -
    6.80 -static ALuint OSSProc(ALvoid *ptr)
    6.81 -{
    6.82 -    ALCdevice *pDevice = (ALCdevice*)ptr;
    6.83 -    oss_data *data = (oss_data*)pDevice->ExtraData;
    6.84 -    ALint frameSize;
    6.85 -    ssize_t wrote;
    6.86 -
    6.87 -    SetRTPriority();
    6.88 -
    6.89 -    frameSize = FrameSizeFromDevFmt(pDevice->FmtChans, pDevice->FmtType);
    6.90 -
    6.91 -    while(!data->killNow && pDevice->Connected)
    6.92 -    {
    6.93 -        ALint len = data->data_size;
    6.94 -        ALubyte *WritePtr = data->mix_data;
    6.95 -
    6.96 -        aluMixData(pDevice, WritePtr, len/frameSize);
    6.97 -        while(len > 0 && !data->killNow)
    6.98 -        {
    6.99 -            wrote = write(data->fd, WritePtr, len);
   6.100 -            if(wrote < 0)
   6.101 -            {
   6.102 -                if(errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR)
   6.103 -                {
   6.104 -                    ERR("write failed: %s\n", strerror(errno));
   6.105 -                    aluHandleDisconnect(pDevice);
   6.106 -                    break;
   6.107 -                }
   6.108 -
   6.109 -                Sleep(1);
   6.110 -                continue;
   6.111 -            }
   6.112 -
   6.113 -            len -= wrote;
   6.114 -            WritePtr += wrote;
   6.115 -        }
   6.116 -    }
   6.117 -
   6.118 -    return 0;
   6.119 -}
   6.120 -
   6.121 -static ALuint OSSCaptureProc(ALvoid *ptr)
   6.122 -{
   6.123 -    ALCdevice *pDevice = (ALCdevice*)ptr;
   6.124 -    oss_data *data = (oss_data*)pDevice->ExtraData;
   6.125 -    int frameSize;
   6.126 -    int amt;
   6.127 -
   6.128 -    SetRTPriority();
   6.129 -
   6.130 -    frameSize = FrameSizeFromDevFmt(pDevice->FmtChans, pDevice->FmtType);
   6.131 -
   6.132 -    while(!data->killNow)
   6.133 -    {
   6.134 -        amt = read(data->fd, data->mix_data, data->data_size);
   6.135 -        if(amt < 0)
   6.136 -        {
   6.137 -            ERR("read failed: %s\n", strerror(errno));
   6.138 -            aluHandleDisconnect(pDevice);
   6.139 -            break;
   6.140 -        }
   6.141 -        if(amt == 0)
   6.142 -        {
   6.143 -            Sleep(1);
   6.144 -            continue;
   6.145 -        }
   6.146 -        if(data->doCapture)
   6.147 -            WriteRingBuffer(data->ring, data->mix_data, amt/frameSize);
   6.148 -    }
   6.149 -
   6.150 -    return 0;
   6.151 -}
   6.152 -
   6.153 -static ALCboolean oss_open_playback(ALCdevice *device, const ALCchar *deviceName)
   6.154 -{
   6.155 -    char driver[64];
   6.156 -    oss_data *data;
   6.157 -
   6.158 -    strncpy(driver, GetConfigValue("oss", "device", "/dev/dsp"), sizeof(driver)-1);
   6.159 -    driver[sizeof(driver)-1] = 0;
   6.160 -    if(!deviceName)
   6.161 -        deviceName = oss_device;
   6.162 -    else if(strcmp(deviceName, oss_device) != 0)
   6.163 -        return ALC_FALSE;
   6.164 -
   6.165 -    data = (oss_data*)calloc(1, sizeof(oss_data));
   6.166 -    data->killNow = 0;
   6.167 -
   6.168 -    data->fd = open(driver, O_WRONLY);
   6.169 -    if(data->fd == -1)
   6.170 -    {
   6.171 -        free(data);
   6.172 -        ERR("Could not open %s: %s\n", driver, strerror(errno));
   6.173 -        return ALC_FALSE;
   6.174 -    }
   6.175 -
   6.176 -    device->szDeviceName = strdup(deviceName);
   6.177 -    device->ExtraData = data;
   6.178 -    return ALC_TRUE;
   6.179 -}
   6.180 -
   6.181 -static void oss_close_playback(ALCdevice *device)
   6.182 -{
   6.183 -    oss_data *data = (oss_data*)device->ExtraData;
   6.184 -
   6.185 -    close(data->fd);
   6.186 -    free(data);
   6.187 -    device->ExtraData = NULL;
   6.188 -}
   6.189 -
   6.190 -static ALCboolean oss_reset_playback(ALCdevice *device)
   6.191 -{
   6.192 -    oss_data *data = (oss_data*)device->ExtraData;
   6.193 -    int numFragmentsLogSize;
   6.194 -    int log2FragmentSize;
   6.195 -    unsigned int periods;
   6.196 -    audio_buf_info info;
   6.197 -    ALuint frameSize;
   6.198 -    int numChannels;
   6.199 -    int ossFormat;
   6.200 -    int ossSpeed;
   6.201 -    char *err;
   6.202 -
   6.203 -    switch(device->FmtType)
   6.204 -    {
   6.205 -        case DevFmtByte:
   6.206 -            ossFormat = AFMT_S8;
   6.207 -            break;
   6.208 -        case DevFmtUByte:
   6.209 -            ossFormat = AFMT_U8;
   6.210 -            break;
   6.211 -        case DevFmtUShort:
   6.212 -        case DevFmtFloat:
   6.213 -            device->FmtType = DevFmtShort;
   6.214 -            /* fall-through */
   6.215 -        case DevFmtShort:
   6.216 -            ossFormat = AFMT_S16_NE;
   6.217 -            break;
   6.218 -    }
   6.219 -
   6.220 -    periods = device->NumUpdates;
   6.221 -    numChannels = ChannelsFromDevFmt(device->FmtChans);
   6.222 -    frameSize = numChannels * BytesFromDevFmt(device->FmtType);
   6.223 -
   6.224 -    ossSpeed = device->Frequency;
   6.225 -    log2FragmentSize = log2i(device->UpdateSize * frameSize);
   6.226 -
   6.227 -    /* according to the OSS spec, 16 bytes are the minimum */
   6.228 -    if (log2FragmentSize < 4)
   6.229 -        log2FragmentSize = 4;
   6.230 -    /* Subtract one period since the temp mixing buffer counts as one. Still
   6.231 -     * need at least two on the card, though. */
   6.232 -    if(periods > 2) periods--;
   6.233 -    numFragmentsLogSize = (periods << 16) | log2FragmentSize;
   6.234 -
   6.235 -#define CHECKERR(func) if((func) < 0) {                                       \
   6.236 -    err = #func;                                                              \
   6.237 -    goto err;                                                                 \
   6.238 -}
   6.239 -    /* Don't fail if SETFRAGMENT fails. We can handle just about anything
   6.240 -     * that's reported back via GETOSPACE */
   6.241 -    ioctl(data->fd, SNDCTL_DSP_SETFRAGMENT, &numFragmentsLogSize);
   6.242 -    CHECKERR(ioctl(data->fd, SNDCTL_DSP_SETFMT, &ossFormat));
   6.243 -    CHECKERR(ioctl(data->fd, SNDCTL_DSP_CHANNELS, &numChannels));
   6.244 -    CHECKERR(ioctl(data->fd, SNDCTL_DSP_SPEED, &ossSpeed));
   6.245 -    CHECKERR(ioctl(data->fd, SNDCTL_DSP_GETOSPACE, &info));
   6.246 -    if(0)
   6.247 -    {
   6.248 -    err:
   6.249 -        ERR("%s failed: %s\n", err, strerror(errno));
   6.250 -        return ALC_FALSE;
   6.251 -    }
   6.252 -#undef CHECKERR
   6.253 -
   6.254 -    if((int)ChannelsFromDevFmt(device->FmtChans) != numChannels)
   6.255 -    {
   6.256 -        ERR("Failed to set %s, got %d channels instead\n", DevFmtChannelsString(device->FmtChans), numChannels);
   6.257 -        return ALC_FALSE;
   6.258 -    }
   6.259 -
   6.260 -    if(!((ossFormat == AFMT_S8 && device->FmtType == DevFmtByte) ||
   6.261 -         (ossFormat == AFMT_U8 && device->FmtType == DevFmtUByte) ||
   6.262 -         (ossFormat == AFMT_S16_NE && device->FmtType == DevFmtShort)))
   6.263 -    {
   6.264 -        ERR("Failed to set %s samples, got OSS format %#x\n", DevFmtTypeString(device->FmtType), ossFormat);
   6.265 -        return ALC_FALSE;
   6.266 -    }
   6.267 -
   6.268 -    if(device->Frequency != (ALuint)ossSpeed)
   6.269 -    {
   6.270 -        if((device->Flags&DEVICE_FREQUENCY_REQUEST))
   6.271 -            ERR("Failed to set %dhz, got %dhz instead\n", device->Frequency, ossSpeed);
   6.272 -        device->Flags &= ~DEVICE_FREQUENCY_REQUEST;
   6.273 -        device->Frequency = ossSpeed;
   6.274 -    }
   6.275 -    device->UpdateSize = info.fragsize / frameSize;
   6.276 -    device->NumUpdates = info.fragments + 1;
   6.277 -
   6.278 -    data->data_size = device->UpdateSize * frameSize;
   6.279 -    data->mix_data = calloc(1, data->data_size);
   6.280 -
   6.281 -    SetDefaultChannelOrder(device);
   6.282 -
   6.283 -    data->thread = StartThread(OSSProc, device);
   6.284 -    if(data->thread == NULL)
   6.285 -    {
   6.286 -        free(data->mix_data);
   6.287 -        data->mix_data = NULL;
   6.288 -        return ALC_FALSE;
   6.289 -    }
   6.290 -
   6.291 -    return ALC_TRUE;
   6.292 -}
   6.293 -
   6.294 -static void oss_stop_playback(ALCdevice *device)
   6.295 -{
   6.296 -    oss_data *data = (oss_data*)device->ExtraData;
   6.297 -
   6.298 -    if(!data->thread)
   6.299 -        return;
   6.300 -
   6.301 -    data->killNow = 1;
   6.302 -    StopThread(data->thread);
   6.303 -    data->thread = NULL;
   6.304 -
   6.305 -    data->killNow = 0;
   6.306 -    if(ioctl(data->fd, SNDCTL_DSP_RESET) != 0)
   6.307 -        ERR("Error resetting device: %s\n", strerror(errno));
   6.308 -
   6.309 -    free(data->mix_data);
   6.310 -    data->mix_data = NULL;
   6.311 -}
   6.312 -
   6.313 -
   6.314 -static ALCboolean oss_open_capture(ALCdevice *device, const ALCchar *deviceName)
   6.315 -{
   6.316 -    int numFragmentsLogSize;
   6.317 -    int log2FragmentSize;
   6.318 -    unsigned int periods;
   6.319 -    audio_buf_info info;
   6.320 -    ALuint frameSize;
   6.321 -    int numChannels;
   6.322 -    char driver[64];
   6.323 -    oss_data *data;
   6.324 -    int ossFormat;
   6.325 -    int ossSpeed;
   6.326 -    char *err;
   6.327 -
   6.328 -    strncpy(driver, GetConfigValue("oss", "capture", "/dev/dsp"), sizeof(driver)-1);
   6.329 -    driver[sizeof(driver)-1] = 0;
   6.330 -    if(!deviceName)
   6.331 -        deviceName = oss_device;
   6.332 -    else if(strcmp(deviceName, oss_device) != 0)
   6.333 -        return ALC_FALSE;
   6.334 -
   6.335 -    data = (oss_data*)calloc(1, sizeof(oss_data));
   6.336 -    data->killNow = 0;
   6.337 -
   6.338 -    data->fd = open(driver, O_RDONLY);
   6.339 -    if(data->fd == -1)
   6.340 -    {
   6.341 -        free(data);
   6.342 -        ERR("Could not open %s: %s\n", driver, strerror(errno));
   6.343 -        return ALC_FALSE;
   6.344 -    }
   6.345 -
   6.346 -    switch(device->FmtType)
   6.347 -    {
   6.348 -        case DevFmtByte:
   6.349 -            ossFormat = AFMT_S8;
   6.350 -            break;
   6.351 -        case DevFmtUByte:
   6.352 -            ossFormat = AFMT_U8;
   6.353 -            break;
   6.354 -        case DevFmtShort:
   6.355 -            ossFormat = AFMT_S16_NE;
   6.356 -            break;
   6.357 -        case DevFmtUShort:
   6.358 -        case DevFmtFloat:
   6.359 -            free(data);
   6.360 -            ERR("%s capture samples not supported on OSS\n", DevFmtTypeString(device->FmtType));
   6.361 -            return ALC_FALSE;
   6.362 -    }
   6.363 -
   6.364 -    periods = 4;
   6.365 -    numChannels = ChannelsFromDevFmt(device->FmtChans);
   6.366 -    frameSize = numChannels * BytesFromDevFmt(device->FmtType);
   6.367 -    ossSpeed = device->Frequency;
   6.368 -    log2FragmentSize = log2i(device->UpdateSize * device->NumUpdates *
   6.369 -                             frameSize / periods);
   6.370 -
   6.371 -    /* according to the OSS spec, 16 bytes are the minimum */
   6.372 -    if (log2FragmentSize < 4)
   6.373 -        log2FragmentSize = 4;
   6.374 -    numFragmentsLogSize = (periods << 16) | log2FragmentSize;
   6.375 -
   6.376 -#define CHECKERR(func) if((func) < 0) {                                       \
   6.377 -    err = #func;                                                              \
   6.378 -    goto err;                                                                 \
   6.379 -}
   6.380 -    CHECKERR(ioctl(data->fd, SNDCTL_DSP_SETFRAGMENT, &numFragmentsLogSize));
   6.381 -    CHECKERR(ioctl(data->fd, SNDCTL_DSP_SETFMT, &ossFormat));
   6.382 -    CHECKERR(ioctl(data->fd, SNDCTL_DSP_CHANNELS, &numChannels));
   6.383 -    CHECKERR(ioctl(data->fd, SNDCTL_DSP_SPEED, &ossSpeed));
   6.384 -    CHECKERR(ioctl(data->fd, SNDCTL_DSP_GETISPACE, &info));
   6.385 -    if(0)
   6.386 -    {
   6.387 -    err:
   6.388 -        ERR("%s failed: %s\n", err, strerror(errno));
   6.389 -        close(data->fd);
   6.390 -        free(data);
   6.391 -        return ALC_FALSE;
   6.392 -    }
   6.393 -#undef CHECKERR
   6.394 -
   6.395 -    if((int)ChannelsFromDevFmt(device->FmtChans) != numChannels)
   6.396 -    {
   6.397 -        ERR("Failed to set %s, got %d channels instead\n", DevFmtChannelsString(device->FmtChans), numChannels);
   6.398 -        close(data->fd);
   6.399 -        free(data);
   6.400 -        return ALC_FALSE;
   6.401 -    }
   6.402 -
   6.403 -    if(!((ossFormat == AFMT_S8 && device->FmtType == DevFmtByte) ||
   6.404 -         (ossFormat == AFMT_U8 && device->FmtType == DevFmtUByte) ||
   6.405 -         (ossFormat == AFMT_S16_NE && device->FmtType == DevFmtShort)))
   6.406 -    {
   6.407 -        ERR("Failed to set %s samples, got OSS format %#x\n", DevFmtTypeString(device->FmtType), ossFormat);
   6.408 -        close(data->fd);
   6.409 -        free(data);
   6.410 -        return ALC_FALSE;
   6.411 -    }
   6.412 -
   6.413 -    data->ring = CreateRingBuffer(frameSize, device->UpdateSize * device->NumUpdates);
   6.414 -    if(!data->ring)
   6.415 -    {
   6.416 -        ERR("Ring buffer create failed\n");
   6.417 -        close(data->fd);
   6.418 -        free(data);
   6.419 -        return ALC_FALSE;
   6.420 -    }
   6.421 -
   6.422 -    data->data_size = info.fragsize;
   6.423 -    data->mix_data = calloc(1, data->data_size);
   6.424 -
   6.425 -    device->ExtraData = data;
   6.426 -    data->thread = StartThread(OSSCaptureProc, device);
   6.427 -    if(data->thread == NULL)
   6.428 -    {
   6.429 -        device->ExtraData = NULL;
   6.430 -        free(data->mix_data);
   6.431 -        free(data);
   6.432 -        return ALC_FALSE;
   6.433 -    }
   6.434 -
   6.435 -    device->szDeviceName = strdup(deviceName);
   6.436 -    return ALC_TRUE;
   6.437 -}
   6.438 -
   6.439 -static void oss_close_capture(ALCdevice *device)
   6.440 -{
   6.441 -    oss_data *data = (oss_data*)device->ExtraData;
   6.442 -    data->killNow = 1;
   6.443 -    StopThread(data->thread);
   6.444 -
   6.445 -    close(data->fd);
   6.446 -
   6.447 -    DestroyRingBuffer(data->ring);
   6.448 -
   6.449 -    free(data->mix_data);
   6.450 -    free(data);
   6.451 -    device->ExtraData = NULL;
   6.452 -}
   6.453 -
   6.454 -static void oss_start_capture(ALCdevice *pDevice)
   6.455 -{
   6.456 -    oss_data *data = (oss_data*)pDevice->ExtraData;
   6.457 -    data->doCapture = 1;
   6.458 -}
   6.459 -
   6.460 -static void oss_stop_capture(ALCdevice *pDevice)
   6.461 -{
   6.462 -    oss_data *data = (oss_data*)pDevice->ExtraData;
   6.463 -    data->doCapture = 0;
   6.464 -}
   6.465 -
   6.466 -static void oss_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
   6.467 -{
   6.468 -    oss_data *data = (oss_data*)pDevice->ExtraData;
   6.469 -    if(lSamples <= (ALCuint)RingBufferSize(data->ring))
   6.470 -        ReadRingBuffer(data->ring, pBuffer, lSamples);
   6.471 -    else
   6.472 -        alcSetError(pDevice, ALC_INVALID_VALUE);
   6.473 -}
   6.474 -
   6.475 -static ALCuint oss_available_samples(ALCdevice *pDevice)
   6.476 -{
   6.477 -    oss_data *data = (oss_data*)pDevice->ExtraData;
   6.478 -    return RingBufferSize(data->ring);
   6.479 -}
   6.480 -
   6.481 -
   6.482 -static const BackendFuncs oss_funcs = {
   6.483 -    oss_open_playback,
   6.484 -    oss_close_playback,
   6.485 -    oss_reset_playback,
   6.486 -    oss_stop_playback,
   6.487 -    oss_open_capture,
   6.488 -    oss_close_capture,
   6.489 -    oss_start_capture,
   6.490 -    oss_stop_capture,
   6.491 -    oss_capture_samples,
   6.492 -    oss_available_samples
   6.493 -};
   6.494 -
   6.495 -ALCboolean alc_oss_init(BackendFuncs *func_list)
   6.496 -{
   6.497 -    *func_list = oss_funcs;
   6.498 -    return ALC_TRUE;
   6.499 -}
   6.500 -
   6.501 -void alc_oss_deinit(void)
   6.502 -{
   6.503 -}
   6.504 -
   6.505 -void alc_oss_probe(enum DevProbe type)
   6.506 -{
   6.507 -    switch(type)
   6.508 -    {
   6.509 -        case DEVICE_PROBE:
   6.510 -        {
   6.511 -#ifdef HAVE_STAT
   6.512 -            struct stat buf;
   6.513 -            if(stat(GetConfigValue("oss", "device", "/dev/dsp"), &buf) == 0)
   6.514 -#endif
   6.515 -                AppendDeviceList(oss_device);
   6.516 -        }
   6.517 -        break;
   6.518 -
   6.519 -        case ALL_DEVICE_PROBE:
   6.520 -        {
   6.521 -#ifdef HAVE_STAT
   6.522 -            struct stat buf;
   6.523 -            if(stat(GetConfigValue("oss", "device", "/dev/dsp"), &buf) == 0)
   6.524 -#endif
   6.525 -                AppendAllDeviceList(oss_device);
   6.526 -        }
   6.527 -        break;
   6.528 -
   6.529 -        case CAPTURE_DEVICE_PROBE:
   6.530 -        {
   6.531 -#ifdef HAVE_STAT
   6.532 -            struct stat buf;
   6.533 -            if(stat(GetConfigValue("oss", "capture", "/dev/dsp"), &buf) == 0)
   6.534 -#endif
   6.535 -                AppendCaptureDeviceList(oss_device);
   6.536 -        }
   6.537 -        break;
   6.538 -    }
   6.539 -}