1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/.hgignore	Tue Oct 25 13:02:31 2011 -0700
     1.3 @@ -0,0 +1,3 @@
     1.4 +syntax: glob
     1.5 +build*
     1.6 +

     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/Alc/ALc.c	Tue Oct 25 13:02:31 2011 -0700
     2.3 @@ -0,0 +1,2681 @@
     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 <math.h>
    2.27 +#include <stdlib.h>
    2.28 +#include <stdio.h>
    2.29 +#include <memory.h>
    2.30 +#include <ctype.h>
    2.31 +
    2.32 +#include "alMain.h"
    2.33 +#include "alSource.h"
    2.34 +#include "AL/al.h"
    2.35 +#include "AL/alc.h"
    2.36 +#include "alThunk.h"
    2.37 +#include "alSource.h"
    2.38 +#include "alBuffer.h"
    2.39 +#include "alAuxEffectSlot.h"
    2.40 +#include "bs2b.h"
    2.41 +#include "alu.h"
    2.42 +
    2.43 +// RLM: try to include the file here.
    2.44 +
    2.45 +
    2.46 +
    2.47 +#define EmptyFuncs { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
    2.48 +static struct BackendInfo BackendList[] = {
    2.49 +#ifdef HAVE_PULSEAUDIO
    2.50 +    { "pulse", alc_pulse_init, alc_pulse_deinit, alc_pulse_probe, EmptyFuncs },
    2.51 +#endif
    2.52 +#ifdef HAVE_ALSA
    2.53 +    { "alsa", alc_alsa_init, alc_alsa_deinit, alc_alsa_probe, EmptyFuncs },
    2.54 +#endif
    2.55 +#ifdef HAVE_COREAUDIO
    2.56 +    { "core", alc_ca_init, alc_ca_deinit, alc_ca_probe, EmptyFuncs },
    2.57 +#endif
    2.58 +#ifdef HAVE_OSS
    2.59 +    { "oss", alc_oss_init, alc_oss_deinit, alc_oss_probe, EmptyFuncs },
    2.60 +#endif
    2.61 +#ifdef HAVE_SOLARIS
    2.62 +    { "solaris", alc_solaris_init, alc_solaris_deinit, alc_solaris_probe, EmptyFuncs },
    2.63 +#endif
    2.64 +#ifdef HAVE_SNDIO
    2.65 +    { "sndio", alc_sndio_init, alc_sndio_deinit, alc_sndio_probe, EmptyFuncs },
    2.66 +#endif
    2.67 +#ifdef HAVE_MMDEVAPI
    2.68 +    { "mmdevapi", alcMMDevApiInit, alcMMDevApiDeinit, alcMMDevApiProbe, EmptyFuncs },
    2.69 +#endif
    2.70 +#ifdef HAVE_DSOUND
    2.71 +    { "dsound", alcDSoundInit, alcDSoundDeinit, alcDSoundProbe, EmptyFuncs },
    2.72 +#endif
    2.73 +#ifdef HAVE_WINMM
    2.74 +    { "winmm", alcWinMMInit, alcWinMMDeinit, alcWinMMProbe, EmptyFuncs },
    2.75 +#endif
    2.76 +#ifdef HAVE_PORTAUDIO
    2.77 +    { "port", alc_pa_init, alc_pa_deinit, alc_pa_probe, EmptyFuncs },
    2.78 +#endif
    2.79 +#ifdef HAVE_OPENSL
    2.80 +    { "opensl", alc_opensl_init, alc_opensl_deinit, alc_opensl_probe, EmptyFuncs },
    2.81 +#endif
    2.82 +
    2.83 +    { "null", alc_null_init, alc_null_deinit, alc_null_probe, EmptyFuncs },
    2.84 +#ifdef HAVE_WAVE
    2.85 +    { "wave", alc_wave_init, alc_wave_deinit, alc_wave_probe, EmptyFuncs },
    2.86 +#endif
    2.87 +    { "send", alc_send_init, alc_send_deinit, alc_send_probe, EmptyFuncs },
    2.88 +    // this entry is so that the list is terminated by a "null" object,
    2.89 +    // and helps things to tell when they've reached the end of the list.
    2.90 +    { NULL, NULL, NULL, NULL, EmptyFuncs }
    2.91 +};
    2.92 +static struct BackendInfo BackendLoopback = {
    2.93 +    "loopback", alc_loopback_init, alc_loopback_deinit, alc_loopback_probe, EmptyFuncs
    2.94 +};
    2.95 +#undef EmptyFuncs
    2.96 +
    2.97 +static struct BackendInfo PlaybackBackend;
    2.98 +static struct BackendInfo CaptureBackend;
    2.99 +
   2.100 +///////////////////////////////////////////////////////
   2.101 +// STRING and EXTENSIONS
   2.102 +
   2.103 +typedef struct ALCfunction {
   2.104 +    const ALCchar *funcName;
   2.105 +    ALCvoid *address;
   2.106 +} ALCfunction;
   2.107 +
   2.108 +typedef struct ALCenums {
   2.109 +    const ALCchar *enumName;
   2.110 +    ALCenum value;
   2.111 +} ALCenums;
   2.112 +
   2.113 +
   2.114 +static const ALCfunction alcFunctions[] = {
   2.115 +    { "alcCreateContext",           (ALCvoid *) alcCreateContext         },
   2.116 +    { "alcMakeContextCurrent",      (ALCvoid *) alcMakeContextCurrent    },
   2.117 +    { "alcProcessContext",          (ALCvoid *) alcProcessContext        },
   2.118 +    { "alcSuspendContext",          (ALCvoid *) alcSuspendContext        },
   2.119 +    { "alcDestroyContext",          (ALCvoid *) alcDestroyContext        },
   2.120 +    { "alcGetCurrentContext",       (ALCvoid *) alcGetCurrentContext     },
   2.121 +    { "alcGetContextsDevice",       (ALCvoid *) alcGetContextsDevice     },
   2.122 +    { "alcOpenDevice",              (ALCvoid *) alcOpenDevice            },
   2.123 +    { "alcCloseDevice",             (ALCvoid *) alcCloseDevice           },
   2.124 +    { "alcGetError",                (ALCvoid *) alcGetError              },
   2.125 +    { "alcIsExtensionPresent",      (ALCvoid *) alcIsExtensionPresent    },
   2.126 +    { "alcGetProcAddress",          (ALCvoid *) alcGetProcAddress        },
   2.127 +    { "alcGetEnumValue",            (ALCvoid *) alcGetEnumValue          },
   2.128 +    { "alcGetString",               (ALCvoid *) alcGetString             },
   2.129 +    { "alcGetIntegerv",             (ALCvoid *) alcGetIntegerv           },
   2.130 +    { "alcCaptureOpenDevice",       (ALCvoid *) alcCaptureOpenDevice     },
   2.131 +    { "alcCaptureCloseDevice",      (ALCvoid *) alcCaptureCloseDevice    },
   2.132 +    { "alcCaptureStart",            (ALCvoid *) alcCaptureStart          },
   2.133 +    { "alcCaptureStop",             (ALCvoid *) alcCaptureStop           },
   2.134 +    { "alcCaptureSamples",          (ALCvoid *) alcCaptureSamples        },
   2.135 +
   2.136 +    { "alcSetThreadContext",        (ALCvoid *) alcSetThreadContext      },
   2.137 +    { "alcGetThreadContext",        (ALCvoid *) alcGetThreadContext      },
   2.138 +
   2.139 +    { "alcLoopbackOpenDeviceSOFT",  (ALCvoid *) alcLoopbackOpenDeviceSOFT},
   2.140 +    { "alcIsRenderFormatSupportedSOFT",(ALCvoid *) alcIsRenderFormatSupportedSOFT},
   2.141 +    { "alcRenderSamplesSOFT",       (ALCvoid *) alcRenderSamplesSOFT         },
   2.142 +
   2.143 +    { "alEnable",                   (ALCvoid *) alEnable                 },
   2.144 +    { "alDisable",                  (ALCvoid *) alDisable                },
   2.145 +    { "alIsEnabled",                (ALCvoid *) alIsEnabled              },
   2.146 +    { "alGetString",                (ALCvoid *) alGetString              },
   2.147 +    { "alGetBooleanv",              (ALCvoid *) alGetBooleanv            },
   2.148 +    { "alGetIntegerv",              (ALCvoid *) alGetIntegerv            },
   2.149 +    { "alGetFloatv",                (ALCvoid *) alGetFloatv              },
   2.150 +    { "alGetDoublev",               (ALCvoid *) alGetDoublev             },
   2.151 +    { "alGetBoolean",               (ALCvoid *) alGetBoolean             },
   2.152 +    { "alGetInteger",               (ALCvoid *) alGetInteger             },
   2.153 +    { "alGetFloat",                 (ALCvoid *) alGetFloat               },
   2.154 +    { "alGetDouble",                (ALCvoid *) alGetDouble              },
   2.155 +    { "alGetError",                 (ALCvoid *) alGetError               },
   2.156 +    { "alIsExtensionPresent",       (ALCvoid *) alIsExtensionPresent     },
   2.157 +    { "alGetProcAddress",           (ALCvoid *) alGetProcAddress         },
   2.158 +    { "alGetEnumValue",             (ALCvoid *) alGetEnumValue           },
   2.159 +    { "alListenerf",                (ALCvoid *) alListenerf              },
   2.160 +    { "alListener3f",               (ALCvoid *) alListener3f             },
   2.161 +    { "alListenerfv",               (ALCvoid *) alListenerfv             },
   2.162 +    { "alListeneri",                (ALCvoid *) alListeneri              },
   2.163 +    { "alListener3i",               (ALCvoid *) alListener3i             },
   2.164 +    { "alListeneriv",               (ALCvoid *) alListeneriv             },
   2.165 +    { "alGetListenerf",             (ALCvoid *) alGetListenerf           },
   2.166 +    { "alGetListener3f",            (ALCvoid *) alGetListener3f          },
   2.167 +    { "alGetListenerfv",            (ALCvoid *) alGetListenerfv          },
   2.168 +    { "alGetListeneri",             (ALCvoid *) alGetListeneri           },
   2.169 +    { "alGetListener3i",            (ALCvoid *) alGetListener3i          },
   2.170 +    { "alGetListeneriv",            (ALCvoid *) alGetListeneriv          },
   2.171 +    { "alGenSources",               (ALCvoid *) alGenSources             },
   2.172 +    { "alDeleteSources",            (ALCvoid *) alDeleteSources          },
   2.173 +    { "alIsSource",                 (ALCvoid *) alIsSource               },
   2.174 +    { "alSourcef",                  (ALCvoid *) alSourcef                },
   2.175 +    { "alSource3f",                 (ALCvoid *) alSource3f               },
   2.176 +    { "alSourcefv",                 (ALCvoid *) alSourcefv               },
   2.177 +    { "alSourcei",                  (ALCvoid *) alSourcei                },
   2.178 +    { "alSource3i",                 (ALCvoid *) alSource3i               },
   2.179 +    { "alSourceiv",                 (ALCvoid *) alSourceiv               },
   2.180 +    { "alGetSourcef",               (ALCvoid *) alGetSourcef             },
   2.181 +    { "alGetSource3f",              (ALCvoid *) alGetSource3f            },
   2.182 +    { "alGetSourcefv",              (ALCvoid *) alGetSourcefv            },
   2.183 +    { "alGetSourcei",               (ALCvoid *) alGetSourcei             },
   2.184 +    { "alGetSource3i",              (ALCvoid *) alGetSource3i            },
   2.185 +    { "alGetSourceiv",              (ALCvoid *) alGetSourceiv            },
   2.186 +    { "alSourcePlayv",              (ALCvoid *) alSourcePlayv            },
   2.187 +    { "alSourceStopv",              (ALCvoid *) alSourceStopv            },
   2.188 +    { "alSourceRewindv",            (ALCvoid *) alSourceRewindv          },
   2.189 +    { "alSourcePausev",             (ALCvoid *) alSourcePausev           },
   2.190 +    { "alSourcePlay",               (ALCvoid *) alSourcePlay             },
   2.191 +    { "alSourceStop",               (ALCvoid *) alSourceStop             },
   2.192 +    { "alSourceRewind",             (ALCvoid *) alSourceRewind           },
   2.193 +    { "alSourcePause",              (ALCvoid *) alSourcePause            },
   2.194 +    { "alSourceQueueBuffers",       (ALCvoid *) alSourceQueueBuffers     },
   2.195 +    { "alSourceUnqueueBuffers",     (ALCvoid *) alSourceUnqueueBuffers   },
   2.196 +    { "alGenBuffers",               (ALCvoid *) alGenBuffers             },
   2.197 +    { "alDeleteBuffers",            (ALCvoid *) alDeleteBuffers          },
   2.198 +    { "alIsBuffer",                 (ALCvoid *) alIsBuffer               },
   2.199 +    { "alBufferData",               (ALCvoid *) alBufferData             },
   2.200 +    { "alBufferf",                  (ALCvoid *) alBufferf                },
   2.201 +    { "alBuffer3f",                 (ALCvoid *) alBuffer3f               },
   2.202 +    { "alBufferfv",                 (ALCvoid *) alBufferfv               },
   2.203 +    { "alBufferi",                  (ALCvoid *) alBufferi                },
   2.204 +    { "alBuffer3i",                 (ALCvoid *) alBuffer3i               },
   2.205 +    { "alBufferiv",                 (ALCvoid *) alBufferiv               },
   2.206 +    { "alGetBufferf",               (ALCvoid *) alGetBufferf             },
   2.207 +    { "alGetBuffer3f",              (ALCvoid *) alGetBuffer3f            },
   2.208 +    { "alGetBufferfv",              (ALCvoid *) alGetBufferfv            },
   2.209 +    { "alGetBufferi",               (ALCvoid *) alGetBufferi             },
   2.210 +    { "alGetBuffer3i",              (ALCvoid *) alGetBuffer3i            },
   2.211 +    { "alGetBufferiv",              (ALCvoid *) alGetBufferiv            },
   2.212 +    { "alDopplerFactor",            (ALCvoid *) alDopplerFactor          },
   2.213 +    { "alDopplerVelocity",          (ALCvoid *) alDopplerVelocity        },
   2.214 +    { "alSpeedOfSound",             (ALCvoid *) alSpeedOfSound           },
   2.215 +    { "alDistanceModel",            (ALCvoid *) alDistanceModel          },
   2.216 +
   2.217 +    { "alGenFilters",               (ALCvoid *) alGenFilters             },
   2.218 +    { "alDeleteFilters",            (ALCvoid *) alDeleteFilters          },
   2.219 +    { "alIsFilter",                 (ALCvoid *) alIsFilter               },
   2.220 +    { "alFilteri",                  (ALCvoid *) alFilteri                },
   2.221 +    { "alFilteriv",                 (ALCvoid *) alFilteriv               },
   2.222 +    { "alFilterf",                  (ALCvoid *) alFilterf                },
   2.223 +    { "alFilterfv",                 (ALCvoid *) alFilterfv               },
   2.224 +    { "alGetFilteri",               (ALCvoid *) alGetFilteri             },
   2.225 +    { "alGetFilteriv",              (ALCvoid *) alGetFilteriv            },
   2.226 +    { "alGetFilterf",               (ALCvoid *) alGetFilterf             },
   2.227 +    { "alGetFilterfv",              (ALCvoid *) alGetFilterfv            },
   2.228 +    { "alGenEffects",               (ALCvoid *) alGenEffects             },
   2.229 +    { "alDeleteEffects",            (ALCvoid *) alDeleteEffects          },
   2.230 +    { "alIsEffect",                 (ALCvoid *) alIsEffect               },
   2.231 +    { "alEffecti",                  (ALCvoid *) alEffecti                },
   2.232 +    { "alEffectiv",                 (ALCvoid *) alEffectiv               },
   2.233 +    { "alEffectf",                  (ALCvoid *) alEffectf                },
   2.234 +    { "alEffectfv",                 (ALCvoid *) alEffectfv               },
   2.235 +    { "alGetEffecti",               (ALCvoid *) alGetEffecti             },
   2.236 +    { "alGetEffectiv",              (ALCvoid *) alGetEffectiv            },
   2.237 +    { "alGetEffectf",               (ALCvoid *) alGetEffectf             },
   2.238 +    { "alGetEffectfv",              (ALCvoid *) alGetEffectfv            },
   2.239 +    { "alGenAuxiliaryEffectSlots",  (ALCvoid *) alGenAuxiliaryEffectSlots},
   2.240 +    { "alDeleteAuxiliaryEffectSlots",(ALCvoid *) alDeleteAuxiliaryEffectSlots},
   2.241 +    { "alIsAuxiliaryEffectSlot",    (ALCvoid *) alIsAuxiliaryEffectSlot  },
   2.242 +    { "alAuxiliaryEffectSloti",     (ALCvoid *) alAuxiliaryEffectSloti   },
   2.243 +    { "alAuxiliaryEffectSlotiv",    (ALCvoid *) alAuxiliaryEffectSlotiv  },
   2.244 +    { "alAuxiliaryEffectSlotf",     (ALCvoid *) alAuxiliaryEffectSlotf   },
   2.245 +    { "alAuxiliaryEffectSlotfv",    (ALCvoid *) alAuxiliaryEffectSlotfv  },
   2.246 +    { "alGetAuxiliaryEffectSloti",  (ALCvoid *) alGetAuxiliaryEffectSloti},
   2.247 +    { "alGetAuxiliaryEffectSlotiv", (ALCvoid *) alGetAuxiliaryEffectSlotiv},
   2.248 +    { "alGetAuxiliaryEffectSlotf",  (ALCvoid *) alGetAuxiliaryEffectSlotf},
   2.249 +    { "alGetAuxiliaryEffectSlotfv", (ALCvoid *) alGetAuxiliaryEffectSlotfv},
   2.250 +
   2.251 +    { "alBufferSubDataSOFT",        (ALCvoid *) alBufferSubDataSOFT      },
   2.252 +
   2.253 +    { "alBufferSamplesSOFT",        (ALCvoid *) alBufferSamplesSOFT      },
   2.254 +    { "alBufferSubSamplesSOFT",     (ALCvoid *) alBufferSubSamplesSOFT   },
   2.255 +    { "alGetBufferSamplesSOFT",     (ALCvoid *) alGetBufferSamplesSOFT   },
   2.256 +    { "alIsBufferFormatSupportedSOFT",(ALCvoid *) alIsBufferFormatSupportedSOFT},
   2.257 +
   2.258 +    { "alDeferUpdatesSOFT",         (ALCvoid *) alDeferUpdatesSOFT       },
   2.259 +    { "alProcessUpdatesSOFT",       (ALCvoid *) alProcessUpdatesSOFT     },
   2.260 +
   2.261 +    { NULL,                         (ALCvoid *) NULL                     }
   2.262 +};
   2.263 +
   2.264 +static const ALCenums enumeration[] = {
   2.265 +    // Types
   2.266 +    { "ALC_INVALID",                          ALC_INVALID                         },
   2.267 +    { "ALC_FALSE",                            ALC_FALSE                           },
   2.268 +    { "ALC_TRUE",                             ALC_TRUE                            },
   2.269 +
   2.270 +    // ALC Properties
   2.271 +    { "ALC_MAJOR_VERSION",                    ALC_MAJOR_VERSION                   },
   2.272 +    { "ALC_MINOR_VERSION",                    ALC_MINOR_VERSION                   },
   2.273 +    { "ALC_ATTRIBUTES_SIZE",                  ALC_ATTRIBUTES_SIZE                 },
   2.274 +    { "ALC_ALL_ATTRIBUTES",                   ALC_ALL_ATTRIBUTES                  },
   2.275 +    { "ALC_DEFAULT_DEVICE_SPECIFIER",         ALC_DEFAULT_DEVICE_SPECIFIER        },
   2.276 +    { "ALC_DEVICE_SPECIFIER",                 ALC_DEVICE_SPECIFIER                },
   2.277 +    { "ALC_ALL_DEVICES_SPECIFIER",            ALC_ALL_DEVICES_SPECIFIER           },
   2.278 +    { "ALC_DEFAULT_ALL_DEVICES_SPECIFIER",    ALC_DEFAULT_ALL_DEVICES_SPECIFIER   },
   2.279 +    { "ALC_EXTENSIONS",                       ALC_EXTENSIONS                      },
   2.280 +    { "ALC_FREQUENCY",                        ALC_FREQUENCY                       },
   2.281 +    { "ALC_REFRESH",                          ALC_REFRESH                         },
   2.282 +    { "ALC_SYNC",                             ALC_SYNC                            },
   2.283 +    { "ALC_MONO_SOURCES",                     ALC_MONO_SOURCES                    },
   2.284 +    { "ALC_STEREO_SOURCES",                   ALC_STEREO_SOURCES                  },
   2.285 +    { "ALC_CAPTURE_DEVICE_SPECIFIER",         ALC_CAPTURE_DEVICE_SPECIFIER        },
   2.286 +    { "ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER", ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER},
   2.287 +    { "ALC_CAPTURE_SAMPLES",                  ALC_CAPTURE_SAMPLES                 },
   2.288 +    { "ALC_CONNECTED",                        ALC_CONNECTED                       },
   2.289 +
   2.290 +    // EFX Properties
   2.291 +    { "ALC_EFX_MAJOR_VERSION",                ALC_EFX_MAJOR_VERSION               },
   2.292 +    { "ALC_EFX_MINOR_VERSION",                ALC_EFX_MINOR_VERSION               },
   2.293 +    { "ALC_MAX_AUXILIARY_SENDS",              ALC_MAX_AUXILIARY_SENDS             },
   2.294 +
   2.295 +    // Loopback device Properties
   2.296 +    { "ALC_FORMAT_CHANNELS_SOFT",             ALC_FORMAT_CHANNELS_SOFT            },
   2.297 +    { "ALC_FORMAT_TYPE_SOFT",                 ALC_FORMAT_TYPE_SOFT                },
   2.298 +
   2.299 +    // Buffer Channel Configurations
   2.300 +    { "ALC_MONO",                             ALC_MONO                            },
   2.301 +    { "ALC_STEREO",                           ALC_STEREO                          },
   2.302 +    { "ALC_QUAD",                             ALC_QUAD                            },
   2.303 +    { "ALC_5POINT1",                          ALC_5POINT1                         },
   2.304 +    { "ALC_6POINT1",                          ALC_6POINT1                         },
   2.305 +    { "ALC_7POINT1",                          ALC_7POINT1                         },
   2.306 +
   2.307 +    // Buffer Sample Types
   2.308 +    { "ALC_BYTE",                             ALC_BYTE                            },
   2.309 +    { "ALC_UNSIGNED_BYTE",                    ALC_UNSIGNED_BYTE                   },
   2.310 +    { "ALC_SHORT",                            ALC_SHORT                           },
   2.311 +    { "ALC_UNSIGNED_SHORT",                   ALC_UNSIGNED_SHORT                  },
   2.312 +    { "ALC_INT",                              ALC_INT                             },
   2.313 +    { "ALC_UNSIGNED_INT",                     ALC_UNSIGNED_INT                    },
   2.314 +    { "ALC_FLOAT",                            ALC_FLOAT                           },
   2.315 +
   2.316 +    // ALC Error Message
   2.317 +    { "ALC_NO_ERROR",                         ALC_NO_ERROR                        },
   2.318 +    { "ALC_INVALID_DEVICE",                   ALC_INVALID_DEVICE                  },
   2.319 +    { "ALC_INVALID_CONTEXT",                  ALC_INVALID_CONTEXT                 },
   2.320 +    { "ALC_INVALID_ENUM",                     ALC_INVALID_ENUM                    },
   2.321 +    { "ALC_INVALID_VALUE",                    ALC_INVALID_VALUE                   },
   2.322 +    { "ALC_OUT_OF_MEMORY",                    ALC_OUT_OF_MEMORY                   },
   2.323 +
   2.324 +    { NULL,                                   (ALCenum)0 }
   2.325 +};
   2.326 +// Error strings
   2.327 +static const ALCchar alcNoError[] = "No Error";
   2.328 +static const ALCchar alcErrInvalidDevice[] = "Invalid Device";
   2.329 +static const ALCchar alcErrInvalidContext[] = "Invalid Context";
   2.330 +static const ALCchar alcErrInvalidEnum[] = "Invalid Enum";
   2.331 +static const ALCchar alcErrInvalidValue[] = "Invalid Value";
   2.332 +static const ALCchar alcErrOutOfMemory[] = "Out of Memory";
   2.333 +
   2.334 +/* Device lists. Sizes only include the first ending null character, not the
   2.335 + * second */
   2.336 +static ALCchar *alcDeviceList;
   2.337 +static size_t alcDeviceListSize;
   2.338 +static ALCchar *alcAllDeviceList;
   2.339 +static size_t alcAllDeviceListSize;
   2.340 +static ALCchar *alcCaptureDeviceList;
   2.341 +static size_t alcCaptureDeviceListSize;
   2.342 +/* Default is always the first in the list */
   2.343 +static ALCchar *alcDefaultDeviceSpecifier;
   2.344 +static ALCchar *alcDefaultAllDeviceSpecifier;
   2.345 +static ALCchar *alcCaptureDefaultDeviceSpecifier;
   2.346 +
   2.347 +
   2.348 +static const ALCchar alcNoDeviceExtList[] =
   2.349 +    "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "
   2.350 +    "ALC_EXT_thread_local_context ALC_SOFTX_loopback_device";
   2.351 +static const ALCchar alcExtensionList[] =
   2.352 +    "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "
   2.353 +    "ALC_EXT_DEDICATED ALC_EXT_disconnect ALC_EXT_EFX "
   2.354 +    "ALC_EXT_thread_local_context ALC_SOFTX_loopback_device";
   2.355 +static const ALCint alcMajorVersion = 1;
   2.356 +static const ALCint alcMinorVersion = 1;
   2.357 +
   2.358 +static const ALCint alcEFXMajorVersion = 1;
   2.359 +static const ALCint alcEFXMinorVersion = 0;
   2.360 +
   2.361 +///////////////////////////////////////////////////////
   2.362 +
   2.363 +
   2.364 +///////////////////////////////////////////////////////
   2.365 +// Global Variables
   2.366 +
   2.367 +static CRITICAL_SECTION ListLock;
   2.368 +
   2.369 +/* Device List */
   2.370 +static ALCdevice *g_pDeviceList = NULL;
   2.371 +static ALCuint    g_ulDeviceCount = 0;
   2.372 +
   2.373 +// Context List
   2.374 +static ALCcontext *g_pContextList = NULL;
   2.375 +static ALCuint     g_ulContextCount = 0;
   2.376 +
   2.377 +// Thread-local current context
   2.378 +static tls_type LocalContext;
   2.379 +// Process-wide current context
   2.380 +static ALCcontext *GlobalContext;
   2.381 +
   2.382 +// Context Error
   2.383 +static ALCenum g_eLastNullDeviceError = ALC_NO_ERROR;
   2.384 +
   2.385 +// Default context extensions
   2.386 +static const ALchar alExtList[] =
   2.387 +    "AL_EXT_DOUBLE AL_EXT_EXPONENT_DISTANCE AL_EXT_FLOAT32 AL_EXT_IMA4 "
   2.388 +    "AL_EXT_LINEAR_DISTANCE AL_EXT_MCFORMATS AL_EXT_MULAW "
   2.389 +    "AL_EXT_MULAW_MCFORMATS AL_EXT_OFFSET AL_EXT_source_distance_model "
   2.390 +    "AL_LOKI_quadriphonic AL_SOFTX_buffer_samples AL_SOFT_buffer_sub_data "
   2.391 +    "AL_SOFTX_deferred_updates AL_SOFT_loop_points "
   2.392 +    "AL_SOFTX_non_virtual_channels";
   2.393 +
   2.394 +// Mixing Priority Level
   2.395 +ALint RTPrioLevel;
   2.396 +
   2.397 +// Output Log File
   2.398 +FILE *LogFile;
   2.399 +
   2.400 +// Output Log Level
   2.401 +#ifdef _DEBUG
   2.402 +enum LogLevel LogLevel = LogWarning;
   2.403 +#else
   2.404 +enum LogLevel LogLevel = LogError;
   2.405 +#endif
   2.406 +
   2.407 +// Cone scalar
   2.408 +ALdouble ConeScale = 0.5;
   2.409 +
   2.410 +// Localized Z scalar for mono sources
   2.411 +ALdouble ZScale = 1.0;
   2.412 +
   2.413 +/* One-time configuration init control */
   2.414 +static pthread_once_t alc_config_once = PTHREAD_ONCE_INIT;
   2.415 +
   2.416 +///////////////////////////////////////////////////////
   2.417 +
   2.418 +
   2.419 +///////////////////////////////////////////////////////
   2.420 +// ALC Related helper functions
   2.421 +static void ReleaseALC(ALCboolean doclose);
   2.422 +
   2.423 +static void alc_initconfig(void);
   2.424 +#define DO_INITCONFIG() pthread_once(&alc_config_once, alc_initconfig)
   2.425 +
   2.426 +#if defined(_WIN32)
   2.427 +static void alc_init(void);
   2.428 +static void alc_deinit(void);
   2.429 +static void alc_deinit_safe(void);
   2.430 +
   2.431 +#ifndef AL_LIBTYPE_STATIC
   2.432 +BOOL APIENTRY DllMain(HANDLE hModule,DWORD ul_reason_for_call,LPVOID lpReserved)
   2.433 +{
   2.434 +    // Perform actions based on the reason for calling.
   2.435 +    switch(ul_reason_for_call)
   2.436 +    {
   2.437 +        case DLL_PROCESS_ATTACH:
   2.438 +            DisableThreadLibraryCalls(hModule);
   2.439 +            alc_init();
   2.440 +            break;
   2.441 +
   2.442 +        case DLL_PROCESS_DETACH:
   2.443 +            if(!lpReserved)
   2.444 +                alc_deinit();
   2.445 +            else
   2.446 +                alc_deinit_safe();
   2.447 +            break;
   2.448 +    }
   2.449 +    return TRUE;
   2.450 +}
   2.451 +#elif defined(_MSC_VER)
   2.452 +#pragma section(".CRT$XCU",read)
   2.453 +static void alc_constructor(void);
   2.454 +static void alc_destructor(void);
   2.455 +__declspec(allocate(".CRT$XCU")) void (__cdecl* alc_constructor_)(void) = alc_constructor;
   2.456 +
   2.457 +static void alc_constructor(void)
   2.458 +{
   2.459 +    atexit(alc_destructor);
   2.460 +    alc_init();
   2.461 +}
   2.462 +
   2.463 +static void alc_destructor(void)
   2.464 +{
   2.465 +    alc_deinit();
   2.466 +}
   2.467 +#elif defined(HAVE_GCC_DESTRUCTOR)
   2.468 +static void alc_init(void) __attribute__((constructor));
   2.469 +static void alc_deinit(void) __attribute__((destructor));
   2.470 +#else
   2.471 +#error "No static initialization available on this platform!"
   2.472 +#endif
   2.473 +#elif defined(HAVE_GCC_DESTRUCTOR)
   2.474 +static void alc_init(void) __attribute__((constructor));
   2.475 +static void alc_deinit(void) __attribute__((destructor));
   2.476 +#else
   2.477 +#error "No global initialization available on this platform!"
   2.478 +#endif
   2.479 +
   2.480 +static void alc_init(void)
   2.481 +{
   2.482 +    const char *str;
   2.483 +
   2.484 +    LogFile = stderr;
   2.485 +
   2.486 +    str = getenv("__ALSOFT_HALF_ANGLE_CONES");
   2.487 +    if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
   2.488 +        ConeScale = 1.0;
   2.489 +
   2.490 +    str = getenv("__ALSOFT_REVERSE_Z");
   2.491 +    if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
   2.492 +        ZScale = -1.0;
   2.493 +
   2.494 +    tls_create(&LocalContext);
   2.495 +    InitializeCriticalSection(&ListLock);
   2.496 +    ThunkInit();
   2.497 +}
   2.498 +
   2.499 +static void alc_deinit_safe(void)
   2.500 +{
   2.501 +    ReleaseALC(ALC_FALSE);
   2.502 +
   2.503 +    FreeALConfig();
   2.504 +
   2.505 +    ThunkExit();
   2.506 +    DeleteCriticalSection(&ListLock);
   2.507 +    tls_delete(LocalContext);
   2.508 +
   2.509 +    if(LogFile != stderr)
   2.510 +        fclose(LogFile);
   2.511 +    LogFile = NULL;
   2.512 +}
   2.513 +
   2.514 +static void alc_deinit(void)
   2.515 +{
   2.516 +    int i;
   2.517 +
   2.518 +    ReleaseALC(ALC_TRUE);
   2.519 +
   2.520 +    memset(&PlaybackBackend, 0, sizeof(PlaybackBackend));
   2.521 +    memset(&CaptureBackend, 0, sizeof(CaptureBackend));
   2.522 +
   2.523 +    for(i = 0;BackendList[i].Deinit;i++)
   2.524 +        BackendList[i].Deinit();
   2.525 +    BackendLoopback.Deinit();
   2.526 +
   2.527 +    alc_deinit_safe();
   2.528 +}
   2.529 +
   2.530 +static void alc_initconfig(void)
   2.531 +{
   2.532 +  printf("OPENAL-AURELLEM: alc_init_config!!\n");
   2.533 +    const char *devs, *str;
   2.534 +    int i, n;
   2.535 +
   2.536 +    str = getenv("ALSOFT_LOGLEVEL");
   2.537 +    if(str)
   2.538 +    {
   2.539 +        long lvl = strtol(str, NULL, 0);
   2.540 +        if(lvl >= NoLog && lvl <= LogTrace)
   2.541 +            LogLevel = lvl;
   2.542 +    }
   2.543 +
   2.544 +    str = getenv("ALSOFT_LOGFILE");
   2.545 +    if(str && str[0])
   2.546 +    {
   2.547 +        FILE *logfile = fopen(str, "wat");
   2.548 +        if(logfile) LogFile = logfile;
   2.549 +        else ERR("Failed to open log file '%s'\n", str);
   2.550 +    }
   2.551 +
   2.552 +    ReadALConfig();
   2.553 +
   2.554 +    InitHrtf();
   2.555 +
   2.556 +#ifdef _WIN32
   2.557 +    RTPrioLevel = GetConfigValueInt(NULL, "rt-prio", 1);
   2.558 +#else
   2.559 +    RTPrioLevel = GetConfigValueInt(NULL, "rt-prio", 0);
   2.560 +#endif
   2.561 +
   2.562 +    DefaultResampler = GetConfigValueInt(NULL, "resampler", RESAMPLER_DEFAULT);
   2.563 +    if(DefaultResampler >= RESAMPLER_MAX || DefaultResampler <= RESAMPLER_MIN)
   2.564 +        DefaultResampler = RESAMPLER_DEFAULT;
   2.565 +
   2.566 +    ReverbBoost *= aluPow(10.0f, GetConfigValueFloat("reverb", "boost", 0.0f) /
   2.567 +                                 20.0f);
   2.568 +    EmulateEAXReverb = GetConfigValueBool("reverb", "emulate-eax", AL_FALSE);
   2.569 +
   2.570 +    devs = GetConfigValue(NULL, "drivers", "");
   2.571 +    //printf("these are the devices: %s\n", devs);
   2.572 +
   2.573 +    if(devs[0])
   2.574 +    {
   2.575 +        int n;
   2.576 +        size_t len;
   2.577 +        const char *next = devs;
   2.578 +        int endlist, delitem;
   2.579 +
   2.580 +        i = 0;
   2.581 +        do {
   2.582 +            devs = next;
   2.583 +	    //printf("AURELLEM: devs is %s\n",devs);
   2.584 +            next = strchr(devs, ',');
   2.585 +
   2.586 +            delitem = (devs[0] == '-');
   2.587 +            if(devs[0] == '-') devs++;
   2.588 +
   2.589 +            if(!devs[0] || devs[0] == ',')
   2.590 +            {
   2.591 +                endlist = 0;
   2.592 +                continue;
   2.593 +            }
   2.594 +            endlist = 1;
   2.595 +
   2.596 +            len = (next ? ((size_t)(next-devs)) : strlen(devs));
   2.597 +            for(n = i;BackendList[n].Init;n++)
   2.598 +            {
   2.599 +	      //printf("AURELLEM: device-name -- %s\n",BackendList[n].name);
   2.600 +                if(len == strlen(BackendList[n].name) &&
   2.601 +                   strncmp(BackendList[n].name, devs, len) == 0)
   2.602 +                {
   2.603 +                    if(delitem)
   2.604 +                    {
   2.605 +                        do {
   2.606 +                            BackendList[n] = BackendList[n+1];
   2.607 +                            ++n;
   2.608 +                        } 
   2.609 +			// this relies on the last entry being terminated by an
   2.610 +			// entry with all nulls.  
   2.611 +			while(BackendList[n].Init);
   2.612 +                    }
   2.613 +                    else
   2.614 +                    {
   2.615 +                        struct BackendInfo Bkp = BackendList[n];
   2.616 +                        while(n > i)
   2.617 +                        {
   2.618 +                            BackendList[n] = BackendList[n-1];
   2.619 +                            --n;
   2.620 +                        }
   2.621 +                        BackendList[n] = Bkp;
   2.622 +
   2.623 +                        i++;
   2.624 +                    }
   2.625 +                    break;
   2.626 +                }
   2.627 +            }
   2.628 +        } while(next++);
   2.629 +
   2.630 +        if(endlist)
   2.631 +        {
   2.632 +            BackendList[i].name = NULL;
   2.633 +            BackendList[i].Init = NULL;
   2.634 +            BackendList[i].Deinit = NULL;
   2.635 +            BackendList[i].Probe = NULL;
   2.636 +        }
   2.637 +    }
   2.638 +
   2.639 +    for(i = 0;BackendList[i].Init && (!PlaybackBackend.name || !CaptureBackend.name);i++)
   2.640 +    {
   2.641 +        if(!BackendList[i].Init(&BackendList[i].Funcs))
   2.642 +        {
   2.643 +            WARN("Failed to initialize backend \"%s\"\n", BackendList[i].name);
   2.644 +            continue;
   2.645 +        }
   2.646 +
   2.647 +        TRACE("Initialized backend \"%s\"\n", BackendList[i].name);
   2.648 +        if(BackendList[i].Funcs.OpenPlayback && !PlaybackBackend.name)
   2.649 +        {
   2.650 +            PlaybackBackend = BackendList[i];
   2.651 +            TRACE("Added \"%s\" for playback\n", PlaybackBackend.name);
   2.652 +        }
   2.653 +        if(BackendList[i].Funcs.OpenCapture && !CaptureBackend.name)
   2.654 +        {
   2.655 +            CaptureBackend = BackendList[i];
   2.656 +            TRACE("Added \"%s\" for capture\n", CaptureBackend.name);
   2.657 +        }
   2.658 +    }
   2.659 +    BackendLoopback.Init(&BackendLoopback.Funcs);
   2.660 +
   2.661 +    str = GetConfigValue(NULL, "excludefx", "");
   2.662 +    if(str[0])
   2.663 +    {
   2.664 +        size_t len;
   2.665 +        const char *next = str;
   2.666 +
   2.667 +        do {
   2.668 +            str = next;
   2.669 +            next = strchr(str, ',');
   2.670 +
   2.671 +            if(!str[0] || next == str)
   2.672 +                continue;
   2.673 +
   2.674 +            len = (next ? ((size_t)(next-str)) : strlen(str));
   2.675 +            for(n = 0;EffectList[n].name;n++)
   2.676 +            {
   2.677 +                if(len == strlen(EffectList[n].name) &&
   2.678 +                   strncmp(EffectList[n].name, str, len) == 0)
   2.679 +                    DisabledEffects[EffectList[n].type] = AL_TRUE;
   2.680 +            }
   2.681 +        } while(next++);
   2.682 +    }
   2.683 +}
   2.684 +
   2.685 +
   2.686 +static void ProbeList(ALCchar **list, size_t *listsize, enum DevProbe type)
   2.687 +{
   2.688 +    free(*list);
   2.689 +    *list = NULL;
   2.690 +    *listsize = 0;
   2.691 +
   2.692 +    DO_INITCONFIG();
   2.693 +    if(type == CAPTURE_DEVICE_PROBE)
   2.694 +        CaptureBackend.Probe(type);
   2.695 +    else
   2.696 +        PlaybackBackend.Probe(type);
   2.697 +}
   2.698 +
   2.699 +static void ProbeDeviceList(void)
   2.700 +{ ProbeList(&alcDeviceList, &alcDeviceListSize, DEVICE_PROBE); }
   2.701 +static void ProbeAllDeviceList(void)
   2.702 +{ ProbeList(&alcAllDeviceList, &alcAllDeviceListSize, ALL_DEVICE_PROBE); }
   2.703 +static void ProbeCaptureDeviceList(void)
   2.704 +{ ProbeList(&alcCaptureDeviceList, &alcCaptureDeviceListSize, CAPTURE_DEVICE_PROBE); }
   2.705 +
   2.706 +
   2.707 +static void AppendList(const ALCchar *name, ALCchar **List, size_t *ListSize)
   2.708 +{
   2.709 +    size_t len = strlen(name);
   2.710 +    void *temp;
   2.711 +
   2.712 +    if(len == 0)
   2.713 +        return;
   2.714 +
   2.715 +    temp = realloc(*List, (*ListSize) + len + 2);
   2.716 +    if(!temp)
   2.717 +    {
   2.718 +        ERR("Realloc failed to add %s!\n", name);
   2.719 +        return;
   2.720 +    }
   2.721 +    *List = temp;
   2.722 +
   2.723 +    memcpy((*List)+(*ListSize), name, len+1);
   2.724 +    *ListSize += len+1;
   2.725 +    (*List)[*ListSize] = 0;
   2.726 +}
   2.727 +
   2.728 +#define DECL_APPEND_LIST_FUNC(type)                                          \
   2.729 +void Append##type##List(const ALCchar *name)                                 \
   2.730 +{ AppendList(name, &alc##type##List, &alc##type##ListSize); }
   2.731 +
   2.732 +DECL_APPEND_LIST_FUNC(Device)
   2.733 +DECL_APPEND_LIST_FUNC(AllDevice)
   2.734 +DECL_APPEND_LIST_FUNC(CaptureDevice)
   2.735 +
   2.736 +#undef DECL_APPEND_LIST_FUNC
   2.737 +
   2.738 +
   2.739 +/* Sets the default channel order used by most non-WaveFormatEx-based APIs */
   2.740 +void SetDefaultChannelOrder(ALCdevice *device)
   2.741 +{
   2.742 +    switch(device->FmtChans)
   2.743 +    {
   2.744 +    case DevFmtX51: device->DevChannels[0] = FRONT_LEFT;
   2.745 +                    device->DevChannels[1] = FRONT_RIGHT;
   2.746 +                    device->DevChannels[2] = BACK_LEFT;
   2.747 +                    device->DevChannels[3] = BACK_RIGHT;
   2.748 +                    device->DevChannels[4] = FRONT_CENTER;
   2.749 +                    device->DevChannels[5] = LFE;
   2.750 +                    return;
   2.751 +
   2.752 +    case DevFmtX71: device->DevChannels[0] = FRONT_LEFT;
   2.753 +                    device->DevChannels[1] = FRONT_RIGHT;
   2.754 +                    device->DevChannels[2] = BACK_LEFT;
   2.755 +                    device->DevChannels[3] = BACK_RIGHT;
   2.756 +                    device->DevChannels[4] = FRONT_CENTER;
   2.757 +                    device->DevChannels[5] = LFE;
   2.758 +                    device->DevChannels[6] = SIDE_LEFT;
   2.759 +                    device->DevChannels[7] = SIDE_RIGHT;
   2.760 +                    return;
   2.761 +
   2.762 +    /* Same as WFX order */
   2.763 +    case DevFmtMono:
   2.764 +    case DevFmtStereo:
   2.765 +    case DevFmtQuad:
   2.766 +    case DevFmtX51Side:
   2.767 +    case DevFmtX61:
   2.768 +        break;
   2.769 +    }
   2.770 +    SetDefaultWFXChannelOrder(device);
   2.771 +}
   2.772 +/* Sets the default order used by WaveFormatEx */
   2.773 +void SetDefaultWFXChannelOrder(ALCdevice *device)
   2.774 +{
   2.775 +    switch(device->FmtChans)
   2.776 +    {
   2.777 +    case DevFmtMono: device->DevChannels[0] = FRONT_CENTER; break;
   2.778 +
   2.779 +    case DevFmtStereo: device->DevChannels[0] = FRONT_LEFT;
   2.780 +                       device->DevChannels[1] = FRONT_RIGHT; break;
   2.781 +
   2.782 +    case DevFmtQuad: device->DevChannels[0] = FRONT_LEFT;
   2.783 +                     device->DevChannels[1] = FRONT_RIGHT;
   2.784 +                     device->DevChannels[2] = BACK_LEFT;
   2.785 +                     device->DevChannels[3] = BACK_RIGHT; break;
   2.786 +
   2.787 +    case DevFmtX51: device->DevChannels[0] = FRONT_LEFT;
   2.788 +                    device->DevChannels[1] = FRONT_RIGHT;
   2.789 +                    device->DevChannels[2] = FRONT_CENTER;
   2.790 +                    device->DevChannels[3] = LFE;
   2.791 +                    device->DevChannels[4] = BACK_LEFT;
   2.792 +                    device->DevChannels[5] = BACK_RIGHT; break;
   2.793 +
   2.794 +    case DevFmtX51Side: device->DevChannels[0] = FRONT_LEFT;
   2.795 +                        device->DevChannels[1] = FRONT_RIGHT;
   2.796 +                        device->DevChannels[2] = FRONT_CENTER;
   2.797 +                        device->DevChannels[3] = LFE;
   2.798 +                        device->DevChannels[4] = SIDE_LEFT;
   2.799 +                        device->DevChannels[5] = SIDE_RIGHT; break;
   2.800 +
   2.801 +    case DevFmtX61: device->DevChannels[0] = FRONT_LEFT;
   2.802 +                    device->DevChannels[1] = FRONT_RIGHT;
   2.803 +                    device->DevChannels[2] = FRONT_CENTER;
   2.804 +                    device->DevChannels[3] = LFE;
   2.805 +                    device->DevChannels[4] = BACK_CENTER;
   2.806 +                    device->DevChannels[5] = SIDE_LEFT;
   2.807 +                    device->DevChannels[6] = SIDE_RIGHT; break;
   2.808 +
   2.809 +    case DevFmtX71: device->DevChannels[0] = FRONT_LEFT;
   2.810 +                    device->DevChannels[1] = FRONT_RIGHT;
   2.811 +                    device->DevChannels[2] = FRONT_CENTER;
   2.812 +                    device->DevChannels[3] = LFE;
   2.813 +                    device->DevChannels[4] = BACK_LEFT;
   2.814 +                    device->DevChannels[5] = BACK_RIGHT;
   2.815 +                    device->DevChannels[6] = SIDE_LEFT;
   2.816 +                    device->DevChannels[7] = SIDE_RIGHT; break;
   2.817 +    }
   2.818 +}
   2.819 +
   2.820 +
   2.821 +const ALCchar *DevFmtTypeString(enum DevFmtType type)
   2.822 +{
   2.823 +    switch(type)
   2.824 +    {
   2.825 +    case DevFmtByte: return "Signed Byte";
   2.826 +    case DevFmtUByte: return "Unsigned Byte";
   2.827 +    case DevFmtShort: return "Signed Short";
   2.828 +    case DevFmtUShort: return "Unsigned Short";
   2.829 +    case DevFmtFloat: return "Float";
   2.830 +    }
   2.831 +    return "(unknown type)";
   2.832 +}
   2.833 +const ALCchar *DevFmtChannelsString(enum DevFmtChannels chans)
   2.834 +{
   2.835 +    switch(chans)
   2.836 +    {
   2.837 +    case DevFmtMono: return "Mono";
   2.838 +    case DevFmtStereo: return "Stereo";
   2.839 +    case DevFmtQuad: return "Quadraphonic";
   2.840 +    case DevFmtX51: return "5.1 Surround";
   2.841 +    case DevFmtX51Side: return "5.1 Side";
   2.842 +    case DevFmtX61: return "6.1 Surround";
   2.843 +    case DevFmtX71: return "7.1 Surround";
   2.844 +    }
   2.845 +    return "(unknown channels)";
   2.846 +}
   2.847 +
   2.848 +ALuint BytesFromDevFmt(enum DevFmtType type)
   2.849 +{
   2.850 +    switch(type)
   2.851 +    {
   2.852 +    case DevFmtByte: return sizeof(ALbyte);
   2.853 +    case DevFmtUByte: return sizeof(ALubyte);
   2.854 +    case DevFmtShort: return sizeof(ALshort);
   2.855 +    case DevFmtUShort: return sizeof(ALushort);
   2.856 +    case DevFmtFloat: return sizeof(ALfloat);
   2.857 +    }
   2.858 +    return 0;
   2.859 +}
   2.860 +ALuint ChannelsFromDevFmt(enum DevFmtChannels chans)
   2.861 +{
   2.862 +    switch(chans)
   2.863 +    {
   2.864 +    case DevFmtMono: return 1;
   2.865 +    case DevFmtStereo: return 2;
   2.866 +    case DevFmtQuad: return 4;
   2.867 +    case DevFmtX51: return 6;
   2.868 +    case DevFmtX51Side: return 6;
   2.869 +    case DevFmtX61: return 7;
   2.870 +    case DevFmtX71: return 8;
   2.871 +    }
   2.872 +    return 0;
   2.873 +}
   2.874 +ALboolean DecomposeDevFormat(ALenum format, enum DevFmtChannels *chans,
   2.875 +                             enum DevFmtType *type)
   2.876 +{
   2.877 +    switch(format)
   2.878 +    {
   2.879 +        case AL_FORMAT_MONO8:
   2.880 +            *chans = DevFmtMono;
   2.881 +            *type  = DevFmtUByte;
   2.882 +            return AL_TRUE;
   2.883 +        case AL_FORMAT_MONO16:
   2.884 +            *chans = DevFmtMono;
   2.885 +            *type  = DevFmtShort;
   2.886 +            return AL_TRUE;
   2.887 +        case AL_FORMAT_MONO_FLOAT32:
   2.888 +            *chans = DevFmtMono;
   2.889 +            *type  = DevFmtFloat;
   2.890 +            return AL_TRUE;
   2.891 +        case AL_FORMAT_STEREO8:
   2.892 +            *chans = DevFmtStereo;
   2.893 +            *type  = DevFmtUByte;
   2.894 +            return AL_TRUE;
   2.895 +        case AL_FORMAT_STEREO16:
   2.896 +            *chans = DevFmtStereo;
   2.897 +            *type  = DevFmtShort;
   2.898 +            return AL_TRUE;
   2.899 +        case AL_FORMAT_STEREO_FLOAT32:
   2.900 +            *chans = DevFmtStereo;
   2.901 +            *type  = DevFmtFloat;
   2.902 +            return AL_TRUE;
   2.903 +        case AL_FORMAT_QUAD8:
   2.904 +            *chans = DevFmtQuad;
   2.905 +            *type  = DevFmtUByte;
   2.906 +            return AL_TRUE;
   2.907 +        case AL_FORMAT_QUAD16:
   2.908 +            *chans = DevFmtQuad;
   2.909 +            *type  = DevFmtShort;
   2.910 +            return AL_TRUE;
   2.911 +        case AL_FORMAT_QUAD32:
   2.912 +            *chans = DevFmtQuad;
   2.913 +            *type  = DevFmtFloat;
   2.914 +            return AL_TRUE;
   2.915 +        case AL_FORMAT_51CHN8:
   2.916 +            *chans = DevFmtX51;
   2.917 +            *type  = DevFmtUByte;
   2.918 +            return AL_TRUE;
   2.919 +        case AL_FORMAT_51CHN16:
   2.920 +            *chans = DevFmtX51;
   2.921 +            *type  = DevFmtShort;
   2.922 +            return AL_TRUE;
   2.923 +        case AL_FORMAT_51CHN32:
   2.924 +            *chans = DevFmtX51;
   2.925 +            *type  = DevFmtFloat;
   2.926 +            return AL_TRUE;
   2.927 +        case AL_FORMAT_61CHN8:
   2.928 +            *chans = DevFmtX61;
   2.929 +            *type  = DevFmtUByte;
   2.930 +            return AL_TRUE;
   2.931 +        case AL_FORMAT_61CHN16:
   2.932 +            *chans = DevFmtX61;
   2.933 +            *type  = DevFmtShort;
   2.934 +            return AL_TRUE;
   2.935 +        case AL_FORMAT_61CHN32:
   2.936 +            *chans = DevFmtX61;
   2.937 +            *type  = DevFmtFloat;
   2.938 +            return AL_TRUE;
   2.939 +        case AL_FORMAT_71CHN8:
   2.940 +            *chans = DevFmtX71;
   2.941 +            *type  = DevFmtUByte;
   2.942 +            return AL_TRUE;
   2.943 +        case AL_FORMAT_71CHN16:
   2.944 +            *chans = DevFmtX71;
   2.945 +            *type  = DevFmtShort;
   2.946 +            return AL_TRUE;
   2.947 +        case AL_FORMAT_71CHN32:
   2.948 +            *chans = DevFmtX71;
   2.949 +            *type  = DevFmtFloat;
   2.950 +            return AL_TRUE;
   2.951 +    }
   2.952 +    return AL_FALSE;
   2.953 +}
   2.954 +
   2.955 +static ALCboolean IsValidALCType(ALCenum type)
   2.956 +{
   2.957 +    switch(type)
   2.958 +    {
   2.959 +        case ALC_BYTE:
   2.960 +        case ALC_UNSIGNED_BYTE:
   2.961 +        case ALC_SHORT:
   2.962 +        case ALC_UNSIGNED_SHORT:
   2.963 +        case ALC_INT:
   2.964 +        case ALC_UNSIGNED_INT:
   2.965 +        case ALC_FLOAT:
   2.966 +            return ALC_TRUE;
   2.967 +    }
   2.968 +    return ALC_FALSE;
   2.969 +}
   2.970 +
   2.971 +static ALCboolean IsValidALCChannels(ALCenum channels)
   2.972 +{
   2.973 +    switch(channels)
   2.974 +    {
   2.975 +        case ALC_MONO:
   2.976 +        case ALC_STEREO:
   2.977 +        case ALC_QUAD:
   2.978 +        case ALC_5POINT1:
   2.979 +        case ALC_6POINT1:
   2.980 +        case ALC_7POINT1:
   2.981 +            return ALC_TRUE;
   2.982 +    }
   2.983 +    return ALC_FALSE;
   2.984 +}
   2.985 +
   2.986 +
   2.987 +static void LockLists(void)
   2.988 +{
   2.989 +    EnterCriticalSection(&ListLock);
   2.990 +}
   2.991 +
   2.992 +static void UnlockLists(void)
   2.993 +{
   2.994 +    LeaveCriticalSection(&ListLock);
   2.995 +}
   2.996 +
   2.997 +/*
   2.998 +    IsDevice
   2.999 +
  2.1000 +    Check pDevice is a valid Device pointer
  2.1001 +*/
  2.1002 +static ALCboolean IsDevice(ALCdevice *pDevice)
  2.1003 +{
  2.1004 +    ALCdevice *pTempDevice;
  2.1005 +
  2.1006 +    pTempDevice = g_pDeviceList;
  2.1007 +    while(pTempDevice && pTempDevice != pDevice)
  2.1008 +        pTempDevice = pTempDevice->next;
  2.1009 +
  2.1010 +    return (pTempDevice ? ALC_TRUE : ALC_FALSE);
  2.1011 +}
  2.1012 +
  2.1013 +/*
  2.1014 +    IsContext
  2.1015 +
  2.1016 +    Check pContext is a valid Context pointer
  2.1017 +*/
  2.1018 +static ALCboolean IsContext(ALCcontext *pContext)
  2.1019 +{
  2.1020 +    ALCcontext *pTempContext;
  2.1021 +
  2.1022 +    pTempContext = g_pContextList;
  2.1023 +    while (pTempContext && pTempContext != pContext)
  2.1024 +        pTempContext = pTempContext->next;
  2.1025 +
  2.1026 +    return (pTempContext ? ALC_TRUE : ALC_FALSE);
  2.1027 +}
  2.1028 +
  2.1029 +
  2.1030 +/*
  2.1031 +    alcSetError
  2.1032 +
  2.1033 +    Store latest ALC Error
  2.1034 +*/
  2.1035 +ALCvoid alcSetError(ALCdevice *device, ALenum errorCode)
  2.1036 +{
  2.1037 +    LockLists();
  2.1038 +    if(IsDevice(device))
  2.1039 +        device->LastError = errorCode;
  2.1040 +    else
  2.1041 +        g_eLastNullDeviceError = errorCode;
  2.1042 +    UnlockLists();
  2.1043 +}
  2.1044 +
  2.1045 +
  2.1046 +/* UpdateDeviceParams:
  2.1047 + *
  2.1048 + * Updates device parameters according to the attribute list.
  2.1049 + */
  2.1050 +static ALCboolean UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
  2.1051 +{
  2.1052 +    ALuint i;
  2.1053 +
  2.1054 +    // Check for attributes
  2.1055 +    if(attrList && attrList[0])
  2.1056 +    {
  2.1057 +        ALCuint freq, numMono, numStereo, numSends;
  2.1058 +        enum DevFmtChannels schans;
  2.1059 +        enum DevFmtType stype;
  2.1060 +        ALuint attrIdx;
  2.1061 +
  2.1062 +        // If a context is already running on the device, stop playback so the
  2.1063 +        // device attributes can be updated
  2.1064 +        if((device->Flags&DEVICE_RUNNING))
  2.1065 +            ALCdevice_StopPlayback(device);
  2.1066 +        device->Flags &= ~DEVICE_RUNNING;
  2.1067 +
  2.1068 +        freq = device->Frequency;
  2.1069 +        schans = device->FmtChans;
  2.1070 +        stype = device->FmtType;
  2.1071 +        numMono = device->NumMonoSources;
  2.1072 +        numStereo = device->NumStereoSources;
  2.1073 +        numSends = device->NumAuxSends;
  2.1074 +
  2.1075 +        freq = GetConfigValueInt(NULL, "frequency", freq);
  2.1076 +        if(freq < 8000) freq = 8000;
  2.1077 +
  2.1078 +        attrIdx = 0;
  2.1079 +        while(attrList[attrIdx])
  2.1080 +        {
  2.1081 +            if(attrList[attrIdx] == ALC_FORMAT_CHANNELS_SOFT &&
  2.1082 +               device->IsLoopbackDevice)
  2.1083 +            {
  2.1084 +                ALCint val = attrList[attrIdx + 1];
  2.1085 +                if(!IsValidALCChannels(val) || !ChannelsFromDevFmt(val))
  2.1086 +                {
  2.1087 +                    alcSetError(device, ALC_INVALID_VALUE);
  2.1088 +                    return ALC_FALSE;
  2.1089 +                }
  2.1090 +                schans = val;
  2.1091 +            }
  2.1092 +
  2.1093 +            if(attrList[attrIdx] == ALC_FORMAT_TYPE_SOFT &&
  2.1094 +               device->IsLoopbackDevice)
  2.1095 +            {
  2.1096 +                ALCint val = attrList[attrIdx + 1];
  2.1097 +                if(!IsValidALCType(val) || !BytesFromDevFmt(val))
  2.1098 +                {
  2.1099 +                    alcSetError(device, ALC_INVALID_VALUE);
  2.1100 +                    return ALC_FALSE;
  2.1101 +                }
  2.1102 +                stype = val;
  2.1103 +            }
  2.1104 +
  2.1105 +            if(attrList[attrIdx] == ALC_FREQUENCY)
  2.1106 +            {
  2.1107 +                if(device->IsLoopbackDevice)
  2.1108 +                {
  2.1109 +                    freq = attrList[attrIdx + 1];
  2.1110 +                    if(freq < 8000)
  2.1111 +                    {
  2.1112 +                        alcSetError(device, ALC_INVALID_VALUE);
  2.1113 +                        return ALC_FALSE;
  2.1114 +                    }
  2.1115 +                }
  2.1116 +                else if(!ConfigValueExists(NULL, "frequency"))
  2.1117 +                {
  2.1118 +                    freq = attrList[attrIdx + 1];
  2.1119 +                    if(freq < 8000) freq = 8000;
  2.1120 +                    device->Flags |= DEVICE_FREQUENCY_REQUEST;
  2.1121 +                }
  2.1122 +            }
  2.1123 +
  2.1124 +            if(attrList[attrIdx] == ALC_STEREO_SOURCES)
  2.1125 +            {
  2.1126 +                numStereo = attrList[attrIdx + 1];
  2.1127 +                if(numStereo > device->MaxNoOfSources)
  2.1128 +                    numStereo = device->MaxNoOfSources;
  2.1129 +
  2.1130 +                numMono = device->MaxNoOfSources - numStereo;
  2.1131 +            }
  2.1132 +
  2.1133 +            if(attrList[attrIdx] == ALC_MAX_AUXILIARY_SENDS &&
  2.1134 +               !ConfigValueExists(NULL, "sends"))
  2.1135 +            {
  2.1136 +                numSends = attrList[attrIdx + 1];
  2.1137 +                if(numSends > MAX_SENDS)
  2.1138 +                    numSends = MAX_SENDS;
  2.1139 +            }
  2.1140 +
  2.1141 +            attrIdx += 2;
  2.1142 +        }
  2.1143 +
  2.1144 +        device->UpdateSize = (ALuint64)device->UpdateSize * freq /
  2.1145 +                             device->Frequency;
  2.1146 +
  2.1147 +        device->Frequency = freq;
  2.1148 +        device->FmtChans = schans;
  2.1149 +        device->FmtType = stype;
  2.1150 +        device->NumMonoSources = numMono;
  2.1151 +        device->NumStereoSources = numStereo;
  2.1152 +        device->NumAuxSends = numSends;
  2.1153 +    }
  2.1154 +
  2.1155 +    if((device->Flags&DEVICE_RUNNING))
  2.1156 +        return ALC_TRUE;
  2.1157 +
  2.1158 +    LockDevice(device);
  2.1159 +    TRACE("Format pre-setup: %s%s, %s, %uhz%s, %u update size x%d\n",
  2.1160 +          DevFmtChannelsString(device->FmtChans),
  2.1161 +          (device->Flags&DEVICE_CHANNELS_REQUEST)?" (requested)":"",
  2.1162 +          DevFmtTypeString(device->FmtType), device->Frequency,
  2.1163 +          (device->Flags&DEVICE_FREQUENCY_REQUEST)?" (requested)":"",
  2.1164 +          device->UpdateSize, device->NumUpdates);
  2.1165 +    if(ALCdevice_ResetPlayback(device) == ALC_FALSE)
  2.1166 +    {
  2.1167 +        UnlockDevice(device);
  2.1168 +        return ALC_FALSE;
  2.1169 +    }
  2.1170 +    device->Flags |= DEVICE_RUNNING;
  2.1171 +    TRACE("Format post-setup: %s%s, %s, %uhz%s, %u update size x%d\n",
  2.1172 +          DevFmtChannelsString(device->FmtChans),
  2.1173 +          (device->Flags&DEVICE_CHANNELS_REQUEST)?" (requested)":"",
  2.1174 +          DevFmtTypeString(device->FmtType), device->Frequency,
  2.1175 +          (device->Flags&DEVICE_FREQUENCY_REQUEST)?" (requested)":"",
  2.1176 +          device->UpdateSize, device->NumUpdates);
  2.1177 +
  2.1178 +    aluInitPanning(device);
  2.1179 +
  2.1180 +    for(i = 0;i < MAXCHANNELS;i++)
  2.1181 +    {
  2.1182 +        device->ClickRemoval[i] = 0.0f;
  2.1183 +        device->PendingClicks[i] = 0.0f;
  2.1184 +    }
  2.1185 +
  2.1186 +    if(!device->IsLoopbackDevice && GetConfigValueBool(NULL, "hrtf", AL_FALSE))
  2.1187 +        device->Flags |= DEVICE_USE_HRTF;
  2.1188 +    if((device->Flags&DEVICE_USE_HRTF) && !IsHrtfCompatible(device))
  2.1189 +        device->Flags &= ~DEVICE_USE_HRTF;
  2.1190 +    TRACE("HRTF %s\n", (device->Flags&DEVICE_USE_HRTF)?"enabled":"disabled");
  2.1191 +
  2.1192 +    if(!(device->Flags&DEVICE_USE_HRTF) && device->Bs2bLevel > 0 && device->Bs2bLevel <= 6)
  2.1193 +    {
  2.1194 +        if(!device->Bs2b)
  2.1195 +        {
  2.1196 +            device->Bs2b = calloc(1, sizeof(*device->Bs2b));
  2.1197 +            bs2b_clear(device->Bs2b);
  2.1198 +        }
  2.1199 +        bs2b_set_srate(device->Bs2b, device->Frequency);
  2.1200 +        bs2b_set_level(device->Bs2b, device->Bs2bLevel);
  2.1201 +        TRACE("BS2B level %d\n", device->Bs2bLevel);
  2.1202 +    }
  2.1203 +    else
  2.1204 +    {
  2.1205 +        free(device->Bs2b);
  2.1206 +        device->Bs2b = NULL;
  2.1207 +        TRACE("BS2B disabled\n");
  2.1208 +    }
  2.1209 +
  2.1210 +    device->Flags &= ~DEVICE_DUPLICATE_STEREO;
  2.1211 +    switch(device->FmtChans)
  2.1212 +    {
  2.1213 +        case DevFmtMono:
  2.1214 +        case DevFmtStereo:
  2.1215 +            break;
  2.1216 +        case DevFmtQuad:
  2.1217 +        case DevFmtX51:
  2.1218 +        case DevFmtX51Side:
  2.1219 +        case DevFmtX61:
  2.1220 +        case DevFmtX71:
  2.1221 +            if(GetConfigValueBool(NULL, "stereodup", AL_TRUE))
  2.1222 +                device->Flags |= DEVICE_DUPLICATE_STEREO;
  2.1223 +            break;
  2.1224 +    }
  2.1225 +    TRACE("Stereo duplication %s\n", (device->Flags&DEVICE_DUPLICATE_STEREO)?"enabled":"disabled");
  2.1226 +
  2.1227 +    for(i = 0;i < device->NumContexts;i++)
  2.1228 +    {
  2.1229 +        ALCcontext *context = device->Contexts[i];
  2.1230 +        ALsizei pos;
  2.1231 +
  2.1232 +        context->UpdateSources = AL_FALSE;
  2.1233 +        for(pos = 0;pos < context->EffectSlotMap.size;pos++)
  2.1234 +        {
  2.1235 +            ALeffectslot *slot = context->EffectSlotMap.array[pos].value;
  2.1236 +
  2.1237 +            if(ALEffect_DeviceUpdate(slot->EffectState, device) == AL_FALSE)
  2.1238 +            {
  2.1239 +                UnlockDevice(device);
  2.1240 +                ALCdevice_StopPlayback(device);
  2.1241 +                device->Flags &= ~DEVICE_RUNNING;
  2.1242 +                return ALC_FALSE;
  2.1243 +            }
  2.1244 +            slot->NeedsUpdate = AL_FALSE;
  2.1245 +            ALEffect_Update(slot->EffectState, context, slot);
  2.1246 +        }
  2.1247 +
  2.1248 +        for(pos = 0;pos < context->SourceMap.size;pos++)
  2.1249 +        {
  2.1250 +            ALsource *source = context->SourceMap.array[pos].value;
  2.1251 +            ALuint s = device->NumAuxSends;
  2.1252 +            while(s < MAX_SENDS)
  2.1253 +            {
  2.1254 +                if(source->Send[s].Slot)
  2.1255 +                    source->Send[s].Slot->refcount--;
  2.1256 +                source->Send[s].Slot = NULL;
  2.1257 +                source->Send[s].WetFilter.type = 0;
  2.1258 +                source->Send[s].WetFilter.filter = 0;
  2.1259 +                s++;
  2.1260 +            }
  2.1261 +            source->NeedsUpdate = AL_FALSE;
  2.1262 +            ALsource_Update(source, context);
  2.1263 +        }
  2.1264 +    }
  2.1265 +    UnlockDevice(device);
  2.1266 +
  2.1267 +    return ALC_TRUE;
  2.1268 +}
  2.1269 +
  2.1270 +
  2.1271 +ALCvoid LockDevice(ALCdevice *device)
  2.1272 +{
  2.1273 +    EnterCriticalSection(&device->Mutex);
  2.1274 +}
  2.1275 +
  2.1276 +ALCvoid UnlockDevice(ALCdevice *device)
  2.1277 +{
  2.1278 +    LeaveCriticalSection(&device->Mutex);
  2.1279 +}
  2.1280 +
  2.1281 +/*
  2.1282 +    LockContext
  2.1283 +
  2.1284 +    Thread-safe entry
  2.1285 +*/
  2.1286 +ALCvoid LockContext(ALCcontext *context)
  2.1287 +{
  2.1288 +    EnterCriticalSection(&context->Device->Mutex);
  2.1289 +}
  2.1290 +
  2.1291 +
  2.1292 +/*
  2.1293 +    UnlockContext
  2.1294 +
  2.1295 +    Thread-safe exit
  2.1296 +*/
  2.1297 +ALCvoid UnlockContext(ALCcontext *context)
  2.1298 +{
  2.1299 +    LeaveCriticalSection(&context->Device->Mutex);
  2.1300 +}
  2.1301 +
  2.1302 +
  2.1303 +/*
  2.1304 +    GetLockedContext
  2.1305 +
  2.1306 +    Returns the currently active Context, in a locked state
  2.1307 +*/
  2.1308 +ALCcontext *GetLockedContext(void)
  2.1309 +{
  2.1310 +    ALCcontext *pContext = NULL;
  2.1311 +
  2.1312 +    LockLists();
  2.1313 +
  2.1314 +    pContext = tls_get(LocalContext);
  2.1315 +    if(pContext && !IsContext(pContext))
  2.1316 +    {
  2.1317 +        tls_set(LocalContext, NULL);
  2.1318 +        pContext = NULL;
  2.1319 +    }
  2.1320 +    if(!pContext)
  2.1321 +        pContext = GlobalContext;
  2.1322 +    if(pContext)
  2.1323 +        LockContext(pContext);
  2.1324 +
  2.1325 +    UnlockLists();
  2.1326 +
  2.1327 +    return pContext;
  2.1328 +}
  2.1329 +
  2.1330 +
  2.1331 +/*
  2.1332 +    InitContext
  2.1333 +
  2.1334 +    Initialize Context variables
  2.1335 +*/
  2.1336 +static ALvoid InitContext(ALCcontext *pContext)
  2.1337 +{
  2.1338 +    //Initialise listener
  2.1339 +    pContext->Listener.Gain = 1.0f;
  2.1340 +    pContext->Listener.MetersPerUnit = 1.0f;
  2.1341 +    pContext->Listener.Position[0] = 0.0f;
  2.1342 +    pContext->Listener.Position[1] = 0.0f;
  2.1343 +    pContext->Listener.Position[2] = 0.0f;
  2.1344 +    pContext->Listener.Velocity[0] = 0.0f;
  2.1345 +    pContext->Listener.Velocity[1] = 0.0f;
  2.1346 +    pContext->Listener.Velocity[2] = 0.0f;
  2.1347 +    pContext->Listener.Forward[0] = 0.0f;
  2.1348 +    pContext->Listener.Forward[1] = 0.0f;
  2.1349 +    pContext->Listener.Forward[2] = -1.0f;
  2.1350 +    pContext->Listener.Up[0] = 0.0f;
  2.1351 +    pContext->Listener.Up[1] = 1.0f;
  2.1352 +    pContext->Listener.Up[2] = 0.0f;
  2.1353 +
  2.1354 +    //Validate pContext
  2.1355 +    pContext->LastError = AL_NO_ERROR;
  2.1356 +    pContext->UpdateSources = AL_FALSE;
  2.1357 +    pContext->ActiveSourceCount = 0;
  2.1358 +    InitUIntMap(&pContext->SourceMap);
  2.1359 +    InitUIntMap(&pContext->EffectSlotMap);
  2.1360 +
  2.1361 +    //Set globals
  2.1362 +    pContext->DistanceModel = AL_INVERSE_DISTANCE_CLAMPED;
  2.1363 +    pContext->SourceDistanceModel = AL_FALSE;
  2.1364 +    pContext->DopplerFactor = 1.0f;
  2.1365 +    pContext->DopplerVelocity = 1.0f;
  2.1366 +    pContext->flSpeedOfSound = SPEEDOFSOUNDMETRESPERSEC;
  2.1367 +    pContext->DeferUpdates = AL_FALSE;
  2.1368 +
  2.1369 +    pContext->ExtensionList = alExtList;
  2.1370 +}
  2.1371 +
  2.1372 +
  2.1373 +/*
  2.1374 +    FreeContext
  2.1375 +
  2.1376 +    Clean up Context, destroy any remaining Sources
  2.1377 +*/
  2.1378 +static ALCvoid FreeContext(ALCcontext *context)
  2.1379 +{
  2.1380 +    //Invalidate context
  2.1381 +    memset(context, 0, sizeof(ALCcontext));
  2.1382 +    free(context);
  2.1383 +}
  2.1384 +
  2.1385 +///////////////////////////////////////////////////////
  2.1386 +
  2.1387 +
  2.1388 +///////////////////////////////////////////////////////
  2.1389 +// ALC Functions calls
  2.1390 +
  2.1391 +
  2.1392 +// This should probably move to another c file but for now ...
  2.1393 +ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
  2.1394 +{
  2.1395 +    ALCdevice *device = NULL;
  2.1396 +
  2.1397 +    DO_INITCONFIG();
  2.1398 +
  2.1399 +    if(!CaptureBackend.name)
  2.1400 +    {
  2.1401 +        alcSetError(NULL, ALC_INVALID_VALUE);
  2.1402 +        return NULL;
  2.1403 +    }
  2.1404 +
  2.1405 +    if(SampleSize <= 0)
  2.1406 +    {
  2.1407 +        alcSetError(NULL, ALC_INVALID_VALUE);
  2.1408 +        return NULL;
  2.1409 +    }
  2.1410 +
  2.1411 +    if(deviceName && (!deviceName[0] || strcasecmp(deviceName, "openal soft") == 0 || strcasecmp(deviceName, "openal-soft") == 0))
  2.1412 +        deviceName = NULL;
  2.1413 +
  2.1414 +    device = calloc(1, sizeof(ALCdevice));
  2.1415 +    if(!device)
  2.1416 +    {
  2.1417 +        alcSetError(NULL, ALC_OUT_OF_MEMORY);
  2.1418 +        return NULL;
  2.1419 +    }
  2.1420 +
  2.1421 +    //Validate device
  2.1422 +    device->Funcs = &CaptureBackend.Funcs;
  2.1423 +    device->Connected = ALC_TRUE;
  2.1424 +    device->IsCaptureDevice = AL_TRUE;
  2.1425 +    device->IsLoopbackDevice = AL_FALSE;
  2.1426 +    InitializeCriticalSection(&device->Mutex);
  2.1427 +
  2.1428 +    device->szDeviceName = NULL;
  2.1429 +
  2.1430 +    device->Flags |= DEVICE_FREQUENCY_REQUEST;
  2.1431 +    device->Frequency = frequency;
  2.1432 +
  2.1433 +    device->Flags |= DEVICE_CHANNELS_REQUEST;
  2.1434 +    if(DecomposeDevFormat(format, &device->FmtChans, &device->FmtType) == AL_FALSE)
  2.1435 +    {
  2.1436 +        free(device);
  2.1437 +        alcSetError(NULL, ALC_INVALID_ENUM);
  2.1438 +        return NULL;
  2.1439 +    }
  2.1440 +
  2.1441 +    device->UpdateSize = SampleSize;
  2.1442 +    device->NumUpdates = 1;
  2.1443 +
  2.1444 +    LockLists();
  2.1445 +    if(ALCdevice_OpenCapture(device, deviceName))
  2.1446 +    {
  2.1447 +        device->next = g_pDeviceList;
  2.1448 +        g_pDeviceList = device;
  2.1449 +        g_ulDeviceCount++;
  2.1450 +    }
  2.1451 +    else
  2.1452 +    {
  2.1453 +        DeleteCriticalSection(&device->Mutex);
  2.1454 +        free(device);
  2.1455 +        device = NULL;
  2.1456 +        alcSetError(NULL, ALC_INVALID_VALUE);
  2.1457 +    }
  2.1458 +    UnlockLists();
  2.1459 +
  2.1460 +    return device;
  2.1461 +}
  2.1462 +
  2.1463 +ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *pDevice)
  2.1464 +{
  2.1465 +    ALCdevice **list;
  2.1466 +
  2.1467 +    LockLists();
  2.1468 +    list = &g_pDeviceList;
  2.1469 +    while(*list && *list != pDevice)
  2.1470 +        list = &(*list)->next;
  2.1471 +
  2.1472 +    if(!*list || !(*list)->IsCaptureDevice)
  2.1473 +    {
  2.1474 +        alcSetError(*list, ALC_INVALID_DEVICE);
  2.1475 +        UnlockLists();
  2.1476 +        return ALC_FALSE;
  2.1477 +    }
  2.1478 +
  2.1479 +    *list = (*list)->next;
  2.1480 +    g_ulDeviceCount--;
  2.1481 +
  2.1482 +    UnlockLists();
  2.1483 +
  2.1484 +    LockDevice(pDevice);
  2.1485 +    ALCdevice_CloseCapture(pDevice);
  2.1486 +    UnlockDevice(pDevice);
  2.1487 +
  2.1488 +    free(pDevice->szDeviceName);
  2.1489 +    pDevice->szDeviceName = NULL;
  2.1490 +
  2.1491 +    DeleteCriticalSection(&pDevice->Mutex);
  2.1492 +
  2.1493 +    free(pDevice);
  2.1494 +
  2.1495 +    return ALC_TRUE;
  2.1496 +}
  2.1497 +
  2.1498 +ALC_API void ALC_APIENTRY alcCaptureStart(ALCdevice *device)
  2.1499 +{
  2.1500 +    LockLists();
  2.1501 +    if(!IsDevice(device) || !device->IsCaptureDevice)
  2.1502 +    {
  2.1503 +        alcSetError(device, ALC_INVALID_DEVICE);
  2.1504 +        UnlockLists();
  2.1505 +        return;
  2.1506 +    }
  2.1507 +    LockDevice(device);
  2.1508 +    UnlockLists();
  2.1509 +    if(device->Connected)
  2.1510 +        ALCdevice_StartCapture(device);
  2.1511 +    UnlockDevice(device);
  2.1512 +}
  2.1513 +
  2.1514 +ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device)
  2.1515 +{
  2.1516 +    LockLists();
  2.1517 +    if(!IsDevice(device) || !device->IsCaptureDevice)
  2.1518 +    {
  2.1519 +        alcSetError(device, ALC_INVALID_DEVICE);
  2.1520 +        UnlockLists();
  2.1521 +        return;
  2.1522 +    }
  2.1523 +    LockDevice(device);
  2.1524 +    UnlockLists();
  2.1525 +    if(device->Connected)
  2.1526 +        ALCdevice_StopCapture(device);
  2.1527 +    UnlockDevice(device);
  2.1528 +}
  2.1529 +
  2.1530 +ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
  2.1531 +{
  2.1532 +    LockLists();
  2.1533 +    if(!IsDevice(device) || !device->IsCaptureDevice)
  2.1534 +    {
  2.1535 +        alcSetError(device, ALC_INVALID_DEVICE);
  2.1536 +        UnlockLists();
  2.1537 +        return;
  2.1538 +    }
  2.1539 +    LockDevice(device);
  2.1540 +    UnlockLists();
  2.1541 +    if(device->Connected)
  2.1542 +        ALCdevice_CaptureSamples(device, buffer, samples);
  2.1543 +    UnlockDevice(device);
  2.1544 +}
  2.1545 +
  2.1546 +/*
  2.1547 +    alcGetError
  2.1548 +
  2.1549 +    Return last ALC generated error code
  2.1550 +*/
  2.1551 +ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device)
  2.1552 +{
  2.1553 +    ALCenum errorCode;
  2.1554 +
  2.1555 +    LockLists();
  2.1556 +    if(IsDevice(device))
  2.1557 +    {
  2.1558 +        errorCode = device->LastError;
  2.1559 +        device->LastError = ALC_NO_ERROR;
  2.1560 +    }
  2.1561 +    else
  2.1562 +    {
  2.1563 +        errorCode = g_eLastNullDeviceError;
  2.1564 +        g_eLastNullDeviceError = ALC_NO_ERROR;
  2.1565 +    }
  2.1566 +    UnlockLists();
  2.1567 +    return errorCode;
  2.1568 +}
  2.1569 +
  2.1570 +
  2.1571 +/*
  2.1572 +    alcSuspendContext
  2.1573 +
  2.1574 +    Not functional
  2.1575 +*/
  2.1576 +ALC_API ALCvoid ALC_APIENTRY alcSuspendContext(ALCcontext *Context)
  2.1577 +{
  2.1578 +    (void)Context;
  2.1579 +}
  2.1580 +
  2.1581 +
  2.1582 +/*
  2.1583 +    alcProcessContext
  2.1584 +
  2.1585 +    Not functional
  2.1586 +*/
  2.1587 +ALC_API ALCvoid ALC_APIENTRY alcProcessContext(ALCcontext *Context)
  2.1588 +{
  2.1589 +    (void)Context;
  2.1590 +}
  2.1591 +
  2.1592 +
  2.1593 +/*
  2.1594 +    alcGetString
  2.1595 +
  2.1596 +    Returns information about the Device, and error strings
  2.1597 +*/
  2.1598 +ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *pDevice,ALCenum param)
  2.1599 +{
  2.1600 +    const ALCchar *value = NULL;
  2.1601 +
  2.1602 +    switch(param)
  2.1603 +    {
  2.1604 +    case ALC_NO_ERROR:
  2.1605 +        value = alcNoError;
  2.1606 +        break;
  2.1607 +
  2.1608 +    case ALC_INVALID_ENUM:
  2.1609 +        value = alcErrInvalidEnum;
  2.1610 +        break;
  2.1611 +
  2.1612 +    case ALC_INVALID_VALUE:
  2.1613 +        value = alcErrInvalidValue;
  2.1614 +        break;
  2.1615 +
  2.1616 +    case ALC_INVALID_DEVICE:
  2.1617 +        value = alcErrInvalidDevice;
  2.1618 +        break;
  2.1619 +
  2.1620 +    case ALC_INVALID_CONTEXT:
  2.1621 +        value = alcErrInvalidContext;
  2.1622 +        break;
  2.1623 +
  2.1624 +    case ALC_OUT_OF_MEMORY:
  2.1625 +        value = alcErrOutOfMemory;
  2.1626 +        break;
  2.1627 +
  2.1628 +    case ALC_DEVICE_SPECIFIER:
  2.1629 +        LockLists();
  2.1630 +        if(IsDevice(pDevice))
  2.1631 +            value = pDevice->szDeviceName;
  2.1632 +        else
  2.1633 +        {
  2.1634 +            ProbeDeviceList();
  2.1635 +            value = alcDeviceList;
  2.1636 +        }
  2.1637 +        UnlockLists();
  2.1638 +        break;
  2.1639 +
  2.1640 +    case ALC_ALL_DEVICES_SPECIFIER:
  2.1641 +        ProbeAllDeviceList();
  2.1642 +        value = alcAllDeviceList;
  2.1643 +        break;
  2.1644 +
  2.1645 +    case ALC_CAPTURE_DEVICE_SPECIFIER:
  2.1646 +        LockLists();
  2.1647 +        if(IsDevice(pDevice))
  2.1648 +            value = pDevice->szDeviceName;
  2.1649 +        else
  2.1650 +        {
  2.1651 +            ProbeCaptureDeviceList();
  2.1652 +            value = alcCaptureDeviceList;
  2.1653 +        }
  2.1654 +        UnlockLists();
  2.1655 +        break;
  2.1656 +
  2.1657 +    /* Default devices are always first in the list */
  2.1658 +    case ALC_DEFAULT_DEVICE_SPECIFIER:
  2.1659 +        if(!alcDeviceList)
  2.1660 +            ProbeDeviceList();
  2.1661 +
  2.1662 +        free(alcDefaultDeviceSpecifier);
  2.1663 +        alcDefaultDeviceSpecifier = strdup(alcDeviceList ? alcDeviceList : "");
  2.1664 +        if(!alcDefaultDeviceSpecifier)
  2.1665 +            alcSetError(pDevice, ALC_OUT_OF_MEMORY);
  2.1666 +        value = alcDefaultDeviceSpecifier;
  2.1667 +        break;
  2.1668 +
  2.1669 +    case ALC_DEFAULT_ALL_DEVICES_SPECIFIER:
  2.1670 +        if(!alcAllDeviceList)
  2.1671 +            ProbeAllDeviceList();
  2.1672 +
  2.1673 +        free(alcDefaultAllDeviceSpecifier);
  2.1674 +        alcDefaultAllDeviceSpecifier = strdup(alcAllDeviceList ?
  2.1675 +                                              alcAllDeviceList : "");
  2.1676 +        if(!alcDefaultAllDeviceSpecifier)
  2.1677 +            alcSetError(pDevice, ALC_OUT_OF_MEMORY);
  2.1678 +        value = alcDefaultAllDeviceSpecifier;
  2.1679 +        break;
  2.1680 +
  2.1681 +    case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER:
  2.1682 +        if(!alcCaptureDeviceList)
  2.1683 +            ProbeCaptureDeviceList();
  2.1684 +
  2.1685 +        free(alcCaptureDefaultDeviceSpecifier);
  2.1686 +        alcCaptureDefaultDeviceSpecifier = strdup(alcCaptureDeviceList ?
  2.1687 +                                                  alcCaptureDeviceList : "");
  2.1688 +        if(!alcCaptureDefaultDeviceSpecifier)
  2.1689 +            alcSetError(pDevice, ALC_OUT_OF_MEMORY);
  2.1690 +        value = alcCaptureDefaultDeviceSpecifier;
  2.1691 +        break;
  2.1692 +
  2.1693 +    case ALC_EXTENSIONS:
  2.1694 +        LockLists();
  2.1695 +        if(IsDevice(pDevice))
  2.1696 +            value = alcExtensionList;
  2.1697 +        else
  2.1698 +            value = alcNoDeviceExtList;
  2.1699 +        UnlockLists();
  2.1700 +        break;
  2.1701 +
  2.1702 +    default:
  2.1703 +        alcSetError(pDevice, ALC_INVALID_ENUM);
  2.1704 +        break;
  2.1705 +    }
  2.1706 +
  2.1707 +    return value;
  2.1708 +}
  2.1709 +
  2.1710 +
  2.1711 +/*
  2.1712 +    alcGetIntegerv
  2.1713 +
  2.1714 +    Returns information about the Device and the version of Open AL
  2.1715 +*/
  2.1716 +ALC_API ALCvoid ALC_APIENTRY alcGetIntegerv(ALCdevice *device,ALCenum param,ALsizei size,ALCint *data)
  2.1717 +{
  2.1718 +    if(size == 0 || data == NULL)
  2.1719 +    {
  2.1720 +        alcSetError(device, ALC_INVALID_VALUE);
  2.1721 +        return;
  2.1722 +    }
  2.1723 +
  2.1724 +    LockLists();
  2.1725 +    if(!IsDevice(device))
  2.1726 +    {
  2.1727 +        switch(param)
  2.1728 +        {
  2.1729 +            case ALC_MAJOR_VERSION:
  2.1730 +                *data = alcMajorVersion;
  2.1731 +                break;
  2.1732 +            case ALC_MINOR_VERSION:
  2.1733 +                *data = alcMinorVersion;
  2.1734 +                break;
  2.1735 +
  2.1736 +            case ALC_ATTRIBUTES_SIZE:
  2.1737 +            case ALC_ALL_ATTRIBUTES:
  2.1738 +            case ALC_FREQUENCY:
  2.1739 +            case ALC_REFRESH:
  2.1740 +            case ALC_SYNC:
  2.1741 +            case ALC_MONO_SOURCES:
  2.1742 +            case ALC_STEREO_SOURCES:
  2.1743 +            case ALC_CAPTURE_SAMPLES:
  2.1744 +            case ALC_FORMAT_CHANNELS_SOFT:
  2.1745 +            case ALC_FORMAT_TYPE_SOFT:
  2.1746 +                alcSetError(NULL, ALC_INVALID_DEVICE);
  2.1747 +                break;
  2.1748 +
  2.1749 +            default:
  2.1750 +                alcSetError(NULL, ALC_INVALID_ENUM);
  2.1751 +                break;
  2.1752 +        }
  2.1753 +    }
  2.1754 +    else if(device->IsCaptureDevice)
  2.1755 +    {
  2.1756 +        switch(param)
  2.1757 +        {
  2.1758 +            case ALC_CAPTURE_SAMPLES:
  2.1759 +                LockDevice(device);
  2.1760 +                *data = ALCdevice_AvailableSamples(device);
  2.1761 +                UnlockDevice(device);
  2.1762 +                break;
  2.1763 +
  2.1764 +            case ALC_CONNECTED:
  2.1765 +                *data = device->Connected;
  2.1766 +                break;
  2.1767 +
  2.1768 +            default:
  2.1769 +                alcSetError(device, ALC_INVALID_ENUM);
  2.1770 +                break;
  2.1771 +        }
  2.1772 +    }
  2.1773 +    else /* render device */
  2.1774 +    {
  2.1775 +        switch(param)
  2.1776 +        {
  2.1777 +            case ALC_MAJOR_VERSION:
  2.1778 +                *data = alcMajorVersion;
  2.1779 +                break;
  2.1780 +
  2.1781 +            case ALC_MINOR_VERSION:
  2.1782 +                *data = alcMinorVersion;
  2.1783 +                break;
  2.1784 +
  2.1785 +            case ALC_EFX_MAJOR_VERSION:
  2.1786 +                *data = alcEFXMajorVersion;
  2.1787 +                break;
  2.1788 +
  2.1789 +            case ALC_EFX_MINOR_VERSION:
  2.1790 +                *data = alcEFXMinorVersion;
  2.1791 +                break;
  2.1792 +
  2.1793 +            case ALC_ATTRIBUTES_SIZE:
  2.1794 +                *data = 13;
  2.1795 +                break;
  2.1796 +
  2.1797 +            case ALC_ALL_ATTRIBUTES:
  2.1798 +                if(size < 13)
  2.1799 +                    alcSetError(device, ALC_INVALID_VALUE);
  2.1800 +                else
  2.1801 +                {
  2.1802 +                    int i = 0;
  2.1803 +
  2.1804 +                    data[i++] = ALC_FREQUENCY;
  2.1805 +                    data[i++] = device->Frequency;
  2.1806 +
  2.1807 +                    if(!device->IsLoopbackDevice)
  2.1808 +                    {
  2.1809 +                        data[i++] = ALC_REFRESH;
  2.1810 +                        data[i++] = device->Frequency / device->UpdateSize;
  2.1811 +
  2.1812 +                        data[i++] = ALC_SYNC;
  2.1813 +                        data[i++] = ALC_FALSE;
  2.1814 +                    }
  2.1815 +                    else
  2.1816 +                    {
  2.1817 +                        data[i++] = ALC_FORMAT_CHANNELS_SOFT;
  2.1818 +                        data[i++] = device->FmtChans;
  2.1819 +
  2.1820 +                        data[i++] = ALC_FORMAT_TYPE_SOFT;
  2.1821 +                        data[i++] = device->FmtType;
  2.1822 +                    }
  2.1823 +
  2.1824 +                    data[i++] = ALC_MONO_SOURCES;
  2.1825 +                    data[i++] = device->NumMonoSources;
  2.1826 +
  2.1827 +                    data[i++] = ALC_STEREO_SOURCES;
  2.1828 +                    data[i++] = device->NumStereoSources;
  2.1829 +
  2.1830 +                    data[i++] = ALC_MAX_AUXILIARY_SENDS;
  2.1831 +                    data[i++] = device->NumAuxSends;
  2.1832 +
  2.1833 +                    data[i++] = 0;
  2.1834 +                }
  2.1835 +                break;
  2.1836 +
  2.1837 +            case ALC_FREQUENCY:
  2.1838 +                *data = device->Frequency;
  2.1839 +                break;
  2.1840 +
  2.1841 +            case ALC_REFRESH:
  2.1842 +                if(device->IsLoopbackDevice)
  2.1843 +                    alcSetError(device, ALC_INVALID_DEVICE);
  2.1844 +                else
  2.1845 +                    *data = device->Frequency / device->UpdateSize;
  2.1846 +                break;
  2.1847 +
  2.1848 +            case ALC_SYNC:
  2.1849 +                if(device->IsLoopbackDevice)
  2.1850 +                    alcSetError(device, ALC_INVALID_DEVICE);
  2.1851 +                else
  2.1852 +                    *data = ALC_FALSE;
  2.1853 +                break;
  2.1854 +
  2.1855 +            case ALC_FORMAT_CHANNELS_SOFT:
  2.1856 +                if(!device->IsLoopbackDevice)
  2.1857 +                    alcSetError(device, ALC_INVALID_DEVICE);
  2.1858 +                else
  2.1859 +                    *data = device->FmtChans;
  2.1860 +                break;
  2.1861 +
  2.1862 +            case ALC_FORMAT_TYPE_SOFT:
  2.1863 +                if(!device->IsLoopbackDevice)
  2.1864 +                    alcSetError(device, ALC_INVALID_DEVICE);
  2.1865 +                else
  2.1866 +                    *data = device->FmtType;
  2.1867 +                break;
  2.1868 +
  2.1869 +            case ALC_MONO_SOURCES:
  2.1870 +                *data = device->NumMonoSources;
  2.1871 +                break;
  2.1872 +
  2.1873 +            case ALC_STEREO_SOURCES:
  2.1874 +                *data = device->NumStereoSources;
  2.1875 +                break;
  2.1876 +
  2.1877 +            case ALC_MAX_AUXILIARY_SENDS:
  2.1878 +                *data = device->NumAuxSends;
  2.1879 +                break;
  2.1880 +
  2.1881 +            case ALC_CONNECTED:
  2.1882 +                *data = device->Connected;
  2.1883 +                break;
  2.1884 +
  2.1885 +            default:
  2.1886 +                alcSetError(device, ALC_INVALID_ENUM);
  2.1887 +                break;
  2.1888 +        }
  2.1889 +    }
  2.1890 +    UnlockLists();
  2.1891 +}
  2.1892 +
  2.1893 +
  2.1894 +/*
  2.1895 +    alcIsExtensionPresent
  2.1896 +
  2.1897 +    Determines if there is support for a particular extension
  2.1898 +*/
  2.1899 +ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extName)
  2.1900 +{
  2.1901 +    ALCboolean bResult = ALC_FALSE;
  2.1902 +    const char *ptr;
  2.1903 +    size_t len;
  2.1904 +
  2.1905 +    if(!extName)
  2.1906 +    {
  2.1907 +        alcSetError(device, ALC_INVALID_VALUE);
  2.1908 +        return ALC_FALSE;
  2.1909 +    }
  2.1910 +
  2.1911 +    len = strlen(extName);
  2.1912 +    LockLists();
  2.1913 +    ptr = (IsDevice(device) ? alcExtensionList : alcNoDeviceExtList);
  2.1914 +    UnlockLists();
  2.1915 +    while(ptr && *ptr)
  2.1916 +    {
  2.1917 +        if(strncasecmp(ptr, extName, len) == 0 &&
  2.1918 +           (ptr[len] == '\0' || isspace(ptr[len])))
  2.1919 +        {
  2.1920 +            bResult = ALC_TRUE;
  2.1921 +            break;
  2.1922 +        }
  2.1923 +        if((ptr=strchr(ptr, ' ')) != NULL)
  2.1924 +        {
  2.1925 +            do {
  2.1926 +                ++ptr;
  2.1927 +            } while(isspace(*ptr));
  2.1928 +        }
  2.1929 +    }
  2.1930 +
  2.1931 +    return bResult;
  2.1932 +}
  2.1933 +
  2.1934 +
  2.1935 +/*
  2.1936 +    alcGetProcAddress
  2.1937 +
  2.1938 +    Retrieves the function address for a particular extension function
  2.1939 +*/
  2.1940 +ALC_API ALCvoid* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcName)
  2.1941 +{
  2.1942 +    ALsizei i = 0;
  2.1943 +
  2.1944 +    if(!funcName)
  2.1945 +    {
  2.1946 +        alcSetError(device, ALC_INVALID_VALUE);
  2.1947 +        return NULL;
  2.1948 +    }
  2.1949 +
  2.1950 +    while(alcFunctions[i].funcName && strcmp(alcFunctions[i].funcName,funcName) != 0)
  2.1951 +        i++;
  2.1952 +    return alcFunctions[i].address;
  2.1953 +}
  2.1954 +
  2.1955 +
  2.1956 +/*
  2.1957 +    alcGetEnumValue
  2.1958 +
  2.1959 +    Get the value for a particular ALC Enumerated Value
  2.1960 +*/
  2.1961 +ALC_API ALCenum ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumName)
  2.1962 +{
  2.1963 +    ALsizei i = 0;
  2.1964 +
  2.1965 +    if(!enumName)
  2.1966 +    {
  2.1967 +        alcSetError(device, ALC_INVALID_VALUE);
  2.1968 +        return (ALCenum)0;
  2.1969 +    }
  2.1970 +
  2.1971 +    while(enumeration[i].enumName && strcmp(enumeration[i].enumName,enumName) != 0)
  2.1972 +        i++;
  2.1973 +    return enumeration[i].value;
  2.1974 +}
  2.1975 +
  2.1976 +
  2.1977 +/*
  2.1978 +    alcCreateContext
  2.1979 +
  2.1980 +    Create and attach a Context to a particular Device.
  2.1981 +*/
  2.1982 +ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrList)
  2.1983 +{
  2.1984 +    ALCcontext *ALContext;
  2.1985 +    void *temp;
  2.1986 +
  2.1987 +    LockLists();
  2.1988 +    if(!IsDevice(device) || device->IsCaptureDevice || !device->Connected)
  2.1989 +    {
  2.1990 +        alcSetError(device, ALC_INVALID_DEVICE);
  2.1991 +        UnlockLists();
  2.1992 +        return NULL;
  2.1993 +    }
  2.1994 +
  2.1995 +    // Reset Context Last Error code
  2.1996 +    device->LastError = ALC_NO_ERROR;
  2.1997 +
  2.1998 +    if(UpdateDeviceParams(device, attrList) == ALC_FALSE)
  2.1999 +    {
  2.2000 +        alcSetError(device, ALC_INVALID_DEVICE);
  2.2001 +        aluHandleDisconnect(device);
  2.2002 +        UnlockLists();
  2.2003 +        return NULL;
  2.2004 +    }
  2.2005 +
  2.2006 +    LockDevice(device);
  2.2007 +    ALContext = NULL;
  2.2008 +    temp = realloc(device->Contexts, (device->NumContexts+1) * sizeof(*device->Contexts));
  2.2009 +    if(temp)
  2.2010 +    {
  2.2011 +        device->Contexts = temp;
  2.2012 +
  2.2013 +        ALContext = calloc(1, sizeof(ALCcontext));
  2.2014 +        if(ALContext)
  2.2015 +        {
  2.2016 +            ALContext->MaxActiveSources = 256;
  2.2017 +            ALContext->ActiveSources = malloc(sizeof(ALContext->ActiveSources[0]) *
  2.2018 +                                              ALContext->MaxActiveSources);
  2.2019 +        }
  2.2020 +    }
  2.2021 +    if(!ALContext || !ALContext->ActiveSources)
  2.2022 +    {
  2.2023 +        free(ALContext);
  2.2024 +        alcSetError(device, ALC_OUT_OF_MEMORY);
  2.2025 +        UnlockDevice(device);
  2.2026 +        if(device->NumContexts == 0)
  2.2027 +        {
  2.2028 +            ALCdevice_StopPlayback(device);
  2.2029 +            device->Flags &= ~DEVICE_RUNNING;
  2.2030 +        }
  2.2031 +        UnlockLists();
  2.2032 +        return NULL;
  2.2033 +    }
  2.2034 +
  2.2035 +    device->Contexts[device->NumContexts++] = ALContext;
  2.2036 +    ALContext->Device = device;
  2.2037 +
  2.2038 +    InitContext(ALContext);
  2.2039 +    UnlockDevice(device);
  2.2040 +
  2.2041 +    ALContext->next = g_pContextList;
  2.2042 +    g_pContextList = ALContext;
  2.2043 +    g_ulContextCount++;
  2.2044 +
  2.2045 +    UnlockLists();
  2.2046 +
  2.2047 +    return ALContext;
  2.2048 +}
  2.2049 +
  2.2050 +
  2.2051 +/*
  2.2052 +    alcDestroyContext
  2.2053 +
  2.2054 +    Remove a Context
  2.2055 +*/
  2.2056 +ALC_API ALCvoid ALC_APIENTRY alcDestroyContext(ALCcontext *context)
  2.2057 +{
  2.2058 +    ALCdevice *Device;
  2.2059 +    ALCcontext **list;
  2.2060 +    ALuint i;
  2.2061 +
  2.2062 +    LockLists();
  2.2063 +    list = &g_pContextList;
  2.2064 +    while(*list && *list != context)
  2.2065 +        list = &(*list)->next;
  2.2066 +
  2.2067 +    if(!*list)
  2.2068 +    {
  2.2069 +        alcSetError(NULL, ALC_INVALID_CONTEXT);
  2.2070 +        UnlockLists();
  2.2071 +        return;
  2.2072 +    }
  2.2073 +
  2.2074 +    *list = (*list)->next;
  2.2075 +    g_ulContextCount--;
  2.2076 +
  2.2077 +    if(context == tls_get(LocalContext))
  2.2078 +        tls_set(LocalContext, NULL);
  2.2079 +    if(context == GlobalContext)
  2.2080 +        GlobalContext = NULL;
  2.2081 +
  2.2082 +    Device = context->Device;
  2.2083 +    LockDevice(Device);
  2.2084 +    for(i = 0;i < Device->NumContexts;i++)
  2.2085 +    {
  2.2086 +        if(Device->Contexts[i] == context)
  2.2087 +        {
  2.2088 +            Device->Contexts[i] = Device->Contexts[Device->NumContexts-1];
  2.2089 +            Device->NumContexts--;
  2.2090 +            break;
  2.2091 +        }
  2.2092 +    }
  2.2093 +    UnlockDevice(Device);
  2.2094 +
  2.2095 +    if(Device->NumContexts == 0)
  2.2096 +    {
  2.2097 +        ALCdevice_StopPlayback(Device);
  2.2098 +        Device->Flags &= ~DEVICE_RUNNING;
  2.2099 +    }
  2.2100 +    UnlockLists();
  2.2101 +
  2.2102 +    if(context->SourceMap.size > 0)
  2.2103 +    {
  2.2104 +        ERR("alcDestroyContext(): deleting %d Source(s)\n", context->SourceMap.size);
  2.2105 +        ReleaseALSources(context);
  2.2106 +    }
  2.2107 +    ResetUIntMap(&context->SourceMap);
  2.2108 +
  2.2109 +    if(context->EffectSlotMap.size > 0)
  2.2110 +    {
  2.2111 +        ERR("alcDestroyContext(): deleting %d AuxiliaryEffectSlot(s)\n", context->EffectSlotMap.size);
  2.2112 +        ReleaseALAuxiliaryEffectSlots(context);
  2.2113 +    }
  2.2114 +    ResetUIntMap(&context->EffectSlotMap);
  2.2115 +
  2.2116 +    free(context->ActiveSources);
  2.2117 +    context->ActiveSources = NULL;
  2.2118 +    context->MaxActiveSources = 0;
  2.2119 +    context->ActiveSourceCount = 0;
  2.2120 +
  2.2121 +    FreeContext(context);
  2.2122 +}
  2.2123 +
  2.2124 +
  2.2125 +/*
  2.2126 +    alcGetCurrentContext
  2.2127 +
  2.2128 +    Returns the currently active Context
  2.2129 +*/
  2.2130 +ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(ALCvoid)
  2.2131 +{
  2.2132 +    ALCcontext *Context;
  2.2133 +
  2.2134 +    LockLists();
  2.2135 +    Context = tls_get(LocalContext);
  2.2136 +    if(Context && !IsContext(Context))
  2.2137 +    {
  2.2138 +        tls_set(LocalContext, NULL);
  2.2139 +        Context = NULL;
  2.2140 +    }
  2.2141 +    if(!Context)
  2.2142 +        Context = GlobalContext;
  2.2143 +    UnlockLists();
  2.2144 +
  2.2145 +    return Context;
  2.2146 +}
  2.2147 +
  2.2148 +/*
  2.2149 +    alcGetThreadContext
  2.2150 +
  2.2151 +    Returns the currently active thread-local Context
  2.2152 +*/
  2.2153 +ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void)
  2.2154 +{
  2.2155 +    ALCcontext *pContext = NULL;
  2.2156 +
  2.2157 +    LockLists();
  2.2158 +
  2.2159 +    pContext = tls_get(LocalContext);
  2.2160 +    if(pContext && !IsContext(pContext))
  2.2161 +    {
  2.2162 +        tls_set(LocalContext, NULL);
  2.2163 +        pContext = NULL;
  2.2164 +    }
  2.2165 +
  2.2166 +    UnlockLists();
  2.2167 +
  2.2168 +    return pContext;
  2.2169 +}
  2.2170 +
  2.2171 +
  2.2172 +/*
  2.2173 +    alcGetContextsDevice
  2.2174 +
  2.2175 +    Returns the Device that a particular Context is attached to
  2.2176 +*/
  2.2177 +ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice(ALCcontext *pContext)
  2.2178 +{
  2.2179 +    ALCdevice *pDevice = NULL;
  2.2180 +
  2.2181 +    LockLists();
  2.2182 +    if(IsContext(pContext))
  2.2183 +        pDevice = pContext->Device;
  2.2184 +    else
  2.2185 +        alcSetError(NULL, ALC_INVALID_CONTEXT);
  2.2186 +    UnlockLists();
  2.2187 +
  2.2188 +    return pDevice;
  2.2189 +}
  2.2190 +
  2.2191 +
  2.2192 +/*
  2.2193 +    alcMakeContextCurrent
  2.2194 +
  2.2195 +    Makes the given Context the active Context
  2.2196 +*/
  2.2197 +ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context)
  2.2198 +{
  2.2199 +    ALboolean bReturn = AL_TRUE;
  2.2200 +
  2.2201 +    LockLists();
  2.2202 +
  2.2203 +    // context must be a valid Context or NULL
  2.2204 +    if(context == NULL || IsContext(context))
  2.2205 +    {
  2.2206 +        GlobalContext = context;
  2.2207 +        tls_set(LocalContext, NULL);
  2.2208 +    }
  2.2209 +    else
  2.2210 +    {
  2.2211 +        alcSetError(NULL, ALC_INVALID_CONTEXT);
  2.2212 +        bReturn = AL_FALSE;
  2.2213 +    }
  2.2214 +
  2.2215 +    UnlockLists();
  2.2216 +
  2.2217 +    return bReturn;
  2.2218 +}
  2.2219 +
  2.2220 +/*
  2.2221 +    alcSetThreadContext
  2.2222 +
  2.2223 +    Makes the given Context the active Context for the current thread
  2.2224 +*/
  2.2225 +ALC_API ALCboolean ALC_APIENTRY alcSetThreadContext(ALCcontext *context)
  2.2226 +{
  2.2227 +    ALboolean bReturn = AL_TRUE;
  2.2228 +
  2.2229 +    LockLists();
  2.2230 +
  2.2231 +    // context must be a valid Context or NULL
  2.2232 +    if(context == NULL || IsContext(context))
  2.2233 +        tls_set(LocalContext, context);
  2.2234 +    else
  2.2235 +    {
  2.2236 +        alcSetError(NULL, ALC_INVALID_CONTEXT);
  2.2237 +        bReturn = AL_FALSE;
  2.2238 +    }
  2.2239 +
  2.2240 +    UnlockLists();
  2.2241 +
  2.2242 +    return bReturn;
  2.2243 +}
  2.2244 +
  2.2245 +
  2.2246 +static void GetFormatFromString(const char *str, enum DevFmtChannels *chans, enum DevFmtType *type)
  2.2247 +{
  2.2248 +    if(strcasecmp(str, "AL_FORMAT_MONO32") == 0)
  2.2249 +    {
  2.2250 +        *chans = DevFmtMono;
  2.2251 +        *type = DevFmtFloat;
  2.2252 +        return;
  2.2253 +    }
  2.2254 +    if(strcasecmp(str, "AL_FORMAT_STEREO32") == 0)
  2.2255 +    {
  2.2256 +        *chans = DevFmtStereo;
  2.2257 +        *type = DevFmtFloat;
  2.2258 +        return;
  2.2259 +    }
  2.2260 +    if(strcasecmp(str, "AL_FORMAT_QUAD32") == 0)
  2.2261 +    {
  2.2262 +        *chans = DevFmtQuad;
  2.2263 +        *type = DevFmtFloat;
  2.2264 +        return;
  2.2265 +    }
  2.2266 +    if(strcasecmp(str, "AL_FORMAT_51CHN32") == 0)
  2.2267 +    {
  2.2268 +        *chans = DevFmtX51;
  2.2269 +        *type = DevFmtFloat;
  2.2270 +        return;
  2.2271 +    }
  2.2272 +    if(strcasecmp(str, "AL_FORMAT_61CHN32") == 0)
  2.2273 +    {
  2.2274 +        *chans = DevFmtX61;
  2.2275 +        *type = DevFmtFloat;
  2.2276 +        return;
  2.2277 +    }
  2.2278 +    if(strcasecmp(str, "AL_FORMAT_71CHN32") == 0)
  2.2279 +    {
  2.2280 +        *chans = DevFmtX71;
  2.2281 +        *type = DevFmtFloat;
  2.2282 +        return;
  2.2283 +    }
  2.2284 +
  2.2285 +    if(strcasecmp(str, "AL_FORMAT_MONO16") == 0)
  2.2286 +    {
  2.2287 +        *chans = DevFmtMono;
  2.2288 +        *type = DevFmtShort;
  2.2289 +        return;
  2.2290 +    }
  2.2291 +    if(strcasecmp(str, "AL_FORMAT_STEREO16") == 0)
  2.2292 +    {
  2.2293 +        *chans = DevFmtStereo;
  2.2294 +        *type = DevFmtShort;
  2.2295 +        return;
  2.2296 +    }
  2.2297 +    if(strcasecmp(str, "AL_FORMAT_QUAD16") == 0)
  2.2298 +    {
  2.2299 +        *chans = DevFmtQuad;
  2.2300 +        *type = DevFmtShort;
  2.2301 +        return;
  2.2302 +    }
  2.2303 +    if(strcasecmp(str, "AL_FORMAT_51CHN16") == 0)
  2.2304 +    {
  2.2305 +        *chans = DevFmtX51;
  2.2306 +        *type = DevFmtShort;
  2.2307 +        return;
  2.2308 +    }
  2.2309 +    if(strcasecmp(str, "AL_FORMAT_61CHN16") == 0)
  2.2310 +    {
  2.2311 +        *chans = DevFmtX61;
  2.2312 +        *type = DevFmtShort;
  2.2313 +        return;
  2.2314 +    }
  2.2315 +    if(strcasecmp(str, "AL_FORMAT_71CHN16") == 0)
  2.2316 +    {
  2.2317 +        *chans = DevFmtX71;
  2.2318 +        *type = DevFmtShort;
  2.2319 +        return;
  2.2320 +    }
  2.2321 +
  2.2322 +    if(strcasecmp(str, "AL_FORMAT_MONO8") == 0)
  2.2323 +    {
  2.2324 +        *chans = DevFmtMono;
  2.2325 +        *type = DevFmtByte;
  2.2326 +        return;
  2.2327 +    }
  2.2328 +    if(strcasecmp(str, "AL_FORMAT_STEREO8") == 0)
  2.2329 +    {
  2.2330 +        *chans = DevFmtStereo;
  2.2331 +        *type = DevFmtByte;
  2.2332 +        return;
  2.2333 +    }
  2.2334 +    if(strcasecmp(str, "AL_FORMAT_QUAD8") == 0)
  2.2335 +    {
  2.2336 +        *chans = DevFmtQuad;
  2.2337 +        *type = DevFmtByte;
  2.2338 +        return;
  2.2339 +    }
  2.2340 +    if(strcasecmp(str, "AL_FORMAT_51CHN8") == 0)
  2.2341 +    {
  2.2342 +        *chans = DevFmtX51;
  2.2343 +        *type = DevFmtByte;
  2.2344 +        return;
  2.2345 +    }
  2.2346 +    if(strcasecmp(str, "AL_FORMAT_61CHN8") == 0)
  2.2347 +    {
  2.2348 +        *chans = DevFmtX61;
  2.2349 +        *type = DevFmtByte;
  2.2350 +        return;
  2.2351 +    }
  2.2352 +    if(strcasecmp(str, "AL_FORMAT_71CHN8") == 0)
  2.2353 +    {
  2.2354 +        *chans = DevFmtX71;
  2.2355 +        *type = DevFmtByte;
  2.2356 +        return;
  2.2357 +    }
  2.2358 +
  2.2359 +    ERR("Unknown format: \"%s\"\n", str);
  2.2360 +    *chans = DevFmtStereo;
  2.2361 +    *type = DevFmtShort;
  2.2362 +}
  2.2363 +
  2.2364 +/*
  2.2365 +    alcOpenDevice
  2.2366 +
  2.2367 +    Open the Device specified.
  2.2368 +*/
  2.2369 +ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *deviceName)
  2.2370 +{
  2.2371 +    const ALCchar *fmt;
  2.2372 +    ALCdevice *device;
  2.2373 +
  2.2374 +    DO_INITCONFIG();
  2.2375 +
  2.2376 +    if(!PlaybackBackend.name)
  2.2377 +    {
  2.2378 +        alcSetError(NULL, ALC_INVALID_VALUE);
  2.2379 +        return NULL;
  2.2380 +    }
  2.2381 +
  2.2382 +    if(deviceName && (!deviceName[0] || strcasecmp(deviceName, "openal soft") == 0 || strcasecmp(deviceName, "openal-soft") == 0))
  2.2383 +        deviceName = NULL;
  2.2384 +
  2.2385 +    device = calloc(1, sizeof(ALCdevice));
  2.2386 +    if(!device)
  2.2387 +    {
  2.2388 +        alcSetError(NULL, ALC_OUT_OF_MEMORY);
  2.2389 +        return NULL;
  2.2390 +    }
  2.2391 +
  2.2392 +    //Validate device
  2.2393 +    device->Funcs = &PlaybackBackend.Funcs;
  2.2394 +    device->Connected = ALC_TRUE;
  2.2395 +    device->IsCaptureDevice = AL_FALSE;
  2.2396 +    device->IsLoopbackDevice = AL_FALSE;
  2.2397 +    InitializeCriticalSection(&device->Mutex);
  2.2398 +    device->LastError = ALC_NO_ERROR;
  2.2399 +
  2.2400 +    device->Flags = 0;
  2.2401 +    device->Bs2b = NULL;
  2.2402 +    device->szDeviceName = NULL;
  2.2403 +
  2.2404 +    device->Contexts = NULL;
  2.2405 +    device->NumContexts = 0;
  2.2406 +
  2.2407 +    InitUIntMap(&device->BufferMap);
  2.2408 +    InitUIntMap(&device->EffectMap);
  2.2409 +    InitUIntMap(&device->FilterMap);
  2.2410 +
  2.2411 +    //Set output format
  2.2412 +    if(ConfigValueExists(NULL, "frequency"))
  2.2413 +        device->Flags |= DEVICE_FREQUENCY_REQUEST;
  2.2414 +    device->Frequency = GetConfigValueInt(NULL, "frequency", DEFAULT_OUTPUT_RATE);
  2.2415 +    if(device->Frequency < 8000)
  2.2416 +        device->Frequency = 8000;
  2.2417 +
  2.2418 +    if(ConfigValueExists(NULL, "format"))
  2.2419 +        device->Flags |= DEVICE_CHANNELS_REQUEST;
  2.2420 +    fmt = GetConfigValue(NULL, "format", "AL_FORMAT_STEREO16");
  2.2421 +    GetFormatFromString(fmt, &device->FmtChans, &device->FmtType);
  2.2422 +
  2.2423 +    device->NumUpdates = GetConfigValueInt(NULL, "periods", 4);
  2.2424 +    if(device->NumUpdates < 2)
  2.2425 +        device->NumUpdates = 4;
  2.2426 +
  2.2427 +    device->UpdateSize = GetConfigValueInt(NULL, "period_size", 1024);
  2.2428 +    if(device->UpdateSize <= 0)
  2.2429 +        device->UpdateSize = 1024;
  2.2430 +
  2.2431 +    device->MaxNoOfSources = GetConfigValueInt(NULL, "sources", 256);
  2.2432 +    if(device->MaxNoOfSources <= 0)
  2.2433 +        device->MaxNoOfSources = 256;
  2.2434 +
  2.2435 +    device->AuxiliaryEffectSlotMax = GetConfigValueInt(NULL, "slots", 4);
  2.2436 +    if(device->AuxiliaryEffectSlotMax <= 0)
  2.2437 +        device->AuxiliaryEffectSlotMax = 4;
  2.2438 +
  2.2439 +    device->NumStereoSources = 1;
  2.2440 +    device->NumMonoSources = device->MaxNoOfSources - device->NumStereoSources;
  2.2441 +
  2.2442 +    device->NumAuxSends = GetConfigValueInt(NULL, "sends", MAX_SENDS);
  2.2443 +    if(device->NumAuxSends > MAX_SENDS)
  2.2444 +        device->NumAuxSends = MAX_SENDS;
  2.2445 +
  2.2446 +    device->Bs2bLevel = GetConfigValueInt(NULL, "cf_level", 0);
  2.2447 +
  2.2448 +    // Find a playback device to open
  2.2449 +    LockLists();
  2.2450 +    if(ALCdevice_OpenPlayback(device, deviceName))
  2.2451 +    {
  2.2452 +        device->next = g_pDeviceList;
  2.2453 +        g_pDeviceList = device;
  2.2454 +        g_ulDeviceCount++;
  2.2455 +    }
  2.2456 +    else
  2.2457 +    {
  2.2458 +        // No suitable output device found
  2.2459 +        DeleteCriticalSection(&device->Mutex);
  2.2460 +        free(device);
  2.2461 +        device = NULL;
  2.2462 +        alcSetError(NULL, ALC_INVALID_VALUE);
  2.2463 +    }
  2.2464 +    UnlockLists();
  2.2465 +
  2.2466 +    return device;
  2.2467 +}
  2.2468 +
  2.2469 +
  2.2470 +/*
  2.2471 +    alcCloseDevice
  2.2472 +
  2.2473 +    Close the specified Device
  2.2474 +*/
  2.2475 +ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *pDevice)
  2.2476 +{
  2.2477 +    ALCdevice **list;
  2.2478 +
  2.2479 +    LockLists();
  2.2480 +    list = &g_pDeviceList;
  2.2481 +    while(*list && *list != pDevice)
  2.2482 +        list = &(*list)->next;
  2.2483 +
  2.2484 +    if(!*list || (*list)->IsCaptureDevice)
  2.2485 +    {
  2.2486 +        alcSetError(*list, ALC_INVALID_DEVICE);
  2.2487 +        UnlockLists();
  2.2488 +        return ALC_FALSE;
  2.2489 +    }
  2.2490 +
  2.2491 +    *list = (*list)->next;
  2.2492 +    g_ulDeviceCount--;
  2.2493 +
  2.2494 +    UnlockLists();
  2.2495 +
  2.2496 +    if(pDevice->NumContexts > 0)
  2.2497 +    {
  2.2498 +        WARN("alcCloseDevice(): destroying %u Context(s)\n", pDevice->NumContexts);
  2.2499 +        while(pDevice->NumContexts > 0)
  2.2500 +            alcDestroyContext(pDevice->Contexts[0]);
  2.2501 +    }
  2.2502 +    ALCdevice_ClosePlayback(pDevice);
  2.2503 +
  2.2504 +    if(pDevice->BufferMap.size > 0)
  2.2505 +    {
  2.2506 +        WARN("alcCloseDevice(): deleting %d Buffer(s)\n", pDevice->BufferMap.size);
  2.2507 +        ReleaseALBuffers(pDevice);
  2.2508 +    }
  2.2509 +    ResetUIntMap(&pDevice->BufferMap);
  2.2510 +
  2.2511 +    if(pDevice->EffectMap.size > 0)
  2.2512 +    {
  2.2513 +        WARN("alcCloseDevice(): deleting %d Effect(s)\n", pDevice->EffectMap.size);
  2.2514 +        ReleaseALEffects(pDevice);
  2.2515 +    }
  2.2516 +    ResetUIntMap(&pDevice->EffectMap);
  2.2517 +
  2.2518 +    if(pDevice->FilterMap.size > 0)
  2.2519 +    {
  2.2520 +        WARN("alcCloseDevice(): deleting %d Filter(s)\n", pDevice->FilterMap.size);
  2.2521 +        ReleaseALFilters(pDevice);
  2.2522 +    }
  2.2523 +    ResetUIntMap(&pDevice->FilterMap);
  2.2524 +
  2.2525 +    free(pDevice->Bs2b);
  2.2526 +    pDevice->Bs2b = NULL;
  2.2527 +
  2.2528 +    free(pDevice->szDeviceName);
  2.2529 +    pDevice->szDeviceName = NULL;
  2.2530 +
  2.2531 +    free(pDevice->Contexts);
  2.2532 +    pDevice->Contexts = NULL;
  2.2533 +
  2.2534 +    DeleteCriticalSection(&pDevice->Mutex);
  2.2535 +
  2.2536 +    //Release device structure
  2.2537 +    memset(pDevice, 0, sizeof(ALCdevice));
  2.2538 +    free(pDevice);
  2.2539 +
  2.2540 +    return ALC_TRUE;
  2.2541 +}
  2.2542 +
  2.2543 +
  2.2544 +ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(void)
  2.2545 +{
  2.2546 +    ALCdevice *device;
  2.2547 +
  2.2548 +    DO_INITCONFIG();
  2.2549 +
  2.2550 +    device = calloc(1, sizeof(ALCdevice));
  2.2551 +    if(!device)
  2.2552 +    {
  2.2553 +        alcSetError(NULL, ALC_OUT_OF_MEMORY);
  2.2554 +        return NULL;
  2.2555 +    }
  2.2556 +
  2.2557 +    //Validate device
  2.2558 +    device->Funcs = &BackendLoopback.Funcs;
  2.2559 +    device->Connected = ALC_TRUE;
  2.2560 +    device->IsCaptureDevice = AL_FALSE;
  2.2561 +    device->IsLoopbackDevice = AL_TRUE;
  2.2562 +    InitializeCriticalSection(&device->Mutex);
  2.2563 +    device->LastError = ALC_NO_ERROR;
  2.2564 +
  2.2565 +    device->Flags = 0;
  2.2566 +    device->Bs2b = NULL;
  2.2567 +    device->szDeviceName = NULL;
  2.2568 +
  2.2569 +    device->Contexts = NULL;
  2.2570 +    device->NumContexts = 0;
  2.2571 +
  2.2572 +    InitUIntMap(&device->BufferMap);
  2.2573 +    InitUIntMap(&device->EffectMap);
  2.2574 +    InitUIntMap(&device->FilterMap);
  2.2575 +
  2.2576 +    //Set output format
  2.2577 +    device->Frequency = 44100;
  2.2578 +    device->FmtChans = DevFmtStereo;
  2.2579 +    device->FmtType = DevFmtShort;
  2.2580 +
  2.2581 +    device->NumUpdates = 0;
  2.2582 +    device->UpdateSize = 0;
  2.2583 +
  2.2584 +    device->MaxNoOfSources = GetConfigValueInt(NULL, "sources", 256);
  2.2585 +    if(device->MaxNoOfSources <= 0)
  2.2586 +        device->MaxNoOfSources = 256;
  2.2587 +
  2.2588 +    device->AuxiliaryEffectSlotMax = GetConfigValueInt(NULL, "slots", 4);
  2.2589 +    if(device->AuxiliaryEffectSlotMax <= 0)
  2.2590 +        device->AuxiliaryEffectSlotMax = 4;
  2.2591 +
  2.2592 +    device->NumStereoSources = 1;
  2.2593 +    device->NumMonoSources = device->MaxNoOfSources - device->NumStereoSources;
  2.2594 +
  2.2595 +    device->NumAuxSends = GetConfigValueInt(NULL, "sends", MAX_SENDS);
  2.2596 +    if(device->NumAuxSends > MAX_SENDS)
  2.2597 +        device->NumAuxSends = MAX_SENDS;
  2.2598 +
  2.2599 +    device->Bs2bLevel = GetConfigValueInt(NULL, "cf_level", 0);
  2.2600 +
  2.2601 +    // Open the "backend"
  2.2602 +    LockLists();
  2.2603 +    ALCdevice_OpenPlayback(device, "Loopback");
  2.2604 +
  2.2605 +    device->next = g_pDeviceList;
  2.2606 +    g_pDeviceList = device;
  2.2607 +    g_ulDeviceCount++;
  2.2608 +    UnlockLists();
  2.2609 +
  2.2610 +    return device;
  2.2611 +}
  2.2612 +
  2.2613 +ALC_API ALCboolean ALC_APIENTRY alcIsRenderFormatSupportedSOFT(ALCdevice *device, ALCsizei freq, ALCenum channels, ALCenum type)
  2.2614 +{
  2.2615 +    ALCboolean ret = ALC_FALSE;
  2.2616 +
  2.2617 +    LockLists();
  2.2618 +    if(!IsDevice(device) || !device->IsLoopbackDevice)
  2.2619 +        alcSetError(device, ALC_INVALID_DEVICE);
  2.2620 +    else if(freq <= 0)
  2.2621 +        alcSetError(device, ALC_INVALID_VALUE);
  2.2622 +    else if(!IsValidALCType(type) || !IsValidALCChannels(channels))
  2.2623 +        alcSetError(device, ALC_INVALID_ENUM);
  2.2624 +    else
  2.2625 +    {
  2.2626 +        if(BytesFromDevFmt(type) > 0 && ChannelsFromDevFmt(channels) > 0 &&
  2.2627 +           freq >= 8000)
  2.2628 +            ret = ALC_TRUE;
  2.2629 +    }
  2.2630 +    UnlockLists();
  2.2631 +
  2.2632 +    return ret;
  2.2633 +}
  2.2634 +
  2.2635 +ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
  2.2636 +{
  2.2637 +    LockLists();
  2.2638 +    if(!IsDevice(device) || !device->IsLoopbackDevice)
  2.2639 +        alcSetError(device, ALC_INVALID_DEVICE);
  2.2640 +    else if(samples < 0 || (samples > 0 && buffer == NULL))
  2.2641 +        alcSetError(device, ALC_INVALID_VALUE);
  2.2642 +    else
  2.2643 +        aluMixData(device, buffer, samples);
  2.2644 +    UnlockLists();
  2.2645 +}
  2.2646 +
  2.2647 +
  2.2648 +static void ReleaseALC(ALCboolean doclose)
  2.2649 +{
  2.2650 +    free(alcDeviceList); alcDeviceList = NULL;
  2.2651 +    alcDeviceListSize = 0;
  2.2652 +    free(alcAllDeviceList); alcAllDeviceList = NULL;
  2.2653 +    alcAllDeviceListSize = 0;
  2.2654 +    free(alcCaptureDeviceList); alcCaptureDeviceList = NULL;
  2.2655 +    alcCaptureDeviceListSize = 0;
  2.2656 +
  2.2657 +    free(alcDefaultDeviceSpecifier);
  2.2658 +    alcDefaultDeviceSpecifier = NULL;
  2.2659 +    free(alcDefaultAllDeviceSpecifier);
  2.2660 +    alcDefaultAllDeviceSpecifier = NULL;
  2.2661 +    free(alcCaptureDefaultDeviceSpecifier);
  2.2662 +    alcCaptureDefaultDeviceSpecifier = NULL;
  2.2663 +
  2.2664 +    if(doclose)
  2.2665 +    {
  2.2666 +        if(g_ulDeviceCount > 0)
  2.2667 +            WARN("ReleaseALC(): closing %u Device%s\n", g_ulDeviceCount, (g_ulDeviceCount>1)?"s":"");
  2.2668 +
  2.2669 +        while(g_pDeviceList)
  2.2670 +        {
  2.2671 +            if(g_pDeviceList->IsCaptureDevice)
  2.2672 +                alcCaptureCloseDevice(g_pDeviceList);
  2.2673 +            else
  2.2674 +                alcCloseDevice(g_pDeviceList);
  2.2675 +        }
  2.2676 +    }
  2.2677 +    else
  2.2678 +    {
  2.2679 +        if(g_ulDeviceCount > 0)
  2.2680 +            WARN("ReleaseALC(): %u Device%s not closed\n", g_ulDeviceCount, (g_ulDeviceCount>1)?"s":"");
  2.2681 +    }
  2.2682 +}
  2.2683 +
  2.2684 +///////////////////////////////////////////////////////

     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/Alc/ALu.c	Tue Oct 25 13:02:31 2011 -0700
     3.3 @@ -0,0 +1,1168 @@
     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 +#include <math.h>
    3.27 +#include <stdlib.h>
    3.28 +#include <string.h>
    3.29 +#include <ctype.h>
    3.30 +#include <assert.h>
    3.31 +
    3.32 +#include "alMain.h"
    3.33 +#include "AL/al.h"
    3.34 +#include "AL/alc.h"
    3.35 +#include "alSource.h"
    3.36 +#include "alBuffer.h"
    3.37 +#include "alListener.h"
    3.38 +#include "alAuxEffectSlot.h"
    3.39 +#include "alu.h"
    3.40 +#include "bs2b.h"
    3.41 +
    3.42 +
    3.43 +static __inline ALvoid aluCrossproduct(const ALfloat *inVector1, const ALfloat *inVector2, ALfloat *outVector)
    3.44 +{
    3.45 +    outVector[0] = inVector1[1]*inVector2[2] - inVector1[2]*inVector2[1];
    3.46 +    outVector[1] = inVector1[2]*inVector2[0] - inVector1[0]*inVector2[2];
    3.47 +    outVector[2] = inVector1[0]*inVector2[1] - inVector1[1]*inVector2[0];
    3.48 +}
    3.49 +
    3.50 +static __inline ALfloat aluDotproduct(const ALfloat *inVector1, const ALfloat *inVector2)
    3.51 +{
    3.52 +    return inVector1[0]*inVector2[0] + inVector1[1]*inVector2[1] +
    3.53 +           inVector1[2]*inVector2[2];
    3.54 +}
    3.55 +
    3.56 +static __inline ALvoid aluNormalize(ALfloat *inVector)
    3.57 +{
    3.58 +    ALfloat length, inverse_length;
    3.59 +
    3.60 +    length = aluSqrt(aluDotproduct(inVector, inVector));
    3.61 +    if(length != 0.0f)
    3.62 +    {
    3.63 +        inverse_length = 1.0f/length;
    3.64 +        inVector[0] *= inverse_length;
    3.65 +        inVector[1] *= inverse_length;
    3.66 +        inVector[2] *= inverse_length;
    3.67 +    }
    3.68 +}
    3.69 +
    3.70 +static __inline ALvoid aluMatrixVector(ALfloat *vector,ALfloat w,ALfloat matrix[4][4])
    3.71 +{
    3.72 +    ALfloat temp[4] = {
    3.73 +        vector[0], vector[1], vector[2], w
    3.74 +    };
    3.75 +
    3.76 +    vector[0] = temp[0]*matrix[0][0] + temp[1]*matrix[1][0] + temp[2]*matrix[2][0] + temp[3]*matrix[3][0];
    3.77 +    vector[1] = temp[0]*matrix[0][1] + temp[1]*matrix[1][1] + temp[2]*matrix[2][1] + temp[3]*matrix[3][1];
    3.78 +    vector[2] = temp[0]*matrix[0][2] + temp[1]*matrix[1][2] + temp[2]*matrix[2][2] + temp[3]*matrix[3][2];
    3.79 +}
    3.80 +
    3.81 +
    3.82 +ALvoid CalcNonAttnSourceParams(ALsource *ALSource, const ALCcontext *ALContext)
    3.83 +{
    3.84 +    static const ALfloat angles_Mono[1] = { 0.0f };
    3.85 +    static const ALfloat angles_Stereo[2] = { -30.0f, 30.0f };
    3.86 +    static const ALfloat angles_Rear[2] = { -150.0f, 150.0f };
    3.87 +    static const ALfloat angles_Quad[4] = { -45.0f, 45.0f, -135.0f, 135.0f };
    3.88 +    static const ALfloat angles_X51[6] = { -30.0f, 30.0f, 0.0f, 0.0f,
    3.89 +                                           -110.0f, 110.0f };
    3.90 +    static const ALfloat angles_X61[7] = { -30.0f, 30.0f, 0.0f, 0.0f,
    3.91 +                                           180.0f, -90.0f, 90.0f };
    3.92 +    static const ALfloat angles_X71[8] = { -30.0f, 30.0f, 0.0f, 0.0f,
    3.93 +                                           -110.0f, 110.0f, -90.0f, 90.0f };
    3.94 +
    3.95 +    static const enum Channel chans_Mono[1] = { FRONT_CENTER };
    3.96 +    static const enum Channel chans_Stereo[2] = { FRONT_LEFT, FRONT_RIGHT };
    3.97 +    static const enum Channel chans_Rear[2] = { BACK_LEFT, BACK_RIGHT };
    3.98 +    static const enum Channel chans_Quad[4] = { FRONT_LEFT, FRONT_RIGHT,
    3.99 +                                                BACK_LEFT, BACK_RIGHT };
   3.100 +    static const enum Channel chans_X51[6] = { FRONT_LEFT, FRONT_RIGHT,
   3.101 +                                               FRONT_CENTER, LFE,
   3.102 +                                               BACK_LEFT, BACK_RIGHT };
   3.103 +    static const enum Channel chans_X61[7] = { FRONT_LEFT, FRONT_RIGHT,
   3.104 +                                               FRONT_CENTER, LFE, BACK_CENTER,
   3.105 +                                               SIDE_LEFT, SIDE_RIGHT };
   3.106 +    static const enum Channel chans_X71[8] = { FRONT_LEFT, FRONT_RIGHT,
   3.107 +                                               FRONT_CENTER, LFE,
   3.108 +                                               BACK_LEFT, BACK_RIGHT,
   3.109 +                                               SIDE_LEFT, SIDE_RIGHT };
   3.110 +
   3.111 +    ALCdevice *Device = ALContext->Device;
   3.112 +    ALfloat SourceVolume,ListenerGain,MinVolume,MaxVolume;
   3.113 +    ALbufferlistitem *BufferListItem;
   3.114 +    enum DevFmtChannels DevChans;
   3.115 +    enum FmtChannels Channels;
   3.116 +    ALfloat (*SrcMatrix)[MAXCHANNELS];
   3.117 +    ALfloat DryGain, DryGainHF;
   3.118 +    ALfloat WetGain[MAX_SENDS];
   3.119 +    ALfloat WetGainHF[MAX_SENDS];
   3.120 +    ALint NumSends, Frequency;
   3.121 +    const ALfloat *SpeakerGain;
   3.122 +    const ALfloat *angles = NULL;
   3.123 +    const enum Channel *chans = NULL;
   3.124 +    enum Resampler Resampler;
   3.125 +    ALint num_channels = 0;
   3.126 +    ALboolean VirtualChannels;
   3.127 +    ALfloat Pitch;
   3.128 +    ALfloat cw;
   3.129 +    ALuint pos;
   3.130 +    ALint i, c;
   3.131 +
   3.132 +    /* Get device properties */
   3.133 +    DevChans  = ALContext->Device->FmtChans;
   3.134 +    NumSends  = ALContext->Device->NumAuxSends;
   3.135 +    Frequency = ALContext->Device->Frequency;
   3.136 +
   3.137 +    /* Get listener properties */
   3.138 +    ListenerGain = ALContext->Listener.Gain;
   3.139 +
   3.140 +    /* Get source properties */
   3.141 +    SourceVolume    = ALSource->flGain;
   3.142 +    MinVolume       = ALSource->flMinGain;
   3.143 +    MaxVolume       = ALSource->flMaxGain;
   3.144 +    Pitch           = ALSource->flPitch;
   3.145 +    Resampler       = ALSource->Resampler;
   3.146 +    VirtualChannels = ALSource->VirtualChannels;
   3.147 +
   3.148 +    /* Calculate the stepping value */
   3.149 +    Channels = FmtMono;
   3.150 +    BufferListItem = ALSource->queue;
   3.151 +    while(BufferListItem != NULL)
   3.152 +    {
   3.153 +        ALbuffer *ALBuffer;
   3.154 +        if((ALBuffer=BufferListItem->buffer) != NULL)
   3.155 +        {
   3.156 +            ALint maxstep = STACK_DATA_SIZE / ALSource->NumChannels /
   3.157 +                                              ALSource->SampleSize;
   3.158 +            maxstep -= ResamplerPadding[Resampler] +
   3.159 +                       ResamplerPrePadding[Resampler] + 1;
   3.160 +            maxstep = mini(maxstep, INT_MAX>>FRACTIONBITS);
   3.161 +
   3.162 +            Pitch = Pitch * ALBuffer->Frequency / Frequency;
   3.163 +            if(Pitch > (ALfloat)maxstep)
   3.164 +                ALSource->Params.Step = maxstep<<FRACTIONBITS;
   3.165 +            else
   3.166 +            {
   3.167 +                ALSource->Params.Step = Pitch*FRACTIONONE;
   3.168 +                if(ALSource->Params.Step == 0)
   3.169 +                    ALSource->Params.Step = 1;
   3.170 +            }
   3.171 +
   3.172 +            Channels = ALBuffer->FmtChannels;
   3.173 +
   3.174 +            if(ALSource->VirtualChannels && (Device->Flags&DEVICE_USE_HRTF))
   3.175 +                ALSource->Params.DoMix = SelectHrtfMixer(ALBuffer,
   3.176 +                       (ALSource->Params.Step==FRACTIONONE) ? POINT_RESAMPLER :
   3.177 +                                                              Resampler);
   3.178 +            else
   3.179 +                ALSource->Params.DoMix = SelectMixer(ALBuffer,
   3.180 +                       (ALSource->Params.Step==FRACTIONONE) ? POINT_RESAMPLER :
   3.181 +                                                              Resampler);
   3.182 +            break;
   3.183 +        }
   3.184 +        BufferListItem = BufferListItem->next;
   3.185 +    }
   3.186 +
   3.187 +    /* Calculate gains */
   3.188 +    DryGain = clampf(SourceVolume, MinVolume, MaxVolume);
   3.189 +    DryGainHF = 1.0f;
   3.190 +    switch(ALSource->DirectFilter.type)
   3.191 +    {
   3.192 +        case AL_FILTER_LOWPASS:
   3.193 +            DryGain *= ALSource->DirectFilter.Gain;
   3.194 +            DryGainHF *= ALSource->DirectFilter.GainHF;
   3.195 +            break;
   3.196 +    }
   3.197 +    for(i = 0;i < NumSends;i++)
   3.198 +    {
   3.199 +        WetGain[i] = clampf(SourceVolume, MinVolume, MaxVolume);
   3.200 +        WetGainHF[i] = 1.0f;
   3.201 +        switch(ALSource->Send[i].WetFilter.type)
   3.202 +        {
   3.203 +            case AL_FILTER_LOWPASS:
   3.204 +                WetGain[i] *= ALSource->Send[i].WetFilter.Gain;
   3.205 +                WetGainHF[i] *= ALSource->Send[i].WetFilter.GainHF;
   3.206 +                break;
   3.207 +        }
   3.208 +    }
   3.209 +
   3.210 +    SrcMatrix = ALSource->Params.DryGains;
   3.211 +    for(i = 0;i < MAXCHANNELS;i++)
   3.212 +    {
   3.213 +        for(c = 0;c < MAXCHANNELS;c++)
   3.214 +            SrcMatrix[i][c] = 0.0f;
   3.215 +    }
   3.216 +    switch(Channels)
   3.217 +    {
   3.218 +    case FmtMono:
   3.219 +        angles = angles_Mono;
   3.220 +        chans = chans_Mono;
   3.221 +        num_channels = 1;
   3.222 +        break;
   3.223 +    case FmtStereo:
   3.224 +        if(VirtualChannels && (ALContext->Device->Flags&DEVICE_DUPLICATE_STEREO))
   3.225 +        {
   3.226 +            DryGain *= aluSqrt(2.0f/4.0f);
   3.227 +            for(c = 0;c < 2;c++)
   3.228 +            {
   3.229 +                pos = aluCart2LUTpos(cos(angles_Rear[c] * (M_PI/180.0)),
   3.230 +                                     sin(angles_Rear[c] * (M_PI/180.0)));
   3.231 +                SpeakerGain = Device->PanningLUT[pos];
   3.232 +
   3.233 +                for(i = 0;i < (ALint)Device->NumChan;i++)
   3.234 +                {
   3.235 +                    enum Channel chan = Device->Speaker2Chan[i];
   3.236 +                    SrcMatrix[c][chan] += DryGain * ListenerGain *
   3.237 +                                          SpeakerGain[chan];
   3.238 +                }
   3.239 +            }
   3.240 +        }
   3.241 +        angles = angles_Stereo;
   3.242 +        chans = chans_Stereo;
   3.243 +        num_channels = 2;
   3.244 +        break;
   3.245 +
   3.246 +    case FmtRear:
   3.247 +        angles = angles_Rear;
   3.248 +        chans = chans_Rear;
   3.249 +        num_channels = 2;
   3.250 +        break;
   3.251 +
   3.252 +    case FmtQuad:
   3.253 +        angles = angles_Quad;
   3.254 +        chans = chans_Quad;
   3.255 +        num_channels = 4;
   3.256 +        break;
   3.257 +
   3.258 +    case FmtX51:
   3.259 +        angles = angles_X51;
   3.260 +        chans = chans_X51;
   3.261 +        num_channels = 6;
   3.262 +        break;
   3.263 +
   3.264 +    case FmtX61:
   3.265 +        angles = angles_X61;
   3.266 +        chans = chans_X61;
   3.267 +        num_channels = 7;
   3.268 +        break;
   3.269 +
   3.270 +    case FmtX71:
   3.271 +        angles = angles_X71;
   3.272 +        chans = chans_X71;
   3.273 +        num_channels = 8;
   3.274 +        break;
   3.275 +    }
   3.276 +
   3.277 +    if(VirtualChannels == AL_FALSE)
   3.278 +    {
   3.279 +        for(c = 0;c < num_channels;c++)
   3.280 +            SrcMatrix[c][chans[c]] += DryGain * ListenerGain;
   3.281 +    }
   3.282 +    else if((Device->Flags&DEVICE_USE_HRTF))
   3.283 +    {
   3.284 +        for(c = 0;c < num_channels;c++)
   3.285 +        {
   3.286 +            if(chans[c] == LFE)
   3.287 +            {
   3.288 +                /* Skip LFE */
   3.289 +                ALSource->Params.HrtfDelay[c][0] = 0;
   3.290 +                ALSource->Params.HrtfDelay[c][1] = 0;
   3.291 +                for(i = 0;i < HRIR_LENGTH;i++)
   3.292 +                {
   3.293 +                    ALSource->Params.HrtfCoeffs[c][i][0] = 0.0f;
   3.294 +                    ALSource->Params.HrtfCoeffs[c][i][1] = 0.0f;
   3.295 +                }
   3.296 +            }
   3.297 +            else
   3.298 +            {
   3.299 +                /* Get the static HRIR coefficients and delays for this
   3.300 +                 * channel. */
   3.301 +                GetLerpedHrtfCoeffs(0.0, angles[c] * (M_PI/180.0),
   3.302 +                                    DryGain*ListenerGain,
   3.303 +                                    ALSource->Params.HrtfCoeffs[c],
   3.304 +                                    ALSource->Params.HrtfDelay[c]);
   3.305 +            }
   3.306 +            ALSource->HrtfCounter = 0;
   3.307 +        }
   3.308 +    }
   3.309 +    else
   3.310 +    {
   3.311 +        for(c = 0;c < num_channels;c++)
   3.312 +        {
   3.313 +            if(chans[c] == LFE) /* Special-case LFE */
   3.314 +            {
   3.315 +                SrcMatrix[c][LFE] += DryGain * ListenerGain;
   3.316 +                continue;
   3.317 +            }
   3.318 +            pos = aluCart2LUTpos(cos(angles[c] * (M_PI/180.0)),
   3.319 +                                 sin(angles[c] * (M_PI/180.0)));
   3.320 +            SpeakerGain = Device->PanningLUT[pos];
   3.321 +
   3.322 +            for(i = 0;i < (ALint)Device->NumChan;i++)
   3.323 +            {
   3.324 +                enum Channel chan = Device->Speaker2Chan[i];
   3.325 +                SrcMatrix[c][chan] += DryGain * ListenerGain *
   3.326 +                                      SpeakerGain[chan];
   3.327 +            }
   3.328 +        }
   3.329 +    }
   3.330 +    for(i = 0;i < NumSends;i++)
   3.331 +    {
   3.332 +        ALSource->Params.Send[i].Slot = ALSource->Send[i].Slot;
   3.333 +        ALSource->Params.Send[i].WetGain = WetGain[i] * ListenerGain;
   3.334 +    }
   3.335 +
   3.336 +    /* Update filter coefficients. Calculations based on the I3DL2
   3.337 +     * spec. */
   3.338 +    cw = cos(2.0*M_PI * LOWPASSFREQCUTOFF / Frequency);
   3.339 +
   3.340 +    /* We use two chained one-pole filters, so we need to take the
   3.341 +     * square root of the squared gain, which is the same as the base
   3.342 +     * gain. */
   3.343 +    ALSource->Params.iirFilter.coeff = lpCoeffCalc(DryGainHF, cw);
   3.344 +    for(i = 0;i < NumSends;i++)
   3.345 +    {
   3.346 +        /* We use a one-pole filter, so we need to take the squared gain */
   3.347 +        ALfloat a = lpCoeffCalc(WetGainHF[i]*WetGainHF[i], cw);
   3.348 +        ALSource->Params.Send[i].iirFilter.coeff = a;
   3.349 +    }
   3.350 +}
   3.351 +
   3.352 +ALvoid CalcSourceParams(ALsource *ALSource, const ALCcontext *ALContext)
   3.353 +{
   3.354 +    const ALCdevice *Device = ALContext->Device;
   3.355 +    ALfloat InnerAngle,OuterAngle,Angle,Distance,ClampedDist;
   3.356 +    ALfloat Direction[3],Position[3],SourceToListener[3];
   3.357 +    ALfloat Velocity[3],ListenerVel[3];
   3.358 +    ALfloat MinVolume,MaxVolume,MinDist,MaxDist,Rolloff;
   3.359 +    ALfloat ConeVolume,ConeHF,SourceVolume,ListenerGain;
   3.360 +    ALfloat DopplerFactor, DopplerVelocity, SpeedOfSound;
   3.361 +    ALfloat AirAbsorptionFactor;
   3.362 +    ALfloat RoomAirAbsorption[MAX_SENDS];
   3.363 +    ALbufferlistitem *BufferListItem;
   3.364 +    ALfloat Attenuation, EffectiveDist;
   3.365 +    ALfloat RoomAttenuation[MAX_SENDS];
   3.366 +    ALfloat MetersPerUnit;
   3.367 +    ALfloat RoomRolloffBase;
   3.368 +    ALfloat RoomRolloff[MAX_SENDS];
   3.369 +    ALfloat DecayDistance[MAX_SENDS];
   3.370 +    ALfloat DryGain;
   3.371 +    ALfloat DryGainHF;
   3.372 +    ALboolean DryGainHFAuto;
   3.373 +    ALfloat WetGain[MAX_SENDS];
   3.374 +    ALfloat WetGainHF[MAX_SENDS];
   3.375 +    ALboolean WetGainAuto;
   3.376 +    ALboolean WetGainHFAuto;
   3.377 +    enum Resampler Resampler;
   3.378 +    ALfloat Pitch;
   3.379 +    ALuint Frequency;
   3.380 +    ALint NumSends;
   3.381 +    ALfloat cw;
   3.382 +    ALint i;
   3.383 +
   3.384 +    DryGainHF = 1.0f;
   3.385 +    for(i = 0;i < MAX_SENDS;i++)
   3.386 +        WetGainHF[i] = 1.0f;
   3.387 +
   3.388 +    //Get context properties
   3.389 +    DopplerFactor   = ALContext->DopplerFactor * ALSource->DopplerFactor;
   3.390 +    DopplerVelocity = ALContext->DopplerVelocity;
   3.391 +    SpeedOfSound    = ALContext->flSpeedOfSound;
   3.392 +    NumSends        = Device->NumAuxSends;
   3.393 +    Frequency       = Device->Frequency;
   3.394 +
   3.395 +    //Get listener properties
   3.396 +    ListenerGain = ALContext->Listener.Gain;
   3.397 +    MetersPerUnit = ALContext->Listener.MetersPerUnit;
   3.398 +    memcpy(ListenerVel, ALContext->Listener.Velocity, sizeof(ALContext->Listener.Velocity));
   3.399 +
   3.400 +    //Get source properties
   3.401 +    SourceVolume = ALSource->flGain;
   3.402 +    MinVolume    = ALSource->flMinGain;
   3.403 +    MaxVolume    = ALSource->flMaxGain;
   3.404 +    Pitch        = ALSource->flPitch;
   3.405 +    Resampler    = ALSource->Resampler;
   3.406 +    memcpy(Position,  ALSource->vPosition,    sizeof(ALSource->vPosition));
   3.407 +    memcpy(Direction, ALSource->vOrientation, sizeof(ALSource->vOrientation));
   3.408 +    memcpy(Velocity,  ALSource->vVelocity,    sizeof(ALSource->vVelocity));
   3.409 +    MinDist = ALSource->flRefDistance;
   3.410 +    MaxDist = ALSource->flMaxDistance;
   3.411 +    Rolloff = ALSource->flRollOffFactor;
   3.412 +    InnerAngle = ALSource->flInnerAngle * ConeScale;
   3.413 +    OuterAngle = ALSource->flOuterAngle * ConeScale;
   3.414 +    AirAbsorptionFactor = ALSource->AirAbsorptionFactor;
   3.415 +    DryGainHFAuto = ALSource->DryGainHFAuto;
   3.416 +    WetGainAuto   = ALSource->WetGainAuto;
   3.417 +    WetGainHFAuto = ALSource->WetGainHFAuto;
   3.418 +    RoomRolloffBase = ALSource->RoomRolloffFactor;
   3.419 +    for(i = 0;i < NumSends;i++)
   3.420 +    {
   3.421 +        ALeffectslot *Slot = ALSource->Send[i].Slot;
   3.422 +
   3.423 +        if(!Slot || Slot->effect.type == AL_EFFECT_NULL)
   3.424 +        {
   3.425 +            RoomRolloff[i] = 0.0f;
   3.426 +            DecayDistance[i] = 0.0f;
   3.427 +            RoomAirAbsorption[i] = 1.0f;
   3.428 +        }
   3.429 +        else if(Slot->AuxSendAuto)
   3.430 +        {
   3.431 +            RoomRolloff[i] = RoomRolloffBase;
   3.432 +            if(IsReverbEffect(Slot->effect.type))
   3.433 +            {
   3.434 +                RoomRolloff[i] += Slot->effect.Params.Reverb.RoomRolloffFactor;
   3.435 +                DecayDistance[i] = Slot->effect.Params.Reverb.DecayTime *
   3.436 +                                   SPEEDOFSOUNDMETRESPERSEC;
   3.437 +                RoomAirAbsorption[i] = Slot->effect.Params.Reverb.AirAbsorptionGainHF;
   3.438 +            }
   3.439 +            else
   3.440 +            {
   3.441 +                DecayDistance[i] = 0.0f;
   3.442 +                RoomAirAbsorption[i] = 1.0f;
   3.443 +            }
   3.444 +        }
   3.445 +        else
   3.446 +        {
   3.447 +            /* If the slot's auxiliary send auto is off, the data sent to the
   3.448 +             * effect slot is the same as the dry path, sans filter effects */
   3.449 +            RoomRolloff[i] = Rolloff;
   3.450 +            DecayDistance[i] = 0.0f;
   3.451 +            RoomAirAbsorption[i] = AIRABSORBGAINHF;
   3.452 +        }
   3.453 +
   3.454 +        ALSource->Params.Send[i].Slot = Slot;
   3.455 +    }
   3.456 +
   3.457 +    //1. Translate Listener to origin (convert to head relative)
   3.458 +    if(ALSource->bHeadRelative == AL_FALSE)
   3.459 +    {
   3.460 +        ALfloat U[3],V[3],N[3];
   3.461 +        ALfloat Matrix[4][4];
   3.462 +
   3.463 +        // Build transform matrix
   3.464 +        memcpy(N, ALContext->Listener.Forward, sizeof(N));  // At-vector
   3.465 +        aluNormalize(N);  // Normalized At-vector
   3.466 +        memcpy(V, ALContext->Listener.Up, sizeof(V));  // Up-vector
   3.467 +        aluNormalize(V);  // Normalized Up-vector
   3.468 +        aluCrossproduct(N, V, U); // Right-vector
   3.469 +        aluNormalize(U);  // Normalized Right-vector
   3.470 +        Matrix[0][0] = U[0]; Matrix[0][1] = V[0]; Matrix[0][2] = -N[0]; Matrix[0][3] = 0.0f;
   3.471 +        Matrix[1][0] = U[1]; Matrix[1][1] = V[1]; Matrix[1][2] = -N[1]; Matrix[1][3] = 0.0f;
   3.472 +        Matrix[2][0] = U[2]; Matrix[2][1] = V[2]; Matrix[2][2] = -N[2]; Matrix[2][3] = 0.0f;
   3.473 +        Matrix[3][0] = 0.0f; Matrix[3][1] = 0.0f; Matrix[3][2] =  0.0f; Matrix[3][3] = 1.0f;
   3.474 +
   3.475 +        // Translate position
   3.476 +        Position[0] -= ALContext->Listener.Position[0];
   3.477 +        Position[1] -= ALContext->Listener.Position[1];
   3.478 +        Position[2] -= ALContext->Listener.Position[2];
   3.479 +
   3.480 +        // Transform source position and direction into listener space
   3.481 +        aluMatrixVector(Position, 1.0f, Matrix);
   3.482 +        aluMatrixVector(Direction, 0.0f, Matrix);
   3.483 +        // Transform source and listener velocity into listener space
   3.484 +        aluMatrixVector(Velocity, 0.0f, Matrix);
   3.485 +        aluMatrixVector(ListenerVel, 0.0f, Matrix);
   3.486 +    }
   3.487 +    else
   3.488 +        ListenerVel[0] = ListenerVel[1] = ListenerVel[2] = 0.0f;
   3.489 +
   3.490 +    SourceToListener[0] = -Position[0];
   3.491 +    SourceToListener[1] = -Position[1];
   3.492 +    SourceToListener[2] = -Position[2];
   3.493 +    aluNormalize(SourceToListener);
   3.494 +    aluNormalize(Direction);
   3.495 +
   3.496 +    //2. Calculate distance attenuation
   3.497 +    Distance = aluSqrt(aluDotproduct(Position, Position));
   3.498 +    ClampedDist = Distance;
   3.499 +
   3.500 +    Attenuation = 1.0f;
   3.501 +    for(i = 0;i < NumSends;i++)
   3.502 +        RoomAttenuation[i] = 1.0f;
   3.503 +    switch(ALContext->SourceDistanceModel ? ALSource->DistanceModel :
   3.504 +                                            ALContext->DistanceModel)
   3.505 +    {
   3.506 +        case InverseDistanceClamped:
   3.507 +            ClampedDist = clampf(ClampedDist, MinDist, MaxDist);
   3.508 +            if(MaxDist < MinDist)
   3.509 +                break;
   3.510 +            //fall-through
   3.511 +        case InverseDistance:
   3.512 +            if(MinDist > 0.0f)
   3.513 +            {
   3.514 +                if((MinDist + (Rolloff * (ClampedDist - MinDist))) > 0.0f)
   3.515 +                    Attenuation = MinDist / (MinDist + (Rolloff * (ClampedDist - MinDist)));
   3.516 +                for(i = 0;i < NumSends;i++)
   3.517 +                {
   3.518 +                    if((MinDist + (RoomRolloff[i] * (ClampedDist - MinDist))) > 0.0f)
   3.519 +                        RoomAttenuation[i] = MinDist / (MinDist + (RoomRolloff[i] * (ClampedDist - MinDist)));
   3.520 +                }
   3.521 +            }
   3.522 +            break;
   3.523 +
   3.524 +        case LinearDistanceClamped:
   3.525 +            ClampedDist = clampf(ClampedDist, MinDist, MaxDist);
   3.526 +            if(MaxDist < MinDist)
   3.527 +                break;
   3.528 +            //fall-through
   3.529 +        case LinearDistance:
   3.530 +            if(MaxDist != MinDist)
   3.531 +            {
   3.532 +                Attenuation = 1.0f - (Rolloff*(ClampedDist-MinDist)/(MaxDist - MinDist));
   3.533 +                Attenuation = maxf(Attenuation, 0.0f);
   3.534 +                for(i = 0;i < NumSends;i++)
   3.535 +                {
   3.536 +                    RoomAttenuation[i] = 1.0f - (RoomRolloff[i]*(ClampedDist-MinDist)/(MaxDist - MinDist));
   3.537 +                    RoomAttenuation[i] = maxf(RoomAttenuation[i], 0.0f);
   3.538 +                }
   3.539 +            }
   3.540 +            break;
   3.541 +
   3.542 +        case ExponentDistanceClamped:
   3.543 +            ClampedDist = clampf(ClampedDist, MinDist, MaxDist);
   3.544 +            if(MaxDist < MinDist)
   3.545 +                break;
   3.546 +            //fall-through
   3.547 +        case ExponentDistance:
   3.548 +            if(ClampedDist > 0.0f && MinDist > 0.0f)
   3.549 +            {
   3.550 +                Attenuation = aluPow(ClampedDist/MinDist, -Rolloff);
   3.551 +                for(i = 0;i < NumSends;i++)
   3.552 +                    RoomAttenuation[i] = aluPow(ClampedDist/MinDist, -RoomRolloff[i]);
   3.553 +            }
   3.554 +            break;
   3.555 +
   3.556 +        case DisableDistance:
   3.557 +            break;
   3.558 +    }
   3.559 +
   3.560 +    // Source Gain + Attenuation
   3.561 +    DryGain = SourceVolume * Attenuation;
   3.562 +    for(i = 0;i < NumSends;i++)
   3.563 +        WetGain[i] = SourceVolume * RoomAttenuation[i];
   3.564 +
   3.565 +    // Distance-based air absorption
   3.566 +    EffectiveDist = 0.0f;
   3.567 +    if(MinDist > 0.0f && Attenuation < 1.0f)
   3.568 +        EffectiveDist = (MinDist/Attenuation - MinDist)*MetersPerUnit;
   3.569 +    if(AirAbsorptionFactor > 0.0f && EffectiveDist > 0.0f)
   3.570 +    {
   3.571 +        DryGainHF *= aluPow(AIRABSORBGAINHF, AirAbsorptionFactor*EffectiveDist);
   3.572 +        for(i = 0;i < NumSends;i++)
   3.573 +            WetGainHF[i] *= aluPow(RoomAirAbsorption[i],
   3.574 +                                   AirAbsorptionFactor*EffectiveDist);
   3.575 +    }
   3.576 +
   3.577 +    //3. Apply directional soundcones
   3.578 +    Angle = aluAcos(aluDotproduct(Direction,SourceToListener)) * (180.0/M_PI);
   3.579 +    if(Angle >= InnerAngle && Angle <= OuterAngle)
   3.580 +    {
   3.581 +        ALfloat scale = (Angle-InnerAngle) / (OuterAngle-InnerAngle);
   3.582 +        ConeVolume = lerp(1.0, ALSource->flOuterGain, scale);
   3.583 +        ConeHF = lerp(1.0, ALSource->OuterGainHF, scale);
   3.584 +    }
   3.585 +    else if(Angle > OuterAngle)
   3.586 +    {
   3.587 +        ConeVolume = ALSource->flOuterGain;
   3.588 +        ConeHF = ALSource->OuterGainHF;
   3.589 +    }
   3.590 +    else
   3.591 +    {
   3.592 +        ConeVolume = 1.0f;
   3.593 +        ConeHF = 1.0f;
   3.594 +    }
   3.595 +
   3.596 +    DryGain *= ConeVolume;
   3.597 +    if(WetGainAuto)
   3.598 +    {
   3.599 +        for(i = 0;i < NumSends;i++)
   3.600 +            WetGain[i] *= ConeVolume;
   3.601 +    }
   3.602 +    if(DryGainHFAuto)
   3.603 +        DryGainHF *= ConeHF;
   3.604 +    if(WetGainHFAuto)
   3.605 +    {
   3.606 +        for(i = 0;i < NumSends;i++)
   3.607 +            WetGainHF[i] *= ConeHF;
   3.608 +    }
   3.609 +
   3.610 +    // Clamp to Min/Max Gain
   3.611 +    DryGain = clampf(DryGain, MinVolume, MaxVolume);
   3.612 +    for(i = 0;i < NumSends;i++)
   3.613 +        WetGain[i] = clampf(WetGain[i], MinVolume, MaxVolume);
   3.614 +
   3.615 +    // Apply filter gains and filters
   3.616 +    switch(ALSource->DirectFilter.type)
   3.617 +    {
   3.618 +        case AL_FILTER_LOWPASS:
   3.619 +            DryGain *= ALSource->DirectFilter.Gain;
   3.620 +            DryGainHF *= ALSource->DirectFilter.GainHF;
   3.621 +            break;
   3.622 +    }
   3.623 +    DryGain *= ListenerGain;
   3.624 +    for(i = 0;i < NumSends;i++)
   3.625 +    {
   3.626 +        switch(ALSource->Send[i].WetFilter.type)
   3.627 +        {
   3.628 +            case AL_FILTER_LOWPASS:
   3.629 +                WetGain[i] *= ALSource->Send[i].WetFilter.Gain;
   3.630 +                WetGainHF[i] *= ALSource->Send[i].WetFilter.GainHF;
   3.631 +                break;
   3.632 +        }
   3.633 +        WetGain[i] *= ListenerGain;
   3.634 +    }
   3.635 +
   3.636 +    if(WetGainAuto)
   3.637 +    {
   3.638 +        /* Apply a decay-time transformation to the wet path, based on the
   3.639 +         * attenuation of the dry path.
   3.640 +         *
   3.641 +         * Using the approximate (effective) source to listener distance, the
   3.642 +         * initial decay of the reverb effect is calculated and applied to the
   3.643 +         * wet path.
   3.644 +         */
   3.645 +        for(i = 0;i < NumSends;i++)
   3.646 +        {
   3.647 +            if(DecayDistance[i] > 0.0f)
   3.648 +                WetGain[i] *= aluPow(0.001f /* -60dB */,
   3.649 +                                     EffectiveDist / DecayDistance[i]);
   3.650 +        }
   3.651 +    }
   3.652 +
   3.653 +    // Calculate Velocity
   3.654 +    if(DopplerFactor != 0.0f)
   3.655 +    {
   3.656 +        ALfloat VSS, VLS;
   3.657 +        ALfloat MaxVelocity = (SpeedOfSound*DopplerVelocity) /
   3.658 +                              DopplerFactor;
   3.659 +
   3.660 +        VSS = aluDotproduct(Velocity, SourceToListener);
   3.661 +        if(VSS >= MaxVelocity)
   3.662 +            VSS = (MaxVelocity - 1.0f);
   3.663 +        else if(VSS <= -MaxVelocity)
   3.664 +            VSS = -MaxVelocity + 1.0f;
   3.665 +
   3.666 +        VLS = aluDotproduct(ListenerVel, SourceToListener);
   3.667 +        if(VLS >= MaxVelocity)
   3.668 +            VLS = (MaxVelocity - 1.0f);
   3.669 +        else if(VLS <= -MaxVelocity)
   3.670 +            VLS = -MaxVelocity + 1.0f;
   3.671 +
   3.672 +        Pitch *= ((SpeedOfSound*DopplerVelocity) - (DopplerFactor*VLS)) /
   3.673 +                 ((SpeedOfSound*DopplerVelocity) - (DopplerFactor*VSS));
   3.674 +    }
   3.675 +
   3.676 +    BufferListItem = ALSource->queue;
   3.677 +    while(BufferListItem != NULL)
   3.678 +    {
   3.679 +        ALbuffer *ALBuffer;
   3.680 +        if((ALBuffer=BufferListItem->buffer) != NULL)
   3.681 +        {
   3.682 +            ALint maxstep = STACK_DATA_SIZE / ALSource->NumChannels /
   3.683 +                                              ALSource->SampleSize;
   3.684 +            maxstep -= ResamplerPadding[Resampler] +
   3.685 +                       ResamplerPrePadding[Resampler] + 1;
   3.686 +            maxstep = mini(maxstep, INT_MAX>>FRACTIONBITS);
   3.687 +
   3.688 +            Pitch = Pitch * ALBuffer->Frequency / Frequency;
   3.689 +            if(Pitch > (ALfloat)maxstep)
   3.690 +                ALSource->Params.Step = maxstep<<FRACTIONBITS;
   3.691 +            else
   3.692 +            {
   3.693 +                ALSource->Params.Step = Pitch*FRACTIONONE;
   3.694 +                if(ALSource->Params.Step == 0)
   3.695 +                    ALSource->Params.Step = 1;
   3.696 +            }
   3.697 +
   3.698 +            if((Device->Flags&DEVICE_USE_HRTF))
   3.699 +                ALSource->Params.DoMix = SelectHrtfMixer(ALBuffer,
   3.700 +                       (ALSource->Params.Step==FRACTIONONE) ? POINT_RESAMPLER :
   3.701 +                                                              Resampler);
   3.702 +            else
   3.703 +                ALSource->Params.DoMix = SelectMixer(ALBuffer,
   3.704 +                       (ALSource->Params.Step==FRACTIONONE) ? POINT_RESAMPLER :
   3.705 +                                                              Resampler);
   3.706 +            break;
   3.707 +        }
   3.708 +        BufferListItem = BufferListItem->next;
   3.709 +    }
   3.710 +
   3.711 +    if((Device->Flags&DEVICE_USE_HRTF))
   3.712 +    {
   3.713 +        // Use a binaural HRTF algorithm for stereo headphone playback
   3.714 +        ALfloat delta, ev = 0.0f, az = 0.0f;
   3.715 +
   3.716 +        if(Distance > 0.0f)
   3.717 +        {
   3.718 +            ALfloat invlen = 1.0f/Distance;
   3.719 +            Position[0] *= invlen;
   3.720 +            Position[1] *= invlen;
   3.721 +            Position[2] *= invlen;
   3.722 +
   3.723 +            // Calculate elevation and azimuth only when the source is not at
   3.724 +            // the listener.  This prevents +0 and -0 Z from producing
   3.725 +            // inconsistent panning.
   3.726 +            ev = asin(Position[1]);
   3.727 +            az = atan2(Position[0], -Position[2]*ZScale);
   3.728 +        }
   3.729 +
   3.730 +        // Check to see if the HRIR is already moving.
   3.731 +        if(ALSource->HrtfMoving)
   3.732 +        {
   3.733 +            // Calculate the normalized HRTF transition factor (delta).
   3.734 +            delta = CalcHrtfDelta(ALSource->Params.HrtfGain, DryGain,
   3.735 +                                  ALSource->Params.HrtfDir, Position);
   3.736 +            // If the delta is large enough, get the moving HRIR target
   3.737 +            // coefficients, target delays, steppping values, and counter.
   3.738 +            if(delta > 0.001f)
   3.739 +            {
   3.740 +                ALSource->HrtfCounter = GetMovingHrtfCoeffs(ev, az, DryGain,
   3.741 +                                          delta, ALSource->HrtfCounter,
   3.742 +                                          ALSource->Params.HrtfCoeffs[0],
   3.743 +                                          ALSource->Params.HrtfDelay[0],
   3.744 +                                          ALSource->Params.HrtfCoeffStep,
   3.745 +                                          ALSource->Params.HrtfDelayStep);
   3.746 +                ALSource->Params.HrtfGain = DryGain;
   3.747 +                ALSource->Params.HrtfDir[0] = Position[0];
   3.748 +                ALSource->Params.HrtfDir[1] = Position[1];
   3.749 +                ALSource->Params.HrtfDir[2] = Position[2];
   3.750 +            }
   3.751 +        }
   3.752 +        else
   3.753 +        {
   3.754 +            // Get the initial (static) HRIR coefficients and delays.
   3.755 +            GetLerpedHrtfCoeffs(ev, az, DryGain,
   3.756 +                                ALSource->Params.HrtfCoeffs[0],
   3.757 +                                ALSource->Params.HrtfDelay[0]);
   3.758 +            ALSource->HrtfCounter = 0;
   3.759 +            ALSource->Params.HrtfGain = DryGain;
   3.760 +            ALSource->Params.HrtfDir[0] = Position[0];
   3.761 +            ALSource->Params.HrtfDir[1] = Position[1];
   3.762 +            ALSource->Params.HrtfDir[2] = Position[2];
   3.763 +        }
   3.764 +    }
   3.765 +    else
   3.766 +    {
   3.767 +        // Use energy-preserving panning algorithm for multi-speaker playback
   3.768 +        ALfloat DirGain, AmbientGain;
   3.769 +        const ALfloat *SpeakerGain;
   3.770 +        ALfloat length;
   3.771 +        ALint pos;
   3.772 +
   3.773 +        length = maxf(Distance, MinDist);
   3.774 +        if(length > 0.0f)
   3.775 +        {
   3.776 +            ALfloat invlen = 1.0f/length;
   3.777 +            Position[0] *= invlen;
   3.778 +            Position[1] *= invlen;
   3.779 +            Position[2] *= invlen;
   3.780 +        }
   3.781 +
   3.782 +        pos = aluCart2LUTpos(-Position[2]*ZScale, Position[0]);
   3.783 +        SpeakerGain = Device->PanningLUT[pos];
   3.784 +
   3.785 +        DirGain = aluSqrt(Position[0]*Position[0] + Position[2]*Position[2]);
   3.786 +        // elevation adjustment for directional gain. this sucks, but
   3.787 +        // has low complexity
   3.788 +        AmbientGain = aluSqrt(1.0/Device->NumChan);
   3.789 +        for(i = 0;i < MAXCHANNELS;i++)
   3.790 +        {
   3.791 +            ALuint i2;
   3.792 +            for(i2 = 0;i2 < MAXCHANNELS;i2++)
   3.793 +                ALSource->Params.DryGains[i][i2] = 0.0f;
   3.794 +        }
   3.795 +        for(i = 0;i < (ALint)Device->NumChan;i++)
   3.796 +        {
   3.797 +            enum Channel chan = Device->Speaker2Chan[i];
   3.798 +            ALfloat gain = lerp(AmbientGain, SpeakerGain[chan], DirGain);
   3.799 +            ALSource->Params.DryGains[0][chan] = DryGain * gain;
   3.800 +        }
   3.801 +    }
   3.802 +    for(i = 0;i < NumSends;i++)
   3.803 +        ALSource->Params.Send[i].WetGain = WetGain[i];
   3.804 +
   3.805 +    /* Update filter coefficients. */
   3.806 +    cw = cos(2.0*M_PI * LOWPASSFREQCUTOFF / Frequency);
   3.807 +
   3.808 +    ALSource->Params.iirFilter.coeff = lpCoeffCalc(DryGainHF, cw);
   3.809 +    for(i = 0;i < NumSends;i++)
   3.810 +    {
   3.811 +        ALfloat a = lpCoeffCalc(WetGainHF[i]*WetGainHF[i], cw);
   3.812 +        ALSource->Params.Send[i].iirFilter.coeff = a;
   3.813 +    }
   3.814 +}
   3.815 +
   3.816 +
   3.817 +static __inline ALfloat aluF2F(ALfloat val)
   3.818 +{ return val; }
   3.819 +static __inline ALshort aluF2S(ALfloat val)
   3.820 +{
   3.821 +    if(val > 1.0f) return 32767;
   3.822 +    if(val < -1.0f) return -32768;
   3.823 +    return (ALint)(val*32767.0f);
   3.824 +}
   3.825 +static __inline ALushort aluF2US(ALfloat val)
   3.826 +{ return aluF2S(val)+32768; }
   3.827 +static __inline ALbyte aluF2B(ALfloat val)
   3.828 +{ return aluF2S(val)>>8; }
   3.829 +static __inline ALubyte aluF2UB(ALfloat val)
   3.830 +{ return aluF2US(val)>>8; }
   3.831 +
   3.832 +#define DECL_TEMPLATE(T, N, func)                                             \
   3.833 +static void Write_##T##_##N(ALCdevice *device, T *RESTRICT buffer,            \
   3.834 +                            ALuint SamplesToDo)                               \
   3.835 +{                                                                             \
   3.836 +    ALfloat (*RESTRICT DryBuffer)[MAXCHANNELS] = device->DryBuffer;           \
   3.837 +    const enum Channel *ChanMap = device->DevChannels;                        \
   3.838 +    ALuint i, j;                                                              \
   3.839 +                                                                              \
   3.840 +    for(i = 0;i < SamplesToDo;i++)                                            \
   3.841 +    {                                                                         \
   3.842 +        for(j = 0;j < N;j++)                                                  \
   3.843 +            *(buffer++) = func(DryBuffer[i][ChanMap[j]]);                     \
   3.844 +    }                                                                         \
   3.845 +}
   3.846 +
   3.847 +DECL_TEMPLATE(ALfloat, 1, aluF2F)
   3.848 +DECL_TEMPLATE(ALfloat, 4, aluF2F)
   3.849 +DECL_TEMPLATE(ALfloat, 6, aluF2F)
   3.850 +DECL_TEMPLATE(ALfloat, 7, aluF2F)
   3.851 +DECL_TEMPLATE(ALfloat, 8, aluF2F)
   3.852 +
   3.853 +DECL_TEMPLATE(ALushort, 1, aluF2US)
   3.854 +DECL_TEMPLATE(ALushort, 4, aluF2US)
   3.855 +DECL_TEMPLATE(ALushort, 6, aluF2US)
   3.856 +DECL_TEMPLATE(ALushort, 7, aluF2US)
   3.857 +DECL_TEMPLATE(ALushort, 8, aluF2US)
   3.858 +
   3.859 +DECL_TEMPLATE(ALshort, 1, aluF2S)
   3.860 +DECL_TEMPLATE(ALshort, 4, aluF2S)
   3.861 +DECL_TEMPLATE(ALshort, 6, aluF2S)
   3.862 +DECL_TEMPLATE(ALshort, 7, aluF2S)
   3.863 +DECL_TEMPLATE(ALshort, 8, aluF2S)
   3.864 +
   3.865 +DECL_TEMPLATE(ALubyte, 1, aluF2UB)
   3.866 +DECL_TEMPLATE(ALubyte, 4, aluF2UB)
   3.867 +DECL_TEMPLATE(ALubyte, 6, aluF2UB)
   3.868 +DECL_TEMPLATE(ALubyte, 7, aluF2UB)
   3.869 +DECL_TEMPLATE(ALubyte, 8, aluF2UB)
   3.870 +
   3.871 +DECL_TEMPLATE(ALbyte, 1, aluF2B)
   3.872 +DECL_TEMPLATE(ALbyte, 4, aluF2B)
   3.873 +DECL_TEMPLATE(ALbyte, 6, aluF2B)
   3.874 +DECL_TEMPLATE(ALbyte, 7, aluF2B)
   3.875 +DECL_TEMPLATE(ALbyte, 8, aluF2B)
   3.876 +
   3.877 +#undef DECL_TEMPLATE
   3.878 +
   3.879 +#define DECL_TEMPLATE(T, N, func)                                             \
   3.880 +static void Write_##T##_##N(ALCdevice *device, T *RESTRICT buffer,            \
   3.881 +                            ALuint SamplesToDo)                               \
   3.882 +{                                                                             \
   3.883 +    ALfloat (*RESTRICT DryBuffer)[MAXCHANNELS] = device->DryBuffer;           \
   3.884 +    const enum Channel *ChanMap = device->DevChannels;                        \
   3.885 +    ALuint i, j;                                                              \
   3.886 +                                                                              \
   3.887 +    if(device->Bs2b)                                                          \
   3.888 +    {                                                                         \
   3.889 +        for(i = 0;i < SamplesToDo;i++)                                        \
   3.890 +        {                                                                     \
   3.891 +            float samples[2];                                                 \
   3.892 +            samples[0] = DryBuffer[i][ChanMap[0]];                            \
   3.893 +            samples[1] = DryBuffer[i][ChanMap[1]];                            \
   3.894 +            bs2b_cross_feed(device->Bs2b, samples);                           \
   3.895 +            *(buffer++) = func(samples[0]);                                   \
   3.896 +            *(buffer++) = func(samples[1]);                                   \
   3.897 +        }                                                                     \
   3.898 +    }                                                                         \
   3.899 +    else                                                                      \
   3.900 +    {                                                                         \
   3.901 +        for(i = 0;i < SamplesToDo;i++)                                        \
   3.902 +        {                                                                     \
   3.903 +            for(j = 0;j < N;j++)                                              \
   3.904 +                *(buffer++) = func(DryBuffer[i][ChanMap[j]]);                 \
   3.905 +        }                                                                     \
   3.906 +    }                                                                         \
   3.907 +}
   3.908 +
   3.909 +DECL_TEMPLATE(ALfloat, 2, aluF2F)
   3.910 +DECL_TEMPLATE(ALushort, 2, aluF2US)
   3.911 +DECL_TEMPLATE(ALshort, 2, aluF2S)
   3.912 +DECL_TEMPLATE(ALubyte, 2, aluF2UB)
   3.913 +DECL_TEMPLATE(ALbyte, 2, aluF2B)
   3.914 +
   3.915 +#undef DECL_TEMPLATE
   3.916 +
   3.917 +#define DECL_TEMPLATE(T)                                                      \
   3.918 +static void Write_##T(ALCdevice *device, T *buffer, ALuint SamplesToDo)       \
   3.919 +{                                                                             \
   3.920 +    switch(device->FmtChans)                                                  \
   3.921 +    {                                                                         \
   3.922 +        case DevFmtMono:                                                      \
   3.923 +            Write_##T##_1(device, buffer, SamplesToDo);                       \
   3.924 +            break;                                                            \
   3.925 +        case DevFmtStereo:                                                    \
   3.926 +            Write_##T##_2(device, buffer, SamplesToDo);                       \
   3.927 +            break;                                                            \
   3.928 +        case DevFmtQuad:                                                      \
   3.929 +            Write_##T##_4(device, buffer, SamplesToDo);                       \
   3.930 +            break;                                                            \
   3.931 +        case DevFmtX51:                                                       \
   3.932 +        case DevFmtX51Side:                                                   \
   3.933 +            Write_##T##_6(device, buffer, SamplesToDo);                       \
   3.934 +            break;                                                            \
   3.935 +        case DevFmtX61:                                                       \
   3.936 +            Write_##T##_7(device, buffer, SamplesToDo);                       \
   3.937 +            break;                                                            \
   3.938 +        case DevFmtX71:                                                       \
   3.939 +            Write_##T##_8(device, buffer, SamplesToDo);                       \
   3.940 +            break;                                                            \
   3.941 +    }                                                                         \
   3.942 +}
   3.943 +
   3.944 +DECL_TEMPLATE(ALfloat)
   3.945 +DECL_TEMPLATE(ALushort)
   3.946 +DECL_TEMPLATE(ALshort)
   3.947 +DECL_TEMPLATE(ALubyte)
   3.948 +DECL_TEMPLATE(ALbyte)
   3.949 +
   3.950 +#undef DECL_TEMPLATE
   3.951 +
   3.952 +ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size)
   3.953 +{
   3.954 +    ALuint SamplesToDo;
   3.955 +    ALeffectslot *ALEffectSlot;
   3.956 +    ALCcontext **ctx, **ctx_end;
   3.957 +    ALsource **src, **src_end;
   3.958 +    int fpuState;
   3.959 +    ALuint i, c;
   3.960 +    ALsizei e;
   3.961 +
   3.962 +#if defined(HAVE_FESETROUND)
   3.963 +    fpuState = fegetround();
   3.964 +    fesetround(FE_TOWARDZERO);
   3.965 +#elif defined(HAVE__CONTROLFP)
   3.966 +    fpuState = _controlfp(0, 0);
   3.967 +    (void)_controlfp(_RC_CHOP, _MCW_RC);
   3.968 +#else
   3.969 +    (void)fpuState;
   3.970 +#endif
   3.971 +
   3.972 +    while(size > 0)
   3.973 +    {
   3.974 +        /* Setup variables */
   3.975 +        SamplesToDo = minu(size, BUFFERSIZE);
   3.976 +
   3.977 +        /* Clear mixing buffer */
   3.978 +        memset(device->DryBuffer, 0, SamplesToDo*MAXCHANNELS*sizeof(ALfloat));
   3.979 +
   3.980 +        LockDevice(device);
   3.981 +        ctx = device->Contexts;
   3.982 +        ctx_end = ctx + device->NumContexts;
   3.983 +	//printf("Contexts: %d\n", device->NumContexts);
   3.984 +	int context_number = 0;
   3.985 +        while(ctx != ctx_end)
   3.986 +	  {
   3.987 +	    //printf("Context %d:\n", context_number++);
   3.988 +            ALboolean DeferUpdates = (*ctx)->DeferUpdates;
   3.989 +            ALboolean UpdateSources = AL_FALSE;
   3.990 +
   3.991 +            if(!DeferUpdates)
   3.992 +            {
   3.993 +	      //printf("NOT deferring updates, whatever that means\n");
   3.994 +                UpdateSources = (*ctx)->UpdateSources;
   3.995 +		//printf("update sources is set to %d\n", UpdateSources);
   3.996 +                (*ctx)->UpdateSources = AL_FALSE;
   3.997 +            }
   3.998 +
   3.999 +            src = (*ctx)->ActiveSources;
  3.1000 +            src_end = src + (*ctx)->ActiveSourceCount;
  3.1001 +	    //printf("number of active sources are %d\n", (*ctx)->ActiveSourceCount);
  3.1002 +            while(src != src_end)
  3.1003 +            {
  3.1004 + 	        
  3.1005 +                if((*src)->state != AL_PLAYING)
  3.1006 +                {
  3.1007 +                    --((*ctx)->ActiveSourceCount);
  3.1008 +                    *src = *(--src_end);
  3.1009 +                    continue;
  3.1010 +                }
  3.1011 +
  3.1012 +                if(!DeferUpdates && ((*src)->NeedsUpdate || UpdateSources))
  3.1013 +                {
  3.1014 +                    (*src)->NeedsUpdate = AL_FALSE;
  3.1015 +                    ALsource_Update(*src, *ctx);
  3.1016 +                }
  3.1017 +		//printf("calling MixSource!\n");
  3.1018 +                MixSource(*src, device, SamplesToDo);
  3.1019 +                src++;
  3.1020 +            }
  3.1021 +
  3.1022 +            /* effect slot processing */
  3.1023 +            for(e = 0;e < (*ctx)->EffectSlotMap.size;e++)
  3.1024 +            {
  3.1025 +                ALEffectSlot = (*ctx)->EffectSlotMap.array[e].value;
  3.1026 +
  3.1027 +                for(i = 0;i < SamplesToDo;i++)
  3.1028 +                {
  3.1029 +		  // RLM: remove click-removal
  3.1030 +		  ALEffectSlot->WetBuffer[i] += ALEffectSlot->ClickRemoval[0];
  3.1031 +		  ALEffectSlot->ClickRemoval[0] -= ALEffectSlot->ClickRemoval[0] / 256.0f;
  3.1032 +                }
  3.1033 +                for(i = 0;i < 1;i++)
  3.1034 +                {
  3.1035 +		  // RLM: remove click-removal
  3.1036 +		  ALEffectSlot->ClickRemoval[i] += ALEffectSlot->PendingClicks[i];
  3.1037 +		  ALEffectSlot->PendingClicks[i] = 0.0f;
  3.1038 +                }
  3.1039 +
  3.1040 +                if(!DeferUpdates && ALEffectSlot->NeedsUpdate)
  3.1041 +                {
  3.1042 +                    ALEffectSlot->NeedsUpdate = AL_FALSE;
  3.1043 +                    ALEffect_Update(ALEffectSlot->EffectState, *ctx, ALEffectSlot);
  3.1044 +                }
  3.1045 +
  3.1046 +                ALEffect_Process(ALEffectSlot->EffectState, ALEffectSlot,
  3.1047 +                                 SamplesToDo, ALEffectSlot->WetBuffer,
  3.1048 +                                 device->DryBuffer);
  3.1049 +
  3.1050 +                for(i = 0;i < SamplesToDo;i++)
  3.1051 +                    ALEffectSlot->WetBuffer[i] = 0.0f;
  3.1052 +            }
  3.1053 +
  3.1054 +            ctx++;
  3.1055 +        }
  3.1056 +        UnlockDevice(device);
  3.1057 +
  3.1058 +        //Post processing loop
  3.1059 +        if(device->FmtChans == DevFmtMono)
  3.1060 +        {
  3.1061 +            for(i = 0;i < SamplesToDo;i++)
  3.1062 +            {
  3.1063 +	      // RLM: remove click-removal
  3.1064 +	      device->DryBuffer[i][FRONT_CENTER] += device->ClickRemoval[FRONT_CENTER];
  3.1065 +	      device->ClickRemoval[FRONT_CENTER] -= device->ClickRemoval[FRONT_CENTER] / 256.0f;
  3.1066 +            }
  3.1067 +	    // RLM: remove click-removal
  3.1068 +            device->ClickRemoval[FRONT_CENTER] += device->PendingClicks[FRONT_CENTER];
  3.1069 +            device->PendingClicks[FRONT_CENTER] = 0.0f;
  3.1070 +        }
  3.1071 +        else if(device->FmtChans == DevFmtStereo)
  3.1072 +        {
  3.1073 +            /* Assumes the first two channels are FRONT_LEFT and FRONT_RIGHT */
  3.1074 +            for(i = 0;i < SamplesToDo;i++)
  3.1075 +            {
  3.1076 +                for(c = 0;c < 2;c++)
  3.1077 +                {
  3.1078 +		  // RLM: remove click-removal
  3.1079 +		  device->DryBuffer[i][c] += device->ClickRemoval[c];
  3.1080 +		  device->ClickRemoval[c] -= device->ClickRemoval[c] / 256.0f;
  3.1081 +                }
  3.1082 +            }
  3.1083 +            for(c = 0;c < 2;c++)
  3.1084 +	      {
  3.1085 +		// RLM: remove click-removal
  3.1086 +		device->ClickRemoval[c] += device->PendingClicks[c];
  3.1087 +		device->PendingClicks[c] = 0.0f;
  3.1088 +	      }
  3.1089 +        }
  3.1090 +        else
  3.1091 +	  {
  3.1092 +            for(i = 0;i < SamplesToDo;i++)
  3.1093 +	      {
  3.1094 +                for(c = 0;c < MAXCHANNELS;c++)
  3.1095 +		  {
  3.1096 +		    // RLM: remove click-removal
  3.1097 +		    device->DryBuffer[i][c] += device->ClickRemoval[c];
  3.1098 +		    device->ClickRemoval[c] -= device->ClickRemoval[c] / 256.0f;
  3.1099 +                }
  3.1100 +            }
  3.1101 +            for(c = 0;c < MAXCHANNELS;c++)
  3.1102 +            {
  3.1103 +	      // RLM: remove click-removal
  3.1104 +	      device->ClickRemoval[c] += device->PendingClicks[c];
  3.1105 +	      device->PendingClicks[c] = 0.0f;
  3.1106 +            }
  3.1107 +        }
  3.1108 +
  3.1109 +        if(buffer)
  3.1110 +        {
  3.1111 +            switch(device->FmtType)
  3.1112 +            {
  3.1113 +                case DevFmtByte:
  3.1114 +                    Write_ALbyte(device, buffer, SamplesToDo);
  3.1115 +                    break;
  3.1116 +                case DevFmtUByte:
  3.1117 +                    Write_ALubyte(device, buffer, SamplesToDo);
  3.1118 +                    break;
  3.1119 +                case DevFmtShort:
  3.1120 +                    Write_ALshort(device, buffer, SamplesToDo);
  3.1121 +                    break;
  3.1122 +                case DevFmtUShort:
  3.1123 +                    Write_ALushort(device, buffer, SamplesToDo);
  3.1124 +                    break;
  3.1125 +                case DevFmtFloat:
  3.1126 +                    Write_ALfloat(device, buffer, SamplesToDo);
  3.1127 +                    break;
  3.1128 +            }
  3.1129 +        }
  3.1130 +
  3.1131 +        size -= SamplesToDo;
  3.1132 +    }
  3.1133 +
  3.1134 +#if defined(HAVE_FESETROUND)
  3.1135 +    fesetround(fpuState);
  3.1136 +#elif defined(HAVE__CONTROLFP)
  3.1137 +    _controlfp(fpuState, _MCW_RC);
  3.1138 +#endif
  3.1139 +}
  3.1140 +
  3.1141 +
  3.1142 +
  3.1143 +
  3.1144 +
  3.1145 +ALvoid aluHandleDisconnect(ALCdevice *device)
  3.1146 +{
  3.1147 +    ALuint i;
  3.1148 +
  3.1149 +    LockDevice(device);
  3.1150 +    for(i = 0;i < device->NumContexts;i++)
  3.1151 +    {
  3.1152 +        ALCcontext *Context = device->Contexts[i];
  3.1153 +        ALsource *source;
  3.1154 +        ALsizei pos;
  3.1155 +
  3.1156 +        for(pos = 0;pos < Context->SourceMap.size;pos++)
  3.1157 +        {
  3.1158 +            source = Context->SourceMap.array[pos].value;
  3.1159 +            if(source->state == AL_PLAYING)
  3.1160 +            {
  3.1161 +                source->state = AL_STOPPED;
  3.1162 +                source->BuffersPlayed = source->BuffersInQueue;
  3.1163 +                source->position = 0;
  3.1164 +                source->position_fraction = 0;
  3.1165 +            }
  3.1166 +        }
  3.1167 +    }
  3.1168 +
  3.1169 +    device->Connected = ALC_FALSE;
  3.1170 +    UnlockDevice(device);
  3.1171 +}