Added OpenAL-Soft lib from git://repo.or.cz/openal-soft/android.git

project/jni/openal/src/Alc/alcConfig.c

@@ -0,0 +1,338 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#ifdef _WIN32
+#ifdef __MINGW64__
+#define _WIN32_IE 0x501
+#else
+#define _WIN32_IE 0x400
+#endif
+#endif
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+
+#include "alMain.h"
+
+#ifdef _WIN32_IE
+#include <shlobj.h>
+#endif
+
+typedef struct ConfigEntry {
+    char *key;
+    char *value;
+} ConfigEntry;
+
+typedef struct ConfigBlock {
+    char *name;
+    ConfigEntry *entries;
+    size_t entryCount;
+} ConfigBlock;
+
+static ConfigBlock *cfgBlocks;
+static size_t cfgCount;
+
+static char buffer[1024];
+
+static void LoadConfigFromFile(FILE *f)
+{
+    ConfigBlock *curBlock = cfgBlocks;
+    ConfigEntry *ent;
+
+    while(fgets(buffer, sizeof(buffer), f))
+    {
+        size_t i = 0;
+
+        while(isspace(buffer[i]))
+            i++;
+        if(!buffer[i] || buffer[i] == '#')
+            continue;
+
+        memmove(buffer, buffer+i, strlen(buffer+i)+1);
+
+        if(buffer[0] == '[')
+        {
+            ConfigBlock *nextBlock;
+
+            i = 1;
+            while(buffer[i] && buffer[i] != ']')
+                i++;
+
+            if(!buffer[i])
+            {
+                 AL_PRINT("config parse error: bad line \"%s\"\n", buffer);
+                 continue;
+            }
+            buffer[i] = 0;
+
+            do {
+                i++;
+                if(buffer[i] && !isspace(buffer[i]))
+                {
+                    if(buffer[i] != '#')
+                        AL_PRINT("config warning: extra data after block: \"%s\"\n", buffer+i);
+                    break;
+                }
+            } while(buffer[i]);
+
+            nextBlock = NULL;
+            for(i = 0;i < cfgCount;i++)
+            {
+                if(strcasecmp(cfgBlocks[i].name, buffer+1) == 0)
+                {
+                    nextBlock = cfgBlocks+i;
+//                    AL_PRINT("found block '%s'\n", nextBlock->name);
+                    break;
+                }
+            }
+
+            if(!nextBlock)
+            {
+                nextBlock = realloc(cfgBlocks, (cfgCount+1)*sizeof(ConfigBlock));
+                if(!nextBlock)
+                {
+                     AL_PRINT("config parse error: error reallocating config blocks\n");
+                     continue;
+                }
+                cfgBlocks = nextBlock;
+                nextBlock = cfgBlocks+cfgCount;
+                cfgCount++;
+
+                nextBlock->name = strdup(buffer+1);
+                nextBlock->entries = NULL;
+                nextBlock->entryCount = 0;
+
+//                AL_PRINT("found new block '%s'\n", nextBlock->name);
+            }
+            curBlock = nextBlock;
+            continue;
+        }
+
+        /* Look for the option name */
+        i = 0;
+        while(buffer[i] && buffer[i] != '#' && buffer[i] != '=' &&
+              !isspace(buffer[i]))
+            i++;
+
+        if(!buffer[i] || buffer[i] == '#' || i == 0)
+        {
+            AL_PRINT("config parse error: malformed option line: \"%s\"\n", buffer);
+            continue;
+        }
+
+        /* Seperate the option */
+        if(buffer[i] != '=')
+        {
+            buffer[i++] = 0;
+
+            while(isspace(buffer[i]))
+                i++;
+            if(buffer[i] != '=')
+            {
+                AL_PRINT("config parse error: option without a value: \"%s\"\n", buffer);
+                continue;
+            }
+        }
+        /* Find the start of the value */
+        buffer[i++] = 0;
+        while(isspace(buffer[i]))
+            i++;
+
+        /* Check if we already have this option set */
+        ent = curBlock->entries;
+        while((size_t)(ent-curBlock->entries) < curBlock->entryCount)
+        {
+            if(strcasecmp(ent->key, buffer) == 0)
+                break;
+            ent++;
+        }
+
+        if((size_t)(ent-curBlock->entries) >= curBlock->entryCount)
+        {
+            /* Allocate a new option entry */
+            ent = realloc(curBlock->entries, (curBlock->entryCount+1)*sizeof(ConfigEntry));
+            if(!ent)
+            {
+                 AL_PRINT("config parse error: error reallocating config entries\n");
+                 continue;
+            }
+            curBlock->entries = ent;
+            ent = curBlock->entries + curBlock->entryCount;
+            curBlock->entryCount++;
+
+            ent->key = strdup(buffer);
+            ent->value = NULL;
+        }
+
+        /* Look for the end of the line (Null term, new-line, or #-symbol) and
+           eat up the trailing whitespace */
+        memmove(buffer, buffer+i, strlen(buffer+i)+1);
+
+        i = 0;
+        while(buffer[i] && buffer[i] != '#' && buffer[i] != '\n')
+            i++;
+        do {
+            i--;
+        } while(isspace(buffer[i]));
+        buffer[++i] = 0;
+
+        free(ent->value);
+        ent->value = strdup(buffer);
+
+//        AL_PRINT("found '%s' = '%s'\n", ent->key, ent->value);
+    }
+}
+
+void ReadALConfig(void)
+{
+    FILE *f;
+
+    cfgBlocks = calloc(1, sizeof(ConfigBlock));
+    cfgBlocks->name = strdup("general");
+    cfgCount = 1;
+
+#ifdef _WIN32
+    if(SHGetSpecialFolderPathA(NULL, buffer, CSIDL_APPDATA, FALSE) != FALSE)
+    {
+        size_t p = strlen(buffer);
+        snprintf(buffer+p, sizeof(buffer)-p, "\\alsoft.ini");
+        f = fopen(buffer, "rt");
+        if(f)
+        {
+            LoadConfigFromFile(f);
+            fclose(f);
+        }
+    }
+#else
+    f = fopen("/etc/openal/alsoft.conf", "r");
+    if(f)
+    {
+        LoadConfigFromFile(f);
+        fclose(f);
+    }
+    if(getenv("HOME") && *(getenv("HOME")))
+    {
+        snprintf(buffer, sizeof(buffer), "%s/.alsoftrc", getenv("HOME"));
+        f = fopen(buffer, "r");
+        if(f)
+        {
+            LoadConfigFromFile(f);
+            fclose(f);
+        }
+    }
+#endif
+    if(getenv("ALSOFT_CONF"))
+    {
+        f = fopen(getenv("ALSOFT_CONF"), "r");
+        if(f)
+        {
+            LoadConfigFromFile(f);
+            fclose(f);
+        }
+    }
+}
+
+void FreeALConfig(void)
+{
+    size_t i;
+
+    for(i = 0;i < cfgCount;i++)
+    {
+        size_t j;
+        for(j = 0;j < cfgBlocks[i].entryCount;j++)
+        {
+           free(cfgBlocks[i].entries[j].key);
+           free(cfgBlocks[i].entries[j].value);
+        }
+        free(cfgBlocks[i].entries);
+        free(cfgBlocks[i].name);
+    }
+    free(cfgBlocks);
+    cfgBlocks = NULL;
+    cfgCount = 0;
+}
+
+const char *GetConfigValue(const char *blockName, const char *keyName, const char *def)
+{
+    size_t i, j;
+
+    if(!keyName)
+        return def;
+
+    if(!blockName)
+        blockName = "general";
+
+    for(i = 0;i < cfgCount;i++)
+    {
+        if(strcasecmp(cfgBlocks[i].name, blockName) != 0)
+            continue;
+
+        for(j = 0;j < cfgBlocks[i].entryCount;j++)
+        {
+            if(strcasecmp(cfgBlocks[i].entries[j].key, keyName) == 0)
+            {
+                if(cfgBlocks[i].entries[j].value[0])
+                    return cfgBlocks[i].entries[j].value;
+                return def;
+            }
+        }
+    }
+
+    return def;
+}
+
+int ConfigValueExists(const char *blockName, const char *keyName)
+{
+    const char *val = GetConfigValue(blockName, keyName, "");
+    return !!val[0];
+}
+
+int GetConfigValueInt(const char *blockName, const char *keyName, int def)
+{
+    const char *val = GetConfigValue(blockName, keyName, "");
+
+    if(!val[0]) return def;
+    return strtol(val, NULL, 0);
+}
+
+float GetConfigValueFloat(const char *blockName, const char *keyName, float def)
+{
+    const char *val = GetConfigValue(blockName, keyName, "");
+
+    if(!val[0]) return def;
+#ifdef HAVE_STRTOF
+    return strtof(val, NULL);
+#else
+    return (float)strtod(val, NULL);
+#endif
+}
+
+int GetConfigValueBool(const char *blockName, const char *keyName, int def)
+{
+    const char *val = GetConfigValue(blockName, keyName, "");
+
+    if(!val[0]) return !!def;
+    return (strcasecmp(val, "true") == 0 || strcasecmp(val, "yes") == 0 ||
+            strcasecmp(val, "on") == 0 || atoi(val) != 0);
+}

project/jni/openal/src/Alc/alcEcho.c

@@ -0,0 +1,193 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2009 by Chris Robinson.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <math.h>
+#include <stdlib.h>
+
+#include "alMain.h"
+#include "alFilter.h"
+#include "alAuxEffectSlot.h"
+#include "alError.h"
+#include "alu.h"
+
+
+typedef struct ALechoState {
+    // Must be first in all effects!
+    ALeffectState state;
+
+    ALfloat *SampleBuffer;
+    ALuint BufferLength;
+
+    // The echo is two tap. The delay is the number of samples from before the
+    // current offset
+    struct {
+        ALuint delay;
+    } Tap[2];
+    ALuint Offset;
+    // The LR gains for the first tap. The second tap uses the reverse
+    ALfloat GainL;
+    ALfloat GainR;
+
+    ALfloat FeedGain;
+
+    ALfloat Scale;
+
+    FILTER iirFilter;
+    ALfloat history[2];
+} ALechoState;
+
+static ALvoid EchoDestroy(ALeffectState *effect)
+{
+    ALechoState *state = (ALechoState*)effect;
+    if(state)
+    {
+        free(state->SampleBuffer);
+        state->SampleBuffer = NULL;
+        free(state);
+    }
+}
+
+static ALboolean EchoDeviceUpdate(ALeffectState *effect, ALCdevice *Device)
+{
+    ALechoState *state = (ALechoState*)effect;
+    ALuint maxlen, i;
+
+    // Use the next power of 2 for the buffer length, so the tap offsets can be
+    // wrapped using a mask instead of a modulo
+    maxlen  = (ALuint)(AL_ECHO_MAX_DELAY * Device->Frequency) + 1;
+    maxlen += (ALuint)(AL_ECHO_MAX_LRDELAY * Device->Frequency) + 1;
+    maxlen  = NextPowerOf2(maxlen);
+
+    if(maxlen != state->BufferLength)
+    {
+        void *temp;
+
+        temp = realloc(state->SampleBuffer, maxlen * sizeof(ALfloat));
+        if(!temp)
+            return AL_FALSE;
+        state->SampleBuffer = temp;
+        state->BufferLength = maxlen;
+    }
+    for(i = 0;i < state->BufferLength;i++)
+        state->SampleBuffer[i] = 0.0f;
+
+    state->Scale = aluSqrt(Device->NumChan / 6.0f);
+    state->Scale = __min(state->Scale, 1.0f);
+
+    return AL_TRUE;
+}
+
+static ALvoid EchoUpdate(ALeffectState *effect, ALCcontext *Context, const ALeffect *Effect)
+{
+    ALechoState *state = (ALechoState*)effect;
+    ALuint frequency = Context->Device->Frequency;
+    ALfloat lrpan, cw, a, g;
+
+    state->Tap[0].delay = (ALuint)(Effect->Echo.Delay * frequency) + 1;
+    state->Tap[1].delay = (ALuint)(Effect->Echo.LRDelay * frequency);
+    state->Tap[1].delay += state->Tap[0].delay;
+
+    lrpan = Effect->Echo.Spread*0.5f + 0.5f;
+    state->GainL = aluSqrt(     lrpan);
+    state->GainR = aluSqrt(1.0f-lrpan);
+
+    state->FeedGain = Effect->Echo.Feedback;
+
+    cw = cos(2.0*M_PI * LOWPASSFREQCUTOFF / frequency);
+    g = 1.0f - Effect->Echo.Damping;
+    a = 0.0f;
+    if(g < 0.9999f) // 1-epsilon
+        a = (1 - g*cw - aluSqrt(2*g*(1-cw) - g*g*(1 - cw*cw))) / (1 - g);
+    state->iirFilter.coeff = a;
+}
+
+static ALvoid EchoProcess(ALeffectState *effect, const ALeffectslot *Slot, ALuint SamplesToDo, const ALfloat *SamplesIn, ALfloat (*SamplesOut)[OUTPUTCHANNELS])
+{
+    ALechoState *state = (ALechoState*)effect;
+    const ALuint mask = state->BufferLength-1;
+    const ALuint tap1 = state->Tap[0].delay;
+    const ALuint tap2 = state->Tap[1].delay;
+    ALuint offset = state->Offset;
+    const ALfloat gain = Slot->Gain * state->Scale;
+    ALfloat samp[2], smp;
+    ALuint i;
+
+    for(i = 0;i < SamplesToDo;i++,offset++)
+    {
+        // Sample first tap
+        smp = state->SampleBuffer[(offset-tap1) & mask];
+        samp[0] = smp * state->GainL;
+        samp[1] = smp * state->GainR;
+        // Sample second tap. Reverse LR panning
+        smp = state->SampleBuffer[(offset-tap2) & mask];
+        samp[0] += smp * state->GainR;
+        samp[1] += smp * state->GainL;
+
+        // Apply damping and feedback gain to the second tap, and mix in the
+        // new sample
+        smp = lpFilter2P(&state->iirFilter, 0, smp+SamplesIn[i]);
+        state->SampleBuffer[offset&mask] = smp * state->FeedGain;
+
+        // Apply slot gain
+        samp[0] *= gain;
+        samp[1] *= gain;
+
+        SamplesOut[i][FRONT_LEFT]  += samp[0];
+        SamplesOut[i][FRONT_RIGHT] += samp[1];
+        SamplesOut[i][SIDE_LEFT]   += samp[0];
+        SamplesOut[i][SIDE_RIGHT]  += samp[1];
+        SamplesOut[i][BACK_LEFT]   += samp[0];
+        SamplesOut[i][BACK_RIGHT]  += samp[1];
+    }
+    state->Offset = offset;
+}
+
+ALeffectState *EchoCreate(void)
+{
+    ALechoState *state;
+
+    state = malloc(sizeof(*state));
+    if(!state)
+        return NULL;
+
+    state->state.Destroy = EchoDestroy;
+    state->state.DeviceUpdate = EchoDeviceUpdate;
+    state->state.Update = EchoUpdate;
+    state->state.Process = EchoProcess;
+
+    state->BufferLength = 0;
+    state->SampleBuffer = NULL;
+
+    state->Tap[0].delay = 0;
+    state->Tap[1].delay = 0;
+    state->Offset = 0;
+    state->GainL = 0.0f;
+    state->GainR = 0.0f;
+
+    state->Scale = 1.0f;
+
+    state->iirFilter.coeff = 0.0f;
+    state->iirFilter.history[0] = 0.0f;
+    state->iirFilter.history[1] = 0.0f;
+
+    return &state->state;
+}

project/jni/openal/src/Alc/alcModulator.c

@@ -0,0 +1,200 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2009 by Chris Robinson.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <math.h>
+#include <stdlib.h>
+
+#include "alMain.h"
+#include "alFilter.h"
+#include "alAuxEffectSlot.h"
+#include "alError.h"
+#include "alu.h"
+
+
+typedef struct ALmodulatorState {
+    // Must be first in all effects!
+    ALeffectState state;
+
+    enum {
+        SINUSOID,
+        SAWTOOTH,
+        SQUARE
+    } Waveform;
+
+    ALuint index;
+    ALuint step;
+
+    ALfloat Scale;
+
+    FILTER iirFilter;
+    ALfloat history[1];
+} ALmodulatorState;
+
+#define WAVEFORM_FRACBITS  16
+#define WAVEFORM_FRACMASK  ((1<<WAVEFORM_FRACBITS)-1)
+
+static __inline ALfloat sin_func(ALuint index)
+{
+    return sin(index / (double)(1<<WAVEFORM_FRACBITS) * M_PI * 2.0f);
+}
+
+static __inline ALfloat saw_func(ALuint index)
+{
+    return index*2.0f/(1<<WAVEFORM_FRACBITS) - 1.0f;
+}
+
+static __inline ALfloat square_func(ALuint index)
+{
+    return ((index>>(WAVEFORM_FRACBITS-1))&1) ? -1.0f : 1.0f;
+}
+
+
+static __inline ALfloat hpFilter1P(FILTER *iir, ALuint offset, ALfloat input)
+{
+    ALfloat *history = &iir->history[offset];
+    ALfloat a = iir->coeff;
+    ALfloat output = input;
+
+    output = output + (history[0]-output)*a;
+    history[0] = output;
+
+    return input - output;
+}
+
+
+static ALvoid ModulatorDestroy(ALeffectState *effect)
+{
+    ALmodulatorState *state = (ALmodulatorState*)effect;
+    free(state);
+}
+
+static ALboolean ModulatorDeviceUpdate(ALeffectState *effect, ALCdevice *Device)
+{
+    ALmodulatorState *state = (ALmodulatorState*)effect;
+
+    state->Scale = aluSqrt(Device->NumChan / 8.0f);
+
+    return AL_TRUE;
+}
+
+static ALvoid ModulatorUpdate(ALeffectState *effect, ALCcontext *Context, const ALeffect *Effect)
+{
+    ALmodulatorState *state = (ALmodulatorState*)effect;
+    ALfloat cw, a = 0.0f;
+
+    if(Effect->Modulator.Waveform == AL_RING_MODULATOR_SINUSOID)
+        state->Waveform = SINUSOID;
+    else if(Effect->Modulator.Waveform == AL_RING_MODULATOR_SAWTOOTH)
+        state->Waveform = SAWTOOTH;
+    else if(Effect->Modulator.Waveform == AL_RING_MODULATOR_SQUARE)
+        state->Waveform = SQUARE;
+
+    state->step = Effect->Modulator.Frequency*(1<<WAVEFORM_FRACBITS) /
+                  Context->Device->Frequency;
+    if(!state->step)
+        state->step = 1;
+
+    cw = cos(2.0*M_PI * Effect->Modulator.HighPassCutoff / Context->Device->Frequency);
+    a = (2.0f-cw) - aluSqrt(aluPow(2.0f-cw, 2.0f) - 1.0f);
+    state->iirFilter.coeff = a;
+}
+
+static ALvoid ModulatorProcess(ALeffectState *effect, const ALeffectslot *Slot, ALuint SamplesToDo, const ALfloat *SamplesIn, ALfloat (*SamplesOut)[OUTPUTCHANNELS])
+{
+    ALmodulatorState *state = (ALmodulatorState*)effect;
+    const ALfloat gain = Slot->Gain * state->Scale;
+    const ALuint step = state->step;
+    ALuint index = state->index;
+    ALfloat samp;
+    ALuint i;
+
+    switch(state->Waveform)
+    {
+    case SINUSOID:
+        for(i = 0;i < SamplesToDo;i++)
+        {
+#define FILTER_OUT(func) do {                                                 \
+    samp = SamplesIn[i];                                                      \
+                                                                              \
+    index += step;                                                            \
+    index &= WAVEFORM_FRACMASK;                                               \
+    samp *= func(index);                                                      \
+                                                                              \
+    samp = hpFilter1P(&state->iirFilter, 0, samp);                            \
+                                                                              \
+    /* Apply slot gain */                                                     \
+    samp *= gain;                                                             \
+                                                                              \
+    SamplesOut[i][FRONT_LEFT]   += samp;                                      \
+    SamplesOut[i][FRONT_RIGHT]  += samp;                                      \
+    SamplesOut[i][FRONT_CENTER] += samp;                                      \
+    SamplesOut[i][SIDE_LEFT]    += samp;                                      \
+    SamplesOut[i][SIDE_RIGHT]   += samp;                                      \
+    SamplesOut[i][BACK_LEFT]    += samp;                                      \
+    SamplesOut[i][BACK_RIGHT]   += samp;                                      \
+    SamplesOut[i][BACK_CENTER]  += samp;                                      \
+} while(0)
+            FILTER_OUT(sin_func);
+        }
+        break;
+
+    case SAWTOOTH:
+        for(i = 0;i < SamplesToDo;i++)
+        {
+            FILTER_OUT(saw_func);
+        }
+        break;
+
+    case SQUARE:
+        for(i = 0;i < SamplesToDo;i++)
+        {
+            FILTER_OUT(square_func);
+#undef FILTER_OUT
+        }
+        break;
+    }
+    state->index = index;
+}
+
+ALeffectState *ModulatorCreate(void)
+{
+    ALmodulatorState *state;
+
+    state = malloc(sizeof(*state));
+    if(!state)
+        return NULL;
+
+    state->state.Destroy = ModulatorDestroy;
+    state->state.DeviceUpdate = ModulatorDeviceUpdate;
+    state->state.Update = ModulatorUpdate;
+    state->state.Process = ModulatorProcess;
+
+    state->index = 0.0f;
+    state->step = 1.0f;
+
+    state->Scale = 1.0f;
+
+    state->iirFilter.coeff = 0.0f;
+    state->iirFilter.history[0] = 0.0f;
+
+    return &state->state;
+}

project/jni/openal/src/Alc/alcRing.c

@@ -0,0 +1,131 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <string.h>
+#include <stdlib.h>
+
+#include "alMain.h"
+
+
+struct RingBuffer {
+    ALubyte *mem;
+
+    ALsizei frame_size;
+    ALsizei length;
+    ALint read_pos;
+    ALint write_pos;
+
+    CRITICAL_SECTION cs;
+};
+
+
+RingBuffer *CreateRingBuffer(ALsizei frame_size, ALsizei length)
+{
+    RingBuffer *ring = calloc(1, sizeof(*ring));
+    if(ring)
+    {
+        ring->frame_size = frame_size;
+        ring->length = length+1;
+        ring->write_pos = 1;
+        ring->mem = malloc(ring->length * ring->frame_size);
+        if(!ring->mem)
+        {
+            free(ring);
+            ring = NULL;
+        }
+
+        InitializeCriticalSection(&ring->cs);
+    }
+    return ring;
+}
+
+void DestroyRingBuffer(RingBuffer *ring)
+{
+    if(ring)
+    {
+        DeleteCriticalSection(&ring->cs);
+        free(ring->mem);
+        free(ring);
+    }
+}
+
+ALsizei RingBufferSize(RingBuffer *ring)
+{
+    ALsizei s;
+
+    EnterCriticalSection(&ring->cs);
+    s = (ring->write_pos-ring->read_pos-1+ring->length) % ring->length;
+    LeaveCriticalSection(&ring->cs);
+
+    return s;
+}
+
+void WriteRingBuffer(RingBuffer *ring, const ALubyte *data, ALsizei len)
+{
+    int remain;
+
+    EnterCriticalSection(&ring->cs);
+
+    remain = (ring->read_pos-ring->write_pos+ring->length) % ring->length;
+    if(remain < len) len = remain;
+
+    if(len > 0)
+    {
+        remain = ring->length - ring->write_pos;
+        if(remain < len)
+        {
+            memcpy(ring->mem+(ring->write_pos*ring->frame_size), data,
+                   remain*ring->frame_size);
+            memcpy(ring->mem, data+(remain*ring->frame_size),
+                   (len-remain)*ring->frame_size);
+        }
+        else
+            memcpy(ring->mem+(ring->write_pos*ring->frame_size), data,
+                   len*ring->frame_size);
+
+        ring->write_pos += len;
+        ring->write_pos %= ring->length;
+    }
+
+    LeaveCriticalSection(&ring->cs);
+}
+
+void ReadRingBuffer(RingBuffer *ring, ALubyte *data, ALsizei len)
+{
+    int remain;
+
+    EnterCriticalSection(&ring->cs);
+
+    remain = ring->length - ring->read_pos;
+    if(remain < len)
+    {
+        memcpy(data, ring->mem+(ring->read_pos*ring->frame_size), remain*ring->frame_size);
+        memcpy(data+(remain*ring->frame_size), ring->mem, (len-remain)*ring->frame_size);
+    }
+    else
+        memcpy(data, ring->mem+(ring->read_pos*ring->frame_size), len*ring->frame_size);
+
+    ring->read_pos += len;
+    ring->read_pos %= ring->length;
+
+    LeaveCriticalSection(&ring->cs);
+}

project/jni/openal/src/Alc/alcThread.c

@@ -0,0 +1,128 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+
+#include "alMain.h"
+#include "alThunk.h"
+
+
+#ifdef _WIN32
+
+typedef struct {
+    ALuint (*func)(ALvoid*);
+    ALvoid *ptr;
+    HANDLE thread;
+} ThreadInfo;
+
+static DWORD CALLBACK StarterFunc(void *ptr)
+{
+    ThreadInfo *inf = (ThreadInfo*)ptr;
+    ALint ret;
+
+    ret = inf->func(inf->ptr);
+    ExitThread((DWORD)ret);
+
+    return (DWORD)ret;
+}
+
+ALvoid *StartThread(ALuint (*func)(ALvoid*), ALvoid *ptr)
+{
+    DWORD dummy;
+    ThreadInfo *inf = malloc(sizeof(ThreadInfo));
+    if(!inf) return 0;
+
+    inf->func = func;
+    inf->ptr = ptr;
+
+    inf->thread = CreateThread(NULL, 0, StarterFunc, inf, 0, &dummy);
+    if(!inf->thread)
+    {
+        free(inf);
+        return NULL;
+    }
+
+    return inf;
+}
+
+ALuint StopThread(ALvoid *thread)
+{
+    ThreadInfo *inf = thread;
+    DWORD ret = 0;
+
+    WaitForSingleObject(inf->thread, INFINITE);
+    GetExitCodeThread(inf->thread, &ret);
+    CloseHandle(inf->thread);
+
+    free(inf);
+
+    return (ALuint)ret;
+}
+
+#else
+
+#include <pthread.h>
+
+typedef struct {
+    ALuint (*func)(ALvoid*);
+    ALvoid *ptr;
+    ALuint ret;
+    pthread_t thread;
+} ThreadInfo;
+
+static void *StarterFunc(void *ptr)
+{
+    ThreadInfo *inf = (ThreadInfo*)ptr;
+    inf->ret = inf->func(inf->ptr);
+    return NULL;
+}
+
+ALvoid *StartThread(ALuint (*func)(ALvoid*), ALvoid *ptr)
+{
+    ThreadInfo *inf = malloc(sizeof(ThreadInfo));
+    if(!inf) return NULL;
+
+    inf->func = func;
+    inf->ptr = ptr;
+    if(pthread_create(&inf->thread, NULL, StarterFunc, inf) != 0)
+    {
+        free(inf);
+        return NULL;
+    }
+
+    return inf;
+}
+
+ALuint StopThread(ALvoid *thread)
+{
+    ThreadInfo *inf = thread;
+    ALuint ret;
+
+    pthread_join(inf->thread, NULL);
+    ret = inf->ret;
+
+    free(inf);
+
+    return ret;
+}
+
+#endif

project/jni/openal/src/Alc/android.c

@@ -0,0 +1,279 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2010 by Chris Robinson
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <jni.h>
+#include <pthread.h>
+#include "alMain.h"
+#include "AL/al.h"
+#include "AL/alc.h"
+
+static const ALCchar android_device[] = "Android Default";
+
+static JavaVM* javaVM = NULL;
+
+static jclass cAudioTrack = NULL;
+
+static jmethodID mAudioTrack;
+static jmethodID mGetMinBufferSize;
+static jmethodID mPlay;
+static jmethodID mStop;
+static jmethodID mRelease;
+static jmethodID mWrite;
+
+jint JNI_OnLoad(JavaVM* vm, void* reserved)
+{
+    javaVM = vm;
+    return JNI_VERSION_1_2;
+}
+
+static JNIEnv* GetEnv()
+{
+    JNIEnv* env = NULL;
+    if (javaVM) (*javaVM)->GetEnv(javaVM, (void**)&env, JNI_VERSION_1_2);
+    return env;
+}
+
+typedef struct
+{
+    pthread_t thread;
+    volatile int running;
+} AndroidData;
+
+#define STREAM_MUSIC 3
+#define CHANNEL_CONFIGURATION_MONO 2
+#define CHANNEL_CONFIGURATION_STEREO 3
+#define ENCODING_PCM_8BIT 3
+#define ENCODING_PCM_16BIT 2
+#define MODE_STREAM 1
+
+static void* thread_function(void* arg)
+{
+    ALCdevice* device = (ALCdevice*)arg;
+    AndroidData* data = (AndroidData*)device->ExtraData;
+
+    JNIEnv* env;
+    (*javaVM)->AttachCurrentThread(javaVM, &env, NULL);
+
+    (*env)->PushLocalFrame(env, 2);
+
+    int sampleRateInHz = device->Frequency;
+    int channelConfig = aluChannelsFromFormat(device->Format) == 1 ? CHANNEL_CONFIGURATION_MONO : CHANNEL_CONFIGURATION_STEREO;
+    int audioFormat = aluBytesFromFormat(device->Format) == 1 ? ENCODING_PCM_8BIT : ENCODING_PCM_16BIT;
+
+    int bufferSizeInBytes = (*env)->CallStaticIntMethod(env, cAudioTrack, 
+        mGetMinBufferSize, sampleRateInHz, channelConfig, audioFormat);
+
+    int bufferSizeInSamples = bufferSizeInBytes / aluFrameSizeFromFormat(device->Format);
+
+    jobject track = (*env)->NewObject(env, cAudioTrack, mAudioTrack,
+        STREAM_MUSIC, sampleRateInHz, channelConfig, audioFormat, device->NumUpdates * bufferSizeInBytes, MODE_STREAM);
+
+    (*env)->CallNonvirtualVoidMethod(env, track, cAudioTrack, mPlay);
+
+    jarray buffer = (*env)->NewByteArray(env, bufferSizeInBytes);
+
+    while (data->running)
+    {
+        void* pBuffer = (*env)->GetPrimitiveArrayCritical(env, buffer, NULL);
+
+        if (pBuffer)
+        {
+            aluMixData(device, pBuffer, bufferSizeInSamples);
+            (*env)->ReleasePrimitiveArrayCritical(env, buffer, pBuffer, 0);
+
+            (*env)->CallNonvirtualIntMethod(env, track, cAudioTrack, mWrite, buffer, 0, bufferSizeInBytes);
+        }
+        else
+        {
+            AL_PRINT("Failed to get pointer to array bytes");
+        }
+    }
+    
+    (*env)->CallNonvirtualVoidMethod(env, track, cAudioTrack, mStop);
+    (*env)->CallNonvirtualVoidMethod(env, track, cAudioTrack, mRelease);
+
+    (*env)->PopLocalFrame(env, NULL);
+
+    (*javaVM)->DetachCurrentThread(javaVM);
+    return NULL;
+}
+
+static ALCboolean android_open_playback(ALCdevice *device, const ALCchar *deviceName)
+{
+    JNIEnv* env = GetEnv();
+    AndroidData* data;
+    int channels;
+    int bytes;
+
+    if (!cAudioTrack)
+    {
+        /* Cache AudioTrack class and it's method id's
+         * And do this only once!
+         */
+
+        cAudioTrack = (*env)->FindClass(env, "android/media/AudioTrack");
+        if (!cAudioTrack)
+        {
+            AL_PRINT("android.media.AudioTrack class is not found. Are you running at least 1.5 version?");
+            return ALC_FALSE;
+        }
+
+        cAudioTrack = (*env)->NewGlobalRef(env, cAudioTrack);
+
+        mAudioTrack = (*env)->GetMethodID(env, cAudioTrack, "<init>", "(IIIIII)V");
+        mGetMinBufferSize = (*env)->GetStaticMethodID(env, cAudioTrack, "getMinBufferSize", "(III)I");
+        mPlay = (*env)->GetMethodID(env, cAudioTrack, "play", "()V");
+        mStop = (*env)->GetMethodID(env, cAudioTrack, "stop", "()V");
+        mRelease = (*env)->GetMethodID(env, cAudioTrack, "release", "()V");
+        mWrite = (*env)->GetMethodID(env, cAudioTrack, "write", "([BII)I");
+    }
+
+    if (!deviceName)
+    {
+        deviceName = android_device;
+    }
+    else if (strcmp(deviceName, android_device) != 0)
+    {
+        return ALC_FALSE;
+    }
+
+    data = (AndroidData*)calloc(1, sizeof(*data));
+    device->szDeviceName = strdup(deviceName);
+    device->ExtraData = data;
+    return ALC_TRUE;
+}
+
+static void android_close_playback(ALCdevice *device)
+{
+    AndroidData* data = (AndroidData*)device->ExtraData;
+    if (data != NULL)
+    {
+        free(data);
+        device->ExtraData = NULL;
+    }
+}
+
+static ALCboolean android_reset_playback(ALCdevice *device)
+{
+    AndroidData* data = (AndroidData*)device->ExtraData;
+
+    if (aluChannelsFromFormat(device->Format) >= 2)
+    {
+        device->Format = aluBytesFromFormat(device->Format) >= 2 ? AL_FORMAT_STEREO16 : AL_FORMAT_STEREO8;
+    }
+    else
+    {
+        device->Format = aluBytesFromFormat(device->Format) >= 2 ? AL_FORMAT_MONO16 : AL_FORMAT_MONO8;
+    }
+
+    SetDefaultChannelOrder(device);
+
+    data->running = 1;
+    pthread_create(&data->thread, NULL, thread_function, device);
+
+    return ALC_TRUE;
+}
+
+static void android_stop_playback(ALCdevice *device)
+{
+    AndroidData* data = (AndroidData*)device->ExtraData;
+
+    if (data->running)
+    {
+        data->running = 0;
+        pthread_join(data->thread, NULL);
+    }
+}
+
+static ALCboolean android_open_capture(ALCdevice *pDevice, const ALCchar *deviceName)
+{
+    (void)pDevice;
+    (void)deviceName;
+    return ALC_FALSE;
+}
+
+static void android_close_capture(ALCdevice *pDevice)
+{
+    (void)pDevice;
+}
+
+static void android_start_capture(ALCdevice *pDevice)
+{
+    (void)pDevice;
+}
+
+static void android_stop_capture(ALCdevice *pDevice)
+{
+    (void)pDevice;
+}
+
+static void android_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
+{
+    (void)pDevice;
+    (void)pBuffer;
+    (void)lSamples;
+}
+
+static ALCuint android_available_samples(ALCdevice *pDevice)
+{
+    (void)pDevice;
+    return 0;
+}
+
+static const BackendFuncs android_funcs = {
+    android_open_playback,
+    android_close_playback,
+    android_reset_playback,
+    android_stop_playback,
+    android_open_capture,
+    android_close_capture,
+    android_start_capture,
+    android_stop_capture,
+    android_capture_samples,
+    android_available_samples
+};
+
+void alc_android_init(BackendFuncs *func_list)
+{
+    *func_list = android_funcs;
+}
+
+void alc_android_deinit(void)
+{
+    JNIEnv* env = GetEnv();
+
+    /* release cached AudioTrack class */
+    (*env)->DeleteGlobalRef(env, cAudioTrack);
+}
+
+void alc_android_probe(int type)
+{
+    if (type == DEVICE_PROBE)
+    {
+        AppendDeviceList(android_device);
+    }
+    else if (type == ALL_DEVICE_PROBE)
+    {
+        AppendAllDeviceList(android_device);
+    }
+}

project/jni/openal/src/Alc/bs2b.c

@@ -0,0 +1,201 @@
+/*-
+ * Copyright (c) 2005 Boris Mikhaylov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include <math.h>
+
+#include "bs2b.h"
+
+#ifndef M_PI
+#define M_PI  3.14159265358979323846
+#endif
+
+/* Single pole IIR filter.
+ * O[n] = a0*I[n] + a1*I[n-1] + b1*O[n-1]
+ */
+
+/* Lowpass filter */
+#define lo_filter(in, out_1) (bs2b->a0_lo*(in) + bs2b->b1_lo*(out_1))
+
+/* Highboost filter */
+#define hi_filter(in, in_1, out_1) (bs2b->a0_hi*(in) + bs2b->a1_hi*(in_1) + bs2b->b1_hi*(out_1))
+
+/* Set up all data. */
+static void init(struct bs2b *bs2b)
+{
+    double Fc_lo, Fc_hi;
+    double G_lo,  G_hi;
+    double x;
+
+    if ((bs2b->srate > 192000) || (bs2b->srate < 2000))
+        bs2b->srate = BS2B_DEFAULT_SRATE;
+
+    switch(bs2b->level)
+    {
+    case BS2B_LOW_CLEVEL: /* Low crossfeed level */
+        Fc_lo = 360.0;
+        Fc_hi = 501.0;
+        G_lo  = 0.398107170553497;
+        G_hi  = 0.205671765275719;
+        break;
+
+    case BS2B_MIDDLE_CLEVEL: /* Middle crossfeed level */
+        Fc_lo = 500.0;
+        Fc_hi = 711.0;
+        G_lo  = 0.459726988530872;
+        G_hi  = 0.228208484414988;
+        break;
+
+    case BS2B_HIGH_CLEVEL: /* High crossfeed level (virtual speakers are closer to itself) */
+        Fc_lo = 700.0;
+        Fc_hi = 1021.0;
+        G_lo  = 0.530884444230988;
+        G_hi  = 0.250105790667544;
+        break;
+
+    case BS2B_LOW_ECLEVEL: /* Low easy crossfeed level */
+        Fc_lo = 360.0;
+        Fc_hi = 494.0;
+        G_lo  = 0.316227766016838;
+        G_hi  = 0.168236228897329;
+        break;
+
+    case BS2B_MIDDLE_ECLEVEL: /* Middle easy crossfeed level */
+        Fc_lo = 500.0;
+        Fc_hi = 689.0;
+        G_lo  = 0.354813389233575;
+        G_hi  = 0.187169483835901;
+        break;
+
+    default: /* High easy crossfeed level */
+        bs2b->level = BS2B_HIGH_ECLEVEL;
+
+        Fc_lo = 700.0;
+        Fc_hi = 975.0;
+        G_lo  = 0.398107170553497;
+        G_hi  = 0.205671765275719;
+        break;
+    } /* switch */
+
+    /* $fc = $Fc / $s;
+     * $d  = 1 / 2 / pi / $fc;
+     * $x  = exp(-1 / $d);
+     */
+
+    x           = exp(-2.0 * M_PI * Fc_lo / bs2b->srate);
+    bs2b->b1_lo = x;
+    bs2b->a0_lo = G_lo * (1.0 - x);
+
+    x           = exp(-2.0 * M_PI * Fc_hi / bs2b->srate);
+    bs2b->b1_hi = x;
+    bs2b->a0_hi = 1.0 - G_hi * (1.0 - x);
+    bs2b->a1_hi = -x;
+
+    bs2b->gain  = 1.0 / (1.0 - G_hi + G_lo);
+} /* init */
+
+/* Exported functions.
+ * See descriptions in "bs2b.h"
+ */
+
+void bs2b_set_level(struct bs2b *bs2b, int level)
+{
+    if(level == bs2b->level)
+        return;
+    bs2b->level = level;
+    init(bs2b);
+} /* bs2b_set_level */
+
+int bs2b_get_level(struct bs2b *bs2b)
+{
+    return bs2b->level;
+} /* bs2b_get_level */
+
+void bs2b_set_srate(struct bs2b *bs2b, int srate)
+{
+    if (srate == bs2b->srate)
+        return;
+    bs2b->srate = srate;
+    init(bs2b);
+} /* bs2b_set_srate */
+
+int bs2b_get_srate(struct bs2b *bs2b)
+{
+    return bs2b->srate;
+} /* bs2b_get_srate */
+
+void bs2b_clear(struct bs2b *bs2b)
+{
+    int loopv = sizeof(bs2b->last_sample);
+
+    while (loopv)
+    {
+        ((char *)&bs2b->last_sample)[--loopv] = 0;
+    }
+} /* bs2b_clear */
+
+int bs2b_is_clear(struct bs2b *bs2b)
+{
+    int loopv = sizeof(bs2b->last_sample);
+
+    while (loopv)
+    {
+        if (((char *)&bs2b->last_sample)[--loopv] != 0)
+            return 0;
+    }
+    return 1;
+} /* bs2b_is_clear */
+
+void bs2b_cross_feed(struct bs2b *bs2b, float *sample)
+{
+    /* Lowpass filter */
+    bs2b->last_sample.lo[0] = lo_filter(sample[0], bs2b->last_sample.lo[0]);
+    bs2b->last_sample.lo[1] = lo_filter(sample[1], bs2b->last_sample.lo[1]);
+
+    /* Highboost filter */
+    bs2b->last_sample.hi[0] = hi_filter(sample[0], bs2b->last_sample.asis[0], bs2b->last_sample.hi[0]);
+    bs2b->last_sample.hi[1] = hi_filter(sample[1], bs2b->last_sample.asis[1], bs2b->last_sample.hi[1]);
+    bs2b->last_sample.asis[0] = sample[0];
+    bs2b->last_sample.asis[1] = sample[1];
+
+    /* Crossfeed */
+    sample[0] = bs2b->last_sample.hi[0] + bs2b->last_sample.lo[1];
+    sample[1] = bs2b->last_sample.hi[1] + bs2b->last_sample.lo[0];
+
+    /* Bass boost cause allpass attenuation */
+    sample[0] *= bs2b->gain;
+    sample[1] *= bs2b->gain;
+
+    /* Clipping of overloaded samples */
+#if 0
+    if (sample[0] > 1.0)
+        sample[0] = 1.0;
+    if (sample[0] < -1.0)
+        sample[0] = -1.0;
+    if (sample[1] > 1.0)
+        sample[1] = 1.0;
+    if (sample[1] < -1.0)
+        sample[1] = -1.0;
+#endif
+} /* bs2b_cross_feed */

project/jni/openal/src/Alc/null.c

@@ -0,0 +1,176 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2010 by Chris Robinson
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include "alMain.h"
+#include "AL/al.h"
+#include "AL/alc.h"
+
+
+typedef struct {
+    ALvoid *buffer;
+    ALuint size;
+
+    volatile int killNow;
+    ALvoid *thread;
+} null_data;
+
+
+static const ALCchar nullDevice[] = "Null Output";
+
+static ALuint NullProc(ALvoid *ptr)
+{
+    ALCdevice *Device = (ALCdevice*)ptr;
+    null_data *data = (null_data*)Device->ExtraData;
+    ALuint frameSize;
+    ALuint now, last;
+    ALuint avail;
+
+    frameSize = aluFrameSizeFromFormat(Device->Format);
+
+    last = timeGetTime()<<8;
+    while(!data->killNow && Device->Connected)
+    {
+        now = timeGetTime()<<8;
+
+        avail = (ALuint64)(now-last) * Device->Frequency / (1000<<8);
+        if(avail < Device->UpdateSize)
+        {
+            Sleep(1);
+            continue;
+        }
+
+        while(avail >= Device->UpdateSize)
+        {
+            aluMixData(Device, data->buffer, Device->UpdateSize);
+
+            avail -= Device->UpdateSize;
+            last += (ALuint64)Device->UpdateSize * (1000<<8) / Device->Frequency;
+        }
+    }
+
+    return 0;
+}
+
+static ALCboolean null_open_playback(ALCdevice *device, const ALCchar *deviceName)
+{
+    null_data *data;
+
+    if(!deviceName)
+        deviceName = nullDevice;
+    else if(strcmp(deviceName, nullDevice) != 0)
+        return ALC_FALSE;
+
+    data = (null_data*)calloc(1, sizeof(*data));
+
+    device->szDeviceName = strdup(deviceName);
+    device->ExtraData = data;
+    return ALC_TRUE;
+}
+
+static void null_close_playback(ALCdevice *device)
+{
+    null_data *data = (null_data*)device->ExtraData;
+
+    free(data);
+    device->ExtraData = NULL;
+}
+
+static ALCboolean null_reset_playback(ALCdevice *device)
+{
+    null_data *data = (null_data*)device->ExtraData;
+
+    data->size = device->UpdateSize * aluFrameSizeFromFormat(device->Format);
+    data->buffer = malloc(data->size);
+    if(!data->buffer)
+    {
+        AL_PRINT("buffer malloc failed\n");
+        return ALC_FALSE;
+    }
+    SetDefaultWFXChannelOrder(device);
+
+    data->thread = StartThread(NullProc, device);
+    if(data->thread == NULL)
+    {
+        free(data->buffer);
+        data->buffer = NULL;
+        return ALC_FALSE;
+    }
+
+    return ALC_TRUE;
+}
+
+static void null_stop_playback(ALCdevice *device)
+{
+    null_data *data = (null_data*)device->ExtraData;
+
+    if(!data->thread)
+        return;
+
+    data->killNow = 1;
+    StopThread(data->thread);
+    data->thread = NULL;
+
+    data->killNow = 0;
+
+    free(data->buffer);
+    data->buffer = NULL;
+}
+
+
+static ALCboolean null_open_capture(ALCdevice *device, const ALCchar *deviceName)
+{
+    (void)device;
+    (void)deviceName;
+    return ALC_FALSE;
+}
+
+
+BackendFuncs null_funcs = {
+    null_open_playback,
+    null_close_playback,
+    null_reset_playback,
+    null_stop_playback,
+    null_open_capture,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+void alc_null_init(BackendFuncs *func_list)
+{
+    *func_list = null_funcs;
+}
+
+void alc_null_deinit(void)
+{
+}
+
+void alc_null_probe(int type)
+{
+    if(type == DEVICE_PROBE)
+        AppendDeviceList(nullDevice);
+    else if(type == ALL_DEVICE_PROBE)
+        AppendAllDeviceList(nullDevice);
+}

project/jni/openal/src/OpenAL32/Include/alAuxEffectSlot.h

@@ -0,0 +1,60 @@
+#ifndef _AL_AUXEFFECTSLOT_H_
+#define _AL_AUXEFFECTSLOT_H_
+
+#include "AL/al.h"
+#include "alEffect.h"
+#include "alFilter.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct ALeffectState ALeffectState;
+
+typedef struct ALeffectslot
+{
+    ALeffect effect;
+
+    ALfloat Gain;
+    ALboolean AuxSendAuto;
+
+    ALeffectState *EffectState;
+
+    ALfloat WetBuffer[BUFFERSIZE];
+
+    ALuint refcount;
+
+    // Index to itself
+    ALuint effectslot;
+
+    struct ALeffectslot *next;
+} ALeffectslot;
+
+
+ALvoid ReleaseALAuxiliaryEffectSlots(ALCcontext *Context);
+
+
+struct ALeffectState {
+    ALvoid (*Destroy)(ALeffectState *State);
+    ALboolean (*DeviceUpdate)(ALeffectState *State, ALCdevice *Device);
+    ALvoid (*Update)(ALeffectState *State, ALCcontext *Context, const ALeffect *Effect);
+    ALvoid (*Process)(ALeffectState *State, const ALeffectslot *Slot, ALuint SamplesToDo, const ALfloat *SamplesIn, ALfloat (*SamplesOut)[OUTPUTCHANNELS]);
+};
+
+ALeffectState *NoneCreate(void);
+ALeffectState *EAXVerbCreate(void);
+ALeffectState *VerbCreate(void);
+ALeffectState *EchoCreate(void);
+ALeffectState *ModulatorCreate(void);
+
+#define ALEffect_Destroy(a)         ((a)->Destroy((a)))
+#define ALEffect_DeviceUpdate(a,b)  ((a)->DeviceUpdate((a),(b)))
+#define ALEffect_Update(a,b,c)      ((a)->Update((a),(b),(c)))
+#define ALEffect_Process(a,b,c,d,e) ((a)->Process((a),(b),(c),(d),(e)))
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

project/jni/openal/src/OpenAL32/Include/alBuffer.h

@@ -0,0 +1,39 @@
+#ifndef _AL_BUFFER_H_
+#define _AL_BUFFER_H_
+
+#include "AL/al.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define BUFFER_PADDING 2
+
+typedef struct ALbuffer
+{
+    ALfloat *data;
+    ALsizei  size;
+
+    ALenum   format;
+    ALenum   eOriginalFormat;
+    ALsizei  frequency;
+
+    ALsizei  OriginalSize;
+    ALsizei  OriginalAlign;
+
+    ALsizei  LoopStart;
+    ALsizei  LoopEnd;
+
+    ALuint   refcount; // Number of sources using this buffer (deletion can only occur when this is 0)
+
+    // Index to itself
+    ALuint buffer;
+} ALbuffer;
+
+ALvoid ReleaseALBuffers(ALCdevice *device);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

project/jni/openal/src/OpenAL32/Include/alDatabuffer.h

@@ -0,0 +1,33 @@
+#ifndef _AL_DATABUFFER_H_
+#define _AL_DATABUFFER_H_
+
+#include "AL/al.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define UNMAPPED 0
+#define MAPPED   1
+
+typedef struct ALdatabuffer
+{
+    ALubyte     *data;
+    ALintptrEXT size;
+
+    ALenum state;
+    ALenum usage;
+
+    /* Index to self */
+    ALuint databuffer;
+
+    struct ALdatabuffer *next;
+} ALdatabuffer;
+
+ALvoid ReleaseALDatabuffers(ALCdevice *device);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

project/jni/openal/src/OpenAL32/Include/alEffect.h

@@ -0,0 +1,83 @@
+// NOTE:  The effect structure is getting too large, it may be a good idea to
+//        start using a union or another form of unified storage.
+#ifndef _AL_EFFECT_H_
+#define _AL_EFFECT_H_
+
+#include "AL/al.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+    EAXREVERB = 0,
+    REVERB,
+    ECHO,
+    MODULATOR,
+
+    MAX_EFFECTS
+};
+extern ALboolean DisabledEffects[MAX_EFFECTS];
+
+typedef struct ALeffect
+{
+    // Effect type (AL_EFFECT_NULL, ...)
+    ALenum type;
+
+    struct {
+        // Shared Reverb Properties
+        ALfloat Density;
+        ALfloat Diffusion;
+        ALfloat Gain;
+        ALfloat GainHF;
+        ALfloat DecayTime;
+        ALfloat DecayHFRatio;
+        ALfloat ReflectionsGain;
+        ALfloat ReflectionsDelay;
+        ALfloat LateReverbGain;
+        ALfloat LateReverbDelay;
+        ALfloat AirAbsorptionGainHF;
+        ALfloat RoomRolloffFactor;
+        ALboolean DecayHFLimit;
+
+        // Additional EAX Reverb Properties
+        ALfloat GainLF;
+        ALfloat DecayLFRatio;
+        ALfloat ReflectionsPan[3];
+        ALfloat LateReverbPan[3];
+        ALfloat EchoTime;
+        ALfloat EchoDepth;
+        ALfloat ModulationTime;
+        ALfloat ModulationDepth;
+        ALfloat HFReference;
+        ALfloat LFReference;
+    } Reverb;
+
+    struct {
+        ALfloat Delay;
+        ALfloat LRDelay;
+
+        ALfloat Damping;
+        ALfloat Feedback;
+
+        ALfloat Spread;
+    } Echo;
+
+    struct {
+        ALfloat Frequency;
+        ALfloat HighPassCutoff;
+        ALint Waveform;
+    } Modulator;
+
+    // Index to itself
+    ALuint effect;
+} ALeffect;
+
+
+ALvoid ReleaseALEffects(ALCdevice *device);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

project/jni/openal/src/OpenAL32/Include/alError.h

@@ -0,0 +1,17 @@
+#ifndef _AL_ERROR_H_
+#define _AL_ERROR_H_
+
+#include "AL/al.h"
+#include "AL/alc.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ALvoid alSetError(ALCcontext *Context, ALenum errorCode);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

project/jni/openal/src/OpenAL32/Include/alFilter.h

@@ -0,0 +1,101 @@
+#ifndef _AL_FILTER_H_
+#define _AL_FILTER_H_
+
+#include "AL/al.h"
+#include "alu.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    ALfloat coeff;
+#ifndef _MSC_VER
+    ALfloat history[0];
+#else
+    ALfloat history[1];
+#endif
+} FILTER;
+
+static __inline ALfloat lpFilter4P(FILTER *iir, ALuint offset, ALfloat input)
+{
+    ALfloat *history = &iir->history[offset];
+    ALfloat a = iir->coeff;
+    ALfloat output = input;
+
+    output = output + (history[0]-output)*a;
+    history[0] = output;
+    output = output + (history[1]-output)*a;
+    history[1] = output;
+    output = output + (history[2]-output)*a;
+    history[2] = output;
+    output = output + (history[3]-output)*a;
+    history[3] = output;
+
+    return output;
+}
+
+static __inline ALfloat lpFilter2P(FILTER *iir, ALuint offset, ALfloat input)
+{
+    ALfloat *history = &iir->history[offset];
+    ALfloat a = iir->coeff;
+    ALfloat output = input;
+
+    output = output + (history[0]-output)*a;
+    history[0] = output;
+    output = output + (history[1]-output)*a;
+    history[1] = output;
+
+    return output;
+}
+
+static __inline ALfloat lpFilter1P(FILTER *iir, ALuint offset, ALfloat input)
+{
+    ALfloat *history = &iir->history[offset];
+    ALfloat a = iir->coeff;
+    ALfloat output = input;
+
+    output = output + (history[0]-output)*a;
+    history[0] = output;
+
+    return output;
+}
+
+/* Calculates the low-pass filter coefficient given the pre-scaled gain and
+ * cos(w) value. Note that g should be pre-scaled (sqr(gain) for one-pole,
+ * sqrt(gain) for four-pole, etc) */
+static __inline ALfloat lpCoeffCalc(ALfloat g, ALfloat cw)
+{
+    ALfloat a = 0.0f;
+
+    /* Be careful with gains < 0.01, as that causes the coefficient
+     * head towards 1, which will flatten the signal */
+    g = __max(g, 0.01f);
+    if(g < 0.9999f) /* 1-epsilon */
+        a = (1 - g*cw - aluSqrt(2*g*(1-cw) - g*g*(1 - cw*cw))) /
+            (1 - g);
+
+    return a;
+}
+
+
+typedef struct ALfilter
+{
+    // Filter type (AL_FILTER_NULL, ...)
+    ALenum type;
+
+    ALfloat Gain;
+    ALfloat GainHF;
+
+    // Index to itself
+    ALuint filter;
+} ALfilter;
+
+
+ALvoid ReleaseALFilters(ALCdevice *device);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

project/jni/openal/src/OpenAL32/Include/alListener.h

@@ -0,0 +1,24 @@
+#ifndef _AL_LISTENER_H_
+#define _AL_LISTENER_H_
+
+#include "AL/al.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct ALlistener_struct
+{
+    ALfloat Position[3];
+    ALfloat Velocity[3];
+    ALfloat Forward[3];
+    ALfloat Up[3];
+    ALfloat Gain;
+    ALfloat MetersPerUnit;
+} ALlistener;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

project/jni/openal/src/OpenAL32/Include/alMain.h

@@ -0,0 +1,497 @@
+#ifndef AL_MAIN_H
+#define AL_MAIN_H
+
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+#ifdef HAVE_FENV_H
+#include <fenv.h>
+#endif
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "AL/alext.h"
+
+#ifndef AL_EXT_buffer_sub_data
+#define AL_EXT_buffer_sub_data 1
+#define AL_BYTE_RW_OFFSETS_EXT                   0x1031
+#define AL_SAMPLE_RW_OFFSETS_EXT                 0x1032
+typedef ALvoid (AL_APIENTRY*PFNALBUFFERSUBDATAEXTPROC)(ALuint,ALenum,const ALvoid*,ALsizei,ALsizei);
+#ifdef AL_ALEXT_PROTOTYPES
+AL_API ALvoid AL_APIENTRY alBufferSubDataEXT(ALuint buffer,ALenum format,const ALvoid *data,ALsizei offset,ALsizei length);
+#endif
+#endif
+
+#ifndef AL_EXT_sample_buffer_object
+#define AL_EXT_sample_buffer_object 1
+typedef ptrdiff_t ALintptrEXT;
+typedef ptrdiff_t ALsizeiptrEXT;
+#define AL_SAMPLE_SOURCE_EXT                     0x1040
+#define AL_SAMPLE_SINK_EXT                       0x1041
+#define AL_READ_ONLY_EXT                         0x1042
+#define AL_WRITE_ONLY_EXT                        0x1043
+#define AL_READ_WRITE_EXT                        0x1044
+#define AL_STREAM_WRITE_EXT                      0x1045
+#define AL_STREAM_READ_EXT                       0x1046
+#define AL_STREAM_COPY_EXT                       0x1047
+#define AL_STATIC_WRITE_EXT                      0x1048
+#define AL_STATIC_READ_EXT                       0x1049
+#define AL_STATIC_COPY_EXT                       0x104A
+#define AL_DYNAMIC_WRITE_EXT                     0x104B
+#define AL_DYNAMIC_READ_EXT                      0x104C
+#define AL_DYNAMIC_COPY_EXT                      0x104D
+typedef ALvoid (AL_APIENTRY*PFNALGENDATABUFFERSEXTPROC)(ALsizei n,ALuint *puiBuffers);
+typedef ALvoid (AL_APIENTRY*PFNALDELETEDATABUFFERSEXTPROC)(ALsizei n, const ALuint *puiBuffers);
+typedef ALboolean (AL_APIENTRY*PFNALISDATABUFFEREXTPROC)(ALuint uiBuffer);
+typedef ALvoid (AL_APIENTRY*PFNALDATABUFFERDATAEXTPROC)(ALuint buffer,const ALvoid *data,ALsizeiptrEXT size,ALenum usage);
+typedef ALvoid (AL_APIENTRY*PFNALDATABUFFERSUBDATAEXTPROC)(ALuint buffer, ALintptrEXT start, ALsizeiptrEXT length, const ALvoid *);
+typedef ALvoid (AL_APIENTRY*PFNALGETDATABUFFERSUBDATAEXTPROC)(ALuint buffer, ALintptrEXT start, ALsizeiptrEXT length, ALvoid *);
+typedef ALvoid (AL_APIENTRY*PFNALDATABUFFERFEXTPROC)(ALuint buffer, ALenum eParam, ALfloat flValue);
+typedef ALvoid (AL_APIENTRY*PFNALDATABUFFERFVEXTPROC)(ALuint buffer, ALenum eParam, const ALfloat* flValues);
+typedef ALvoid (AL_APIENTRY*PFNALDATABUFFERIEXTPROC)(ALuint buffer, ALenum eParam, ALint lValue);
+typedef ALvoid (AL_APIENTRY*PFNALDATABUFFERIVEXTPROC)(ALuint buffer, ALenum eParam, const ALint* plValues);
+typedef ALvoid (AL_APIENTRY*PFNALGETDATABUFFERFEXTPROC)(ALuint buffer, ALenum eParam, ALfloat *pflValue);
+typedef ALvoid (AL_APIENTRY*PFNALGETDATABUFFERFVEXTPROC)(ALuint buffer, ALenum eParam, ALfloat* pflValues);
+typedef ALvoid (AL_APIENTRY*PFNALGETDATABUFFERIEXTPROC)(ALuint buffer, ALenum eParam, ALint *plValue);
+typedef ALvoid (AL_APIENTRY*PFNALGETDATABUFFERIVEXTPROC)(ALuint buffer, ALenum eParam, ALint* plValues);
+typedef ALvoid (AL_APIENTRY*PFNALSELECTDATABUFFEREXTPROC)(ALenum target, ALuint uiBuffer);
+typedef ALvoid* (AL_APIENTRY*PFNALMAPDATABUFFEREXTPROC)(ALuint uiBuffer, ALintptrEXT start, ALsizeiptrEXT length, ALenum access);
+typedef ALvoid (AL_APIENTRY*PFNALUNMAPDATABUFFEREXTPROC)(ALuint uiBuffer);
+#ifdef AL_ALEXT_PROTOTYPES
+AL_API ALvoid AL_APIENTRY alGenDatabuffersEXT(ALsizei n,ALuint *puiBuffers);
+AL_API ALvoid AL_APIENTRY alDeleteDatabuffersEXT(ALsizei n, const ALuint *puiBuffers);
+AL_API ALboolean AL_APIENTRY alIsDatabufferEXT(ALuint uiBuffer);
+AL_API ALvoid AL_APIENTRY alDatabufferDataEXT(ALuint buffer,const ALvoid *data,ALsizeiptrEXT size,ALenum usage);
+AL_API ALvoid AL_APIENTRY alDatabufferSubDataEXT(ALuint buffer, ALintptrEXT start, ALsizeiptrEXT length, const ALvoid *data);
+AL_API ALvoid AL_APIENTRY alGetDatabufferSubDataEXT(ALuint buffer, ALintptrEXT start, ALsizeiptrEXT length, ALvoid *data);
+AL_API ALvoid AL_APIENTRY alDatabufferfEXT(ALuint buffer, ALenum eParam, ALfloat flValue);
+AL_API ALvoid AL_APIENTRY alDatabufferfvEXT(ALuint buffer, ALenum eParam, const ALfloat* flValues);
+AL_API ALvoid AL_APIENTRY alDatabufferiEXT(ALuint buffer, ALenum eParam, ALint lValue);
+AL_API ALvoid AL_APIENTRY alDatabufferivEXT(ALuint buffer, ALenum eParam, const ALint* plValues);
+AL_API ALvoid AL_APIENTRY alGetDatabufferfEXT(ALuint buffer, ALenum eParam, ALfloat *pflValue);
+AL_API ALvoid AL_APIENTRY alGetDatabufferfvEXT(ALuint buffer, ALenum eParam, ALfloat* pflValues);
+AL_API ALvoid AL_APIENTRY alGetDatabufferiEXT(ALuint buffer, ALenum eParam, ALint *plValue);
+AL_API ALvoid AL_APIENTRY alGetDatabufferivEXT(ALuint buffer, ALenum eParam, ALint* plValues);
+AL_API ALvoid AL_APIENTRY alSelectDatabufferEXT(ALenum target, ALuint uiBuffer);
+AL_API ALvoid* AL_APIENTRY alMapDatabufferEXT(ALuint uiBuffer, ALintptrEXT start, ALsizeiptrEXT length, ALenum access);
+AL_API ALvoid AL_APIENTRY alUnmapDatabufferEXT(ALuint uiBuffer);
+#endif
+#endif
+
+#ifndef AL_EXT_loop_points
+#define AL_EXT_loop_points 1
+#define AL_LOOP_POINTS                           0x2015
+#endif
+
+#if defined(HAVE_STDINT_H)
+#include <stdint.h>
+typedef int64_t ALint64;
+typedef uint64_t ALuint64;
+#elif defined(HAVE___INT64)
+typedef __int64 ALint64;
+typedef unsigned __int64 ALuint64;
+#elif (SIZEOF_LONG == 8)
+typedef long ALint64;
+typedef unsigned long ALuint64;
+#elif (SIZEOF_LONG_LONG == 8)
+typedef long long ALint64;
+typedef unsigned long long ALuint64;
+#endif
+
+#ifdef HAVE_GCC_FORMAT
+#define PRINTF_STYLE(x, y) __attribute__((format(printf, (x), (y))))
+#else
+#define PRINTF_STYLE(x, y)
+#endif
+
+#ifdef _WIN32
+
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0500
+#endif
+#include <windows.h>
+
+typedef DWORD tls_type;
+#define tls_create(x) (*(x) = TlsAlloc())
+#define tls_delete(x) TlsFree((x))
+#define tls_get(x) TlsGetValue((x))
+#define tls_set(x, a) TlsSetValue((x), (a))
+
+#else
+
+#include <unistd.h>
+#include <assert.h>
+#include <pthread.h>
+#ifdef HAVE_PTHREAD_NP_H
+#include <pthread_np.h>
+#endif
+#include <sys/time.h>
+#include <time.h>
+#include <errno.h>
+
+#ifdef ANDROID
+#include <android/log.h>
+#endif
+
+#define IsBadWritePtr(a,b) ((a) == NULL && (b) != 0)
+
+typedef pthread_key_t tls_type;
+#define tls_create(x) pthread_key_create((x), NULL)
+#define tls_delete(x) pthread_key_delete((x))
+#define tls_get(x) pthread_getspecific((x))
+#define tls_set(x, a) pthread_setspecific((x), (a))
+
+typedef pthread_mutex_t CRITICAL_SECTION;
+static __inline void EnterCriticalSection(CRITICAL_SECTION *cs)
+{
+    int ret;
+    ret = pthread_mutex_lock(cs);
+    assert(ret == 0);
+}
+static __inline void LeaveCriticalSection(CRITICAL_SECTION *cs)
+{
+    int ret;
+    ret = pthread_mutex_unlock(cs);
+    assert(ret == 0);
+}
+static __inline void InitializeCriticalSection(CRITICAL_SECTION *cs)
+{
+    pthread_mutexattr_t attrib;
+    int ret;
+
+    ret = pthread_mutexattr_init(&attrib);
+    assert(ret == 0);
+
+    ret = pthread_mutexattr_settype(&attrib, PTHREAD_MUTEX_RECURSIVE);
+#ifdef HAVE_PTHREAD_NP_H
+    if(ret != 0)
+        ret = pthread_mutexattr_setkind_np(&attrib, PTHREAD_MUTEX_RECURSIVE);
+#endif
+    assert(ret == 0);
+    ret = pthread_mutex_init(cs, &attrib);
+    assert(ret == 0);
+
+    pthread_mutexattr_destroy(&attrib);
+}
+
+static __inline void DeleteCriticalSection(CRITICAL_SECTION *cs)
+{
+    int ret;
+    ret = pthread_mutex_destroy(cs);
+    assert(ret == 0);
+}
+
+/* NOTE: This wrapper isn't quite accurate as it returns an ALuint, as opposed
+ * to the expected DWORD. Both are defined as unsigned 32-bit types, however.
+ * Additionally, Win32 is supposed to measure the time since Windows started,
+ * as opposed to the actual time. */
+static __inline ALuint timeGetTime(void)
+{
+    int ret;
+#if _POSIX_TIMERS > 0
+    struct timespec ts;
+
+    ret = clock_gettime(CLOCK_REALTIME, &ts);
+    assert(ret == 0);
+
+    return ts.tv_nsec/1000000 + ts.tv_sec*1000;
+#else
+    struct timeval tv;
+
+    ret = gettimeofday(&tv, NULL);
+    assert(ret == 0);
+
+    return tv.tv_usec/1000 + tv.tv_sec*1000;
+#endif
+}
+
+static __inline void Sleep(ALuint t)
+{
+    struct timespec tv, rem;
+    tv.tv_nsec = (t*1000000)%1000000000;
+    tv.tv_sec = t/1000;
+
+    while(nanosleep(&tv, &rem) == -1 && errno == EINTR)
+        tv = rem;
+}
+#define min(x,y) (((x)<(y))?(x):(y))
+#define max(x,y) (((x)>(y))?(x):(y))
+#endif
+
+#include "alListener.h"
+#include "alu.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define SWMIXER_OUTPUT_RATE        44100
+
+#define SPEEDOFSOUNDMETRESPERSEC   (343.3f)
+#define AIRABSORBGAINDBHF          (-0.05f)
+
+#define LOWPASSFREQCUTOFF          (5000)
+
+#define DEFAULT_HEAD_DAMPEN        (0.25f)
+
+
+// Find the next power-of-2 for non-power-of-2 numbers.
+static __inline ALuint NextPowerOf2(ALuint value)
+{
+    ALuint powerOf2 = 1;
+
+    if(value)
+    {
+        value--;
+        while(value)
+        {
+            value >>= 1;
+            powerOf2 <<= 1;
+        }
+    }
+    return powerOf2;
+}
+
+
+typedef struct {
+    ALCboolean (*OpenPlayback)(ALCdevice*, const ALCchar*);
+    void (*ClosePlayback)(ALCdevice*);
+    ALCboolean (*ResetPlayback)(ALCdevice*);
+    void (*StopPlayback)(ALCdevice*);
+
+    ALCboolean (*OpenCapture)(ALCdevice*, const ALCchar*);
+    void (*CloseCapture)(ALCdevice*);
+    void (*StartCapture)(ALCdevice*);
+    void (*StopCapture)(ALCdevice*);
+    void (*CaptureSamples)(ALCdevice*, void*, ALCuint);
+    ALCuint (*AvailableSamples)(ALCdevice*);
+} BackendFuncs;
+
+enum {
+    DEVICE_PROBE,
+    ALL_DEVICE_PROBE,
+    CAPTURE_DEVICE_PROBE
+};
+
+void alc_alsa_init(BackendFuncs *func_list);
+void alc_alsa_deinit(void);
+void alc_alsa_probe(int type);
+void alc_oss_init(BackendFuncs *func_list);
+void alc_oss_deinit(void);
+void alc_oss_probe(int type);
+void alc_solaris_init(BackendFuncs *func_list);
+void alc_solaris_deinit(void);
+void alc_solaris_probe(int type);
+void alcDSoundInit(BackendFuncs *func_list);
+void alcDSoundDeinit(void);
+void alcDSoundProbe(int type);
+void alcWinMMInit(BackendFuncs *FuncList);
+void alcWinMMDeinit(void);
+void alcWinMMProbe(int type);
+void alc_pa_init(BackendFuncs *func_list);
+void alc_pa_deinit(void);
+void alc_pa_probe(int type);
+void alc_wave_init(BackendFuncs *func_list);
+void alc_wave_deinit(void);
+void alc_wave_probe(int type);
+void alc_pulse_init(BackendFuncs *func_list);
+void alc_pulse_deinit(void);
+void alc_pulse_probe(int type);
+void alc_android_init(BackendFuncs *func_list);
+void alc_android_deinit(void);
+void alc_android_probe(int type);
+void alc_null_init(BackendFuncs *func_list);
+void alc_null_deinit(void);
+void alc_null_probe(int type);
+
+
+typedef struct UIntMap {
+    struct {
+        ALuint key;
+        ALvoid *value;
+    } *array;
+    ALsizei size;
+    ALsizei maxsize;
+} UIntMap;
+
+void InitUIntMap(UIntMap *map);
+void ResetUIntMap(UIntMap *map);
+ALenum InsertUIntMapEntry(UIntMap *map, ALuint key, ALvoid *value);
+void RemoveUIntMapKey(UIntMap *map, ALuint key);
+
+static __inline ALvoid *LookupUIntMapKey(UIntMap *map, ALuint key)
+{
+    if(map->size > 0)
+    {
+        ALsizei low = 0;
+        ALsizei high = map->size - 1;
+        while(low < high)
+        {
+            ALsizei mid = low + (high-low)/2;
+            if(map->array[mid].key < key)
+                low = mid + 1;
+            else
+                high = mid;
+        }
+        if(map->array[low].key == key)
+            return map->array[low].value;
+    }
+    return NULL;
+}
+
+
+struct ALCdevice_struct
+{
+    ALCboolean   Connected;
+    ALboolean    IsCaptureDevice;
+
+    ALuint       Frequency;
+    ALuint       UpdateSize;
+    ALuint       NumUpdates;
+    ALenum       Format;
+
+    ALCchar      *szDeviceName;
+
+    ALCenum      LastError;
+
+    // Maximum number of sources that can be created
+    ALuint       MaxNoOfSources;
+    // Maximum number of slots that can be created
+    ALuint       AuxiliaryEffectSlotMax;
+
+    ALCuint      NumMonoSources;
+    ALCuint      NumStereoSources;
+    ALuint       NumAuxSends;
+
+    // Map of Buffers for this device
+    UIntMap BufferMap;
+
+    // Map of Effects for this device
+    UIntMap EffectMap;
+
+    // Map of Filters for this device
+    UIntMap FilterMap;
+
+    // Map of Databuffers for this device
+    UIntMap DatabufferMap;
+
+    // Stereo-to-binaural filter
+    struct bs2b *Bs2b;
+    ALCint       Bs2bLevel;
+
+    // Simulated dampening from head occlusion
+    ALfloat      HeadDampen;
+
+    // Duplicate stereo sources on the side/rear channels
+    ALboolean    DuplicateStereo;
+
+    // Dry path buffer mix
+    float DryBuffer[BUFFERSIZE][OUTPUTCHANNELS];
+
+    ALuint DevChannels[OUTPUTCHANNELS];
+
+    ALfloat ChannelMatrix[OUTPUTCHANNELS][OUTPUTCHANNELS];
+
+    Channel Speaker2Chan[OUTPUTCHANNELS];
+    ALfloat PanningLUT[OUTPUTCHANNELS * LUT_NUM];
+    ALuint  NumChan;
+
+    // Contexts created on this device
+    ALCcontext  **Contexts;
+    ALuint        NumContexts;
+
+    BackendFuncs *Funcs;
+    void         *ExtraData; // For the backend's use
+
+    ALCdevice *next;
+};
+
+#define ALCdevice_OpenPlayback(a,b)      ((a)->Funcs->OpenPlayback((a), (b)))
+#define ALCdevice_ClosePlayback(a)       ((a)->Funcs->ClosePlayback((a)))
+#define ALCdevice_ResetPlayback(a)       ((a)->Funcs->ResetPlayback((a)))
+#define ALCdevice_StopPlayback(a)        ((a)->Funcs->StopPlayback((a)))
+#define ALCdevice_OpenCapture(a,b)       ((a)->Funcs->OpenCapture((a), (b)))
+#define ALCdevice_CloseCapture(a)        ((a)->Funcs->CloseCapture((a)))
+#define ALCdevice_StartCapture(a)        ((a)->Funcs->StartCapture((a)))
+#define ALCdevice_StopCapture(a)         ((a)->Funcs->StopCapture((a)))
+#define ALCdevice_CaptureSamples(a,b,c)  ((a)->Funcs->CaptureSamples((a), (b), (c)))
+#define ALCdevice_AvailableSamples(a)    ((a)->Funcs->AvailableSamples((a)))
+
+struct ALCcontext_struct
+{
+    ALlistener  Listener;
+
+    UIntMap SourceMap;
+    UIntMap EffectSlotMap;
+
+    struct ALdatabuffer *SampleSource;
+    struct ALdatabuffer *SampleSink;
+
+    ALenum      LastError;
+
+    ALboolean   Suspended;
+
+    ALenum      DistanceModel;
+    ALboolean   SourceDistanceModel;
+
+    ALfloat     DopplerFactor;
+    ALfloat     DopplerVelocity;
+    ALfloat     flSpeedOfSound;
+
+    struct ALsource **ActiveSources;
+    ALsizei           ActiveSourceCount;
+    ALsizei           MaxActiveSources;
+
+    ALCdevice  *Device;
+    const ALCchar *ExtensionList;
+
+    ALCcontext *next;
+};
+
+ALCvoid ReleaseALC(ALCvoid);
+
+void AppendDeviceList(const ALCchar *name);
+void AppendAllDeviceList(const ALCchar *name);
+void AppendCaptureDeviceList(const ALCchar *name);
+
+ALCvoid alcSetError(ALCdevice *device, ALenum errorCode);
+
+ALCvoid SuspendContext(ALCcontext *context);
+ALCvoid ProcessContext(ALCcontext *context);
+
+ALvoid *StartThread(ALuint (*func)(ALvoid*), ALvoid *ptr);
+ALuint StopThread(ALvoid *thread);
+
+ALCcontext *GetContextSuspended(void);
+
+typedef struct RingBuffer RingBuffer;
+RingBuffer *CreateRingBuffer(ALsizei frame_size, ALsizei length);
+void DestroyRingBuffer(RingBuffer *ring);
+ALsizei RingBufferSize(RingBuffer *ring);
+void WriteRingBuffer(RingBuffer *ring, const ALubyte *data, ALsizei len);
+void ReadRingBuffer(RingBuffer *ring, ALubyte *data, ALsizei len);
+
+void ReadALConfig(void);
+void FreeALConfig(void);
+int ConfigValueExists(const char *blockName, const char *keyName);
+const char *GetConfigValue(const char *blockName, const char *keyName, const char *def);
+int GetConfigValueInt(const char *blockName, const char *keyName, int def);
+float GetConfigValueFloat(const char *blockName, const char *keyName, float def);
+int GetConfigValueBool(const char *blockName, const char *keyName, int def);
+
+void SetRTPriority(void);
+
+void SetDefaultChannelOrder(ALCdevice *device);
+void SetDefaultWFXChannelOrder(ALCdevice *device);
+
+void al_print(const char *fname, unsigned int line, const char *fmt, ...)
+             PRINTF_STYLE(3,4);
+#define AL_PRINT(...) al_print(__FILE__, __LINE__, __VA_ARGS__)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

project/jni/openal/src/OpenAL32/Include/alSource.h

@@ -0,0 +1,115 @@
+#ifndef _AL_SOURCE_H_
+#define _AL_SOURCE_H_
+
+#define MAX_SENDS                 2
+
+#include "alFilter.h"
+#include "alu.h"
+#include "AL/al.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    POINT_RESAMPLER = 0,
+    LINEAR_RESAMPLER,
+    COSINE_RESAMPLER,
+
+    RESAMPLER_MAX,
+    RESAMPLER_MIN = -1,
+    RESAMPLER_DEFAULT = LINEAR_RESAMPLER
+} resampler_t;
+extern resampler_t DefaultResampler;
+
+typedef struct ALbufferlistitem
+{
+    struct ALbuffer         *buffer;
+    struct ALbufferlistitem *next;
+} ALbufferlistitem;
+
+typedef struct ALsource
+{
+    ALfloat      flPitch;
+    ALfloat      flGain;
+    ALfloat      flOuterGain;
+    ALfloat      flMinGain;
+    ALfloat      flMaxGain;
+    ALfloat      flInnerAngle;
+    ALfloat      flOuterAngle;
+    ALfloat      flRefDistance;
+    ALfloat      flMaxDistance;
+    ALfloat      flRollOffFactor;
+    ALfloat      vPosition[3];
+    ALfloat      vVelocity[3];
+    ALfloat      vOrientation[3];
+    ALboolean    bHeadRelative;
+    ALboolean    bLooping;
+    ALenum       DistanceModel;
+
+    resampler_t  Resampler;
+
+    ALenum       state;
+    ALuint       position;
+    ALuint       position_fraction;
+
+    struct ALbuffer *Buffer;
+
+    struct ALbufferlistitem *queue; // Linked list of buffers in queue
+    ALuint       BuffersInQueue;    // Number of buffers in queue
+    ALuint       BuffersPlayed;     // Number of buffers played on this loop
+
+    ALfilter DirectFilter;
+
+    struct {
+        struct ALeffectslot *Slot;
+        ALfilter WetFilter;
+    } Send[MAX_SENDS];
+
+    ALboolean DryGainHFAuto;
+    ALboolean WetGainAuto;
+    ALboolean WetGainHFAuto;
+    ALfloat   OuterGainHF;
+
+    ALfloat AirAbsorptionFactor;
+    ALfloat RoomRolloffFactor;
+    ALfloat DopplerFactor;
+
+    ALint  lOffset;
+    ALint  lOffsetType;
+
+    // Source Type (Static, Streaming, or Undetermined)
+    ALint  lSourceType;
+
+    // Current gains, which are ramped while mixed
+    ALfloat DryGains[OUTPUTCHANNELS];
+    ALfloat WetGains[MAX_SENDS];
+    ALboolean FirstStart;
+
+    // Current target parameters used for mixing
+    ALboolean NeedsUpdate;
+    struct {
+        ALfloat DryGains[OUTPUTCHANNELS];
+        ALfloat WetGains[MAX_SENDS];
+        ALfloat Pitch;
+
+        struct {
+            FILTER iirFilter;
+            ALfloat history[OUTPUTCHANNELS];
+        } Send[MAX_SENDS];
+
+        FILTER iirFilter;
+        ALfloat history[OUTPUTCHANNELS*2];
+    } Params;
+
+    // Index to itself
+    ALuint source;
+} ALsource;
+
+ALvoid ReleaseALSources(ALCcontext *Context);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

project/jni/openal/src/OpenAL32/Include/alState.h

@@ -0,0 +1,14 @@
+#ifndef _AL_STATE_H_
+#define _AL_STATE_H_
+
+#include "AL/al.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

project/jni/openal/src/OpenAL32/Include/alThunk.h

@@ -0,0 +1,42 @@
+#ifndef _AL_THUNK_H_
+#define _AL_THUNK_H_
+
+#include "config.h"
+
+#include "AL/al.h"
+#include "AL/alc.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void alThunkInit(void);
+void alThunkExit(void);
+ALuint alThunkAddEntry(ALvoid * ptr);
+void alThunkRemoveEntry(ALuint index);
+ALvoid *alThunkLookupEntry(ALuint index);
+
+#if (SIZEOF_VOIDP > SIZEOF_UINT)
+
+#define ALTHUNK_INIT()          alThunkInit()
+#define ALTHUNK_EXIT()          alThunkExit()
+#define ALTHUNK_ADDENTRY(p)     alThunkAddEntry(p)
+#define ALTHUNK_REMOVEENTRY(i)  alThunkRemoveEntry(i)
+#define ALTHUNK_LOOKUPENTRY(i)  alThunkLookupEntry(i)
+
+#else
+
+#define ALTHUNK_INIT()
+#define ALTHUNK_EXIT()
+#define ALTHUNK_ADDENTRY(p)     ((ALuint)p)
+#define ALTHUNK_REMOVEENTRY(i)
+#define ALTHUNK_LOOKUPENTRY(i)  ((ALvoid*)(i))
+
+#endif // (SIZEOF_VOIDP > SIZEOF_INT)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //_AL_THUNK_H_
+

project/jni/openal/src/OpenAL32/Include/alu.h

@@ -0,0 +1,189 @@
+#ifndef _ALU_H_
+#define _ALU_H_
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "AL/alext.h"
+
+#include <math.h>
+#ifdef HAVE_FLOAT_H
+#include <float.h>
+#endif
+
+#ifndef M_PI
+#define M_PI           3.14159265358979323846  /* pi */
+#define M_PI_2         1.57079632679489661923  /* pi/2 */
+#endif
+
+#ifdef HAVE_POWF
+#define aluPow(x,y) ((ALfloat)powf((float)(x),(float)(y)))
+#else
+#define aluPow(x,y) ((ALfloat)pow((double)(x),(double)(y)))
+#endif
+
+#ifdef HAVE_SQRTF
+#define aluSqrt(x) ((ALfloat)sqrtf((float)(x)))
+#else
+#define aluSqrt(x) ((ALfloat)sqrt((double)(x)))
+#endif
+
+#ifdef HAVE_ACOSF
+#define aluAcos(x) ((ALfloat)acosf((float)(x)))
+#else
+#define aluAcos(x) ((ALfloat)acos((double)(x)))
+#endif
+
+#ifdef HAVE_ATANF
+#define aluAtan(x) ((ALfloat)atanf((float)(x)))
+#else
+#define aluAtan(x) ((ALfloat)atan((double)(x)))
+#endif
+
+#ifdef HAVE_FABSF
+#define aluFabs(x) ((ALfloat)fabsf((float)(x)))
+#else
+#define aluFabs(x) ((ALfloat)fabs((double)(x)))
+#endif
+
+// fixes for mingw32.
+#if defined(max) && !defined(__max)
+#define __max max
+#endif
+#if defined(min) && !defined(__min)
+#define __min min
+#endif
+
+#define QUADRANT_NUM  128
+#define LUT_NUM       (4 * QUADRANT_NUM)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    FRONT_LEFT = 0,
+    FRONT_RIGHT,
+    FRONT_CENTER,
+    LFE,
+    BACK_LEFT,
+    BACK_RIGHT,
+    BACK_CENTER,
+    SIDE_LEFT,
+    SIDE_RIGHT,
+
+    OUTPUTCHANNELS
+} Channel;
+
+#define BUFFERSIZE 8192
+
+/* NOTE: The AL_FORMAT_REAR* enums aren't handled here because they're
+ *       converted to AL_FORMAT_QUAD* when loaded */
+static __inline ALuint aluBytesFromFormat(ALenum format)
+{
+    switch(format)
+    {
+        case AL_FORMAT_MONO8:
+        case AL_FORMAT_STEREO8:
+        case AL_FORMAT_QUAD8_LOKI:
+        case AL_FORMAT_QUAD8:
+        case AL_FORMAT_51CHN8:
+        case AL_FORMAT_61CHN8:
+        case AL_FORMAT_71CHN8:
+            return 1;
+
+        case AL_FORMAT_MONO16:
+        case AL_FORMAT_STEREO16:
+        case AL_FORMAT_QUAD16_LOKI:
+        case AL_FORMAT_QUAD16:
+        case AL_FORMAT_51CHN16:
+        case AL_FORMAT_61CHN16:
+        case AL_FORMAT_71CHN16:
+            return 2;
+
+        case AL_FORMAT_MONO_FLOAT32:
+        case AL_FORMAT_STEREO_FLOAT32:
+        case AL_FORMAT_QUAD32:
+        case AL_FORMAT_51CHN32:
+        case AL_FORMAT_61CHN32:
+        case AL_FORMAT_71CHN32:
+            return 4;
+
+        case AL_FORMAT_MONO_DOUBLE_EXT:
+        case AL_FORMAT_STEREO_DOUBLE_EXT:
+            return 8;
+
+        default:
+            return 0;
+    }
+}
+static __inline ALuint aluChannelsFromFormat(ALenum format)
+{
+    switch(format)
+    {
+        case AL_FORMAT_MONO8:
+        case AL_FORMAT_MONO16:
+        case AL_FORMAT_MONO_FLOAT32:
+        case AL_FORMAT_MONO_DOUBLE_EXT:
+            return 1;
+
+        case AL_FORMAT_STEREO8:
+        case AL_FORMAT_STEREO16:
+        case AL_FORMAT_STEREO_FLOAT32:
+        case AL_FORMAT_STEREO_DOUBLE_EXT:
+            return 2;
+
+        case AL_FORMAT_QUAD8_LOKI:
+        case AL_FORMAT_QUAD16_LOKI:
+        case AL_FORMAT_QUAD8:
+        case AL_FORMAT_QUAD16:
+        case AL_FORMAT_QUAD32:
+            return 4;
+
+        case AL_FORMAT_51CHN8:
+        case AL_FORMAT_51CHN16:
+        case AL_FORMAT_51CHN32:
+            return 6;
+
+        case AL_FORMAT_61CHN8:
+        case AL_FORMAT_61CHN16:
+        case AL_FORMAT_61CHN32:
+            return 7;
+
+        case AL_FORMAT_71CHN8:
+        case AL_FORMAT_71CHN16:
+        case AL_FORMAT_71CHN32:
+            return 8;
+
+        default:
+            return 0;
+    }
+}
+static __inline ALuint aluFrameSizeFromFormat(ALenum format)
+{
+    return aluBytesFromFormat(format) * aluChannelsFromFormat(format);
+}
+
+static __inline ALint aluCart2LUTpos(ALfloat re, ALfloat im)
+{
+    ALint pos = 0;
+    ALfloat denom = aluFabs(re) + aluFabs(im);
+    if(denom > 0.0f)
+        pos = (ALint)(QUADRANT_NUM*aluFabs(im) / denom + 0.5);
+
+    if(re < 0.0)
+        pos = 2 * QUADRANT_NUM - pos;
+    if(im < 0.0)
+        pos = LUT_NUM - pos;
+    return pos%LUT_NUM;
+}
+
+ALvoid aluInitPanning(ALCdevice *Device);
+ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size);
+ALvoid aluHandleDisconnect(ALCdevice *device);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

project/jni/openal/src/OpenAL32/Include/bs2b.h

@@ -0,0 +1,109 @@
+/*-
+ * Copyright (c) 2005 Boris Mikhaylov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef BS2B_H
+#define BS2B_H
+
+/* Number of crossfeed levels */
+#define BS2B_CLEVELS           3
+
+/* Normal crossfeed levels */
+#define BS2B_HIGH_CLEVEL       3
+#define BS2B_MIDDLE_CLEVEL     2
+#define BS2B_LOW_CLEVEL        1
+
+/* Easy crossfeed levels */
+#define BS2B_HIGH_ECLEVEL      BS2B_HIGH_CLEVEL    + BS2B_CLEVELS
+#define BS2B_MIDDLE_ECLEVEL    BS2B_MIDDLE_CLEVEL  + BS2B_CLEVELS
+#define BS2B_LOW_ECLEVEL       BS2B_LOW_CLEVEL     + BS2B_CLEVELS
+
+/* Default crossfeed levels */
+#define BS2B_DEFAULT_CLEVEL    BS2B_HIGH_ECLEVEL
+/* Default sample rate (Hz) */
+#define BS2B_DEFAULT_SRATE     44100
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+struct bs2b {
+    int level;  /* Crossfeed level */
+    int srate;   /* Sample rate (Hz) */
+
+    /* Lowpass IIR filter coefficients */
+    double a0_lo;
+    double b1_lo;
+
+    /* Highboost IIR filter coefficients */
+    double a0_hi;
+    double a1_hi;
+    double b1_hi;
+
+    /* Global gain against overloading */
+    double gain;
+
+    /* Buffer of last filtered sample.
+     * [0] - first channel, [1] - second channel
+     */
+    struct t_last_sample {
+        double asis[2];
+        double lo[2];
+        double hi[2];
+    } last_sample;
+};
+
+/* Clear buffers and set new coefficients with new crossfeed level value.
+ * level - crossfeed level of *LEVEL values.
+ */
+void bs2b_set_level(struct bs2b *bs2b, int level);
+
+/* Return current crossfeed level value */
+int bs2b_get_level(struct bs2b *bs2b);
+
+/* Clear buffers and set new coefficients with new sample rate value.
+ * srate - sample rate by Hz.
+ */
+void bs2b_set_srate(struct bs2b *bs2b, int srate);
+
+/* Return current sample rate value */
+int bs2b_get_srate(struct bs2b *bs2b);
+
+/* Clear buffer */
+void bs2b_clear(struct bs2b *bs2b);
+
+/* Return 1 if buffer is clear */
+int bs2b_is_clear(struct bs2b *bs2b);
+
+/* Crossfeeds one stereo sample that are pointed by sample.
+ * [0] - first channel, [1] - second channel.
+ * Returns crossfided samle by sample pointer.
+ */
+
+/* sample poits to floats */
+void bs2b_cross_feed(struct bs2b *bs2b, float *sample);
+
+#ifdef __cplusplus
+}    /* extern "C" */
+#endif /* __cplusplus */
+
+#endif /* BS2B_H */

project/jni/openal/src/OpenAL32/alAuxEffectSlot.c

@@ -0,0 +1,523 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <math.h>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "alMain.h"
+#include "alAuxEffectSlot.h"
+#include "alThunk.h"
+#include "alError.h"
+#include "alSource.h"
+
+
+static ALvoid InitializeEffect(ALCcontext *Context, ALeffectslot *EffectSlot, ALeffect *effect);
+
+#define LookupEffectSlot(m, k) ((ALeffectslot*)LookupUIntMapKey(&(m), (k)))
+#define LookupEffect(m, k) ((ALeffect*)LookupUIntMapKey(&(m), (k)))
+
+AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
+{
+    ALCcontext *Context;
+    ALsizei i=0, j;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    if(n > 0)
+    {
+        ALCdevice *Device = Context->Device;
+
+        if(Context->EffectSlotMap.size+n <= (ALsizei)Device->AuxiliaryEffectSlotMax)
+        {
+            // Check that enough memory has been allocted in the 'effectslots' array for n Effect Slots
+            if(!IsBadWritePtr((void*)effectslots, n * sizeof(ALuint)))
+            {
+                ALenum err;
+
+                while(i < n)
+                {
+                    ALeffectslot *slot = calloc(1, sizeof(ALeffectslot));
+                    if(!slot || !(slot->EffectState=NoneCreate()))
+                    {
+                        free(slot);
+                        // We must have run out or memory
+                        alSetError(Context, AL_OUT_OF_MEMORY);
+                        alDeleteAuxiliaryEffectSlots(i, effectslots);
+                        break;
+                    }
+
+                    slot->effectslot = (ALuint)ALTHUNK_ADDENTRY(slot);
+                    err = InsertUIntMapEntry(&Context->EffectSlotMap,
+                                             slot->effectslot, slot);
+                    if(err != AL_NO_ERROR)
+                    {
+                        ALTHUNK_REMOVEENTRY(slot->effectslot);
+                        ALEffect_Destroy(slot->EffectState);
+                        free(slot);
+
+                        alSetError(Context, err);
+                        alDeleteAuxiliaryEffectSlots(i, effectslots);
+                        break;
+                    }
+
+                    effectslots[i++] = slot->effectslot;
+
+                    slot->Gain = 1.0;
+                    slot->AuxSendAuto = AL_TRUE;
+                    for(j = 0;j < BUFFERSIZE;j++)
+                        slot->WetBuffer[j] = 0.0f;
+                    slot->refcount = 0;
+                }
+            }
+        }
+        else
+            alSetError(Context, AL_INVALID_OPERATION);
+    }
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
+{
+    ALCcontext *Context;
+    ALeffectslot *EffectSlot;
+    ALsizei i;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    if (n >= 0)
+    {
+        // Check that all effectslots are valid
+        for (i = 0; i < n; i++)
+        {
+            if((EffectSlot=LookupEffectSlot(Context->EffectSlotMap, effectslots[i])) == NULL)
+            {
+                alSetError(Context, AL_INVALID_NAME);
+                break;
+            }
+            else
+            {
+                if(EffectSlot->refcount > 0)
+                {
+                    alSetError(Context, AL_INVALID_NAME);
+                    break;
+                }
+            }
+        }
+
+        if (i == n)
+        {
+            // All effectslots are valid
+            for (i = 0; i < n; i++)
+            {
+                // Recheck that the effectslot is valid, because there could be duplicated names
+                if((EffectSlot=LookupEffectSlot(Context->EffectSlotMap, effectslots[i])) != NULL)
+                {
+                    ALEffect_Destroy(EffectSlot->EffectState);
+
+                    RemoveUIntMapKey(&Context->EffectSlotMap, EffectSlot->effectslot);
+                    ALTHUNK_REMOVEENTRY(EffectSlot->effectslot);
+
+                    memset(EffectSlot, 0, sizeof(ALeffectslot));
+                    free(EffectSlot);
+                }
+            }
+        }
+    }
+    else
+        alSetError(Context, AL_INVALID_VALUE);
+
+    ProcessContext(Context);
+}
+
+AL_API ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot)
+{
+    ALCcontext *Context;
+    ALboolean  result;
+
+    Context = GetContextSuspended();
+    if(!Context) return AL_FALSE;
+
+    result = (LookupEffectSlot(Context->EffectSlotMap, effectslot) ?
+              AL_TRUE : AL_FALSE);
+
+    ProcessContext(Context);
+
+    return result;
+}
+
+AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue)
+{
+    ALCcontext *Context;
+    ALboolean updateSources = AL_FALSE;
+    ALeffectslot *EffectSlot;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    if((EffectSlot=LookupEffectSlot(Context->EffectSlotMap, effectslot)) != NULL)
+    {
+        switch(param)
+        {
+        case AL_EFFECTSLOT_EFFECT: {
+            ALeffect *effect = NULL;
+
+            if(iValue == 0 ||
+               (effect=LookupEffect(Context->Device->EffectMap, iValue)) != NULL)
+            {
+                InitializeEffect(Context, EffectSlot, effect);
+                updateSources = AL_TRUE;
+            }
+            else
+                alSetError(Context, AL_INVALID_VALUE);
+        }   break;
+
+        case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
+            if(iValue == AL_TRUE || iValue == AL_FALSE)
+            {
+                EffectSlot->AuxSendAuto = iValue;
+                updateSources = AL_TRUE;
+            }
+            else
+                alSetError(Context, AL_INVALID_VALUE);
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_ENUM);
+            break;
+        }
+    }
+    else
+        alSetError(Context, AL_INVALID_NAME);
+
+    // Force updating the sources that use this slot, since it affects the
+    // sending parameters
+    if(updateSources)
+    {
+        ALsizei pos;
+        for(pos = 0;pos < Context->SourceMap.size;pos++)
+        {
+            ALsource *source = Context->SourceMap.array[pos].value;
+            ALuint i;
+            for(i = 0;i < MAX_SENDS;i++)
+            {
+                if(!source->Send[i].Slot ||
+                   source->Send[i].Slot->effectslot != effectslot)
+                    continue;
+                source->NeedsUpdate = AL_TRUE;
+                break;
+            }
+        }
+    }
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues)
+{
+    ALCcontext *Context;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    if(LookupEffectSlot(Context->EffectSlotMap, effectslot) != NULL)
+    {
+        switch(param)
+        {
+        case AL_EFFECTSLOT_EFFECT:
+        case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
+            alAuxiliaryEffectSloti(effectslot, param, piValues[0]);
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_ENUM);
+            break;
+        }
+    }
+    else
+        alSetError(Context, AL_INVALID_NAME);
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat flValue)
+{
+    ALCcontext *Context;
+    ALeffectslot *EffectSlot;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    if((EffectSlot=LookupEffectSlot(Context->EffectSlotMap, effectslot)) != NULL)
+    {
+        switch(param)
+        {
+        case AL_EFFECTSLOT_GAIN:
+            if(flValue >= 0.0f && flValue <= 1.0f)
+                EffectSlot->Gain = flValue;
+            else
+                alSetError(Context, AL_INVALID_VALUE);
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_ENUM);
+            break;
+        }
+    }
+    else
+        alSetError(Context, AL_INVALID_NAME);
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues)
+{
+    ALCcontext *Context;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    if(LookupEffectSlot(Context->EffectSlotMap, effectslot) != NULL)
+    {
+        switch(param)
+        {
+        case AL_EFFECTSLOT_GAIN:
+            alAuxiliaryEffectSlotf(effectslot, param, pflValues[0]);
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_ENUM);
+            break;
+        }
+    }
+    else
+        alSetError(Context, AL_INVALID_NAME);
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *piValue)
+{
+    ALCcontext *Context;
+    ALeffectslot *EffectSlot;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    if((EffectSlot=LookupEffectSlot(Context->EffectSlotMap, effectslot)) != NULL)
+    {
+        switch(param)
+        {
+        case AL_EFFECTSLOT_EFFECT:
+            *piValue = EffectSlot->effect.effect;
+            break;
+
+        case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
+            *piValue = EffectSlot->AuxSendAuto;
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_ENUM);
+            break;
+        }
+    }
+    else
+        alSetError(Context, AL_INVALID_NAME);
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues)
+{
+    ALCcontext *Context;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    if(LookupEffectSlot(Context->EffectSlotMap, effectslot) != NULL)
+    {
+        switch(param)
+        {
+        case AL_EFFECTSLOT_EFFECT:
+        case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
+            alGetAuxiliaryEffectSloti(effectslot, param, piValues);
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_ENUM);
+            break;
+        }
+    }
+    else
+        alSetError(Context, AL_INVALID_NAME);
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *pflValue)
+{
+    ALCcontext *Context;
+    ALeffectslot *EffectSlot;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    if((EffectSlot=LookupEffectSlot(Context->EffectSlotMap, effectslot)) != NULL)
+    {
+        switch(param)
+        {
+        case AL_EFFECTSLOT_GAIN:
+            *pflValue = EffectSlot->Gain;
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_ENUM);
+            break;
+        }
+    }
+    else
+        alSetError(Context, AL_INVALID_NAME);
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues)
+{
+    ALCcontext *Context;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    if(LookupEffectSlot(Context->EffectSlotMap, effectslot) != NULL)
+    {
+        switch(param)
+        {
+        case AL_EFFECTSLOT_GAIN:
+            alGetAuxiliaryEffectSlotf(effectslot, param, pflValues);
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_ENUM);
+            break;
+        }
+    }
+    else
+        alSetError(Context, AL_INVALID_NAME);
+
+    ProcessContext(Context);
+}
+
+
+static ALvoid NoneDestroy(ALeffectState *State)
+{ free(State); }
+static ALboolean NoneDeviceUpdate(ALeffectState *State, ALCdevice *Device)
+{
+    return AL_TRUE;
+    (void)State;
+    (void)Device;
+}
+static ALvoid NoneUpdate(ALeffectState *State, ALCcontext *Context, const ALeffect *Effect)
+{
+    (void)State;
+    (void)Context;
+    (void)Effect;
+}
+static ALvoid NoneProcess(ALeffectState *State, const ALeffectslot *Slot, ALuint SamplesToDo, const ALfloat *SamplesIn, ALfloat (*SamplesOut)[OUTPUTCHANNELS])
+{
+    (void)State;
+    (void)Slot;
+    (void)SamplesToDo;
+    (void)SamplesIn;
+    (void)SamplesOut;
+}
+ALeffectState *NoneCreate(void)
+{
+    ALeffectState *state;
+
+    state = calloc(1, sizeof(*state));
+    if(!state)
+        return NULL;
+
+    state->Destroy = NoneDestroy;
+    state->DeviceUpdate = NoneDeviceUpdate;
+    state->Update = NoneUpdate;
+    state->Process = NoneProcess;
+
+    return state;
+}
+
+static ALvoid InitializeEffect(ALCcontext *Context, ALeffectslot *EffectSlot, ALeffect *effect)
+{
+    if(EffectSlot->effect.type != (effect?effect->type:AL_EFFECT_NULL))
+    {
+        ALeffectState *NewState = NULL;
+        if(!effect || effect->type == AL_EFFECT_NULL)
+            NewState = NoneCreate();
+        else if(effect->type == AL_EFFECT_EAXREVERB)
+            NewState = EAXVerbCreate();
+        else if(effect->type == AL_EFFECT_REVERB)
+            NewState = VerbCreate();
+        else if(effect->type == AL_EFFECT_ECHO)
+            NewState = EchoCreate();
+        else if(effect->type == AL_EFFECT_RING_MODULATOR)
+            NewState = ModulatorCreate();
+        /* No new state? An error occured.. */
+        if(NewState == NULL ||
+           ALEffect_DeviceUpdate(NewState, Context->Device) == AL_FALSE)
+        {
+            if(NewState)
+                ALEffect_Destroy(NewState);
+            alSetError(Context, AL_OUT_OF_MEMORY);
+            return;
+        }
+        if(EffectSlot->EffectState)
+            ALEffect_Destroy(EffectSlot->EffectState);
+        EffectSlot->EffectState = NewState;
+    }
+    if(!effect)
+        memset(&EffectSlot->effect, 0, sizeof(EffectSlot->effect));
+    else
+        memcpy(&EffectSlot->effect, effect, sizeof(*effect));
+    ALEffect_Update(EffectSlot->EffectState, Context, effect);
+}
+
+
+ALvoid ReleaseALAuxiliaryEffectSlots(ALCcontext *Context)
+{
+    ALsizei pos;
+    for(pos = 0;pos < Context->EffectSlotMap.size;pos++)
+    {
+        ALeffectslot *temp = Context->EffectSlotMap.array[pos].value;
+        Context->EffectSlotMap.array[pos].value = NULL;
+
+        // Release effectslot structure
+        ALEffect_Destroy(temp->EffectState);
+
+        ALTHUNK_REMOVEENTRY(temp->effectslot);
+        memset(temp, 0, sizeof(ALeffectslot));
+        free(temp);
+    }
+}

project/jni/openal/src/OpenAL32/alDatabuffer.c

@@ -0,0 +1,656 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include "alMain.h"
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "AL/alext.h"
+#include "alError.h"
+#include "alDatabuffer.h"
+#include "alThunk.h"
+
+
+#define LookupDatabuffer(m, k) ((ALdatabuffer*)LookupUIntMapKey(&(m), (k)))
+
+/*
+*    alGenDatabuffersEXT(ALsizei n, ALuint *puiBuffers)
+*
+*    Generates n AL Databuffers, and stores the Databuffers Names in the array pointed to by puiBuffers
+*/
+AL_API ALvoid AL_APIENTRY alGenDatabuffersEXT(ALsizei n,ALuint *puiBuffers)
+{
+    ALCcontext *Context;
+    ALsizei i=0;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    /* Check that we are actually generation some Databuffers */
+    if(n > 0)
+    {
+        ALCdevice *device = Context->Device;
+
+        /* Check the pointer is valid (and points to enough memory to store
+         * Databuffer Names) */
+        if(!IsBadWritePtr((void*)puiBuffers, n * sizeof(ALuint)))
+        {
+            ALenum err;
+
+            /* Create all the new Databuffers */
+            while(i < n)
+            {
+                ALdatabuffer *buffer = calloc(1, sizeof(ALdatabuffer));
+                if(!buffer)
+                {
+                    alSetError(Context, AL_OUT_OF_MEMORY);
+                    alDeleteDatabuffersEXT(i, puiBuffers);
+                    break;
+                }
+
+                buffer->databuffer = ALTHUNK_ADDENTRY(buffer);
+                err = InsertUIntMapEntry(&device->DatabufferMap,
+                                         buffer->databuffer, buffer);
+                if(err != AL_NO_ERROR)
+                {
+                    ALTHUNK_REMOVEENTRY(buffer->databuffer);
+                    memset(buffer, 0, sizeof(ALdatabuffer));
+                    free(buffer);
+
+                    alSetError(Context, err);
+                    alDeleteDatabuffersEXT(i, puiBuffers);
+                    break;
+                }
+                puiBuffers[i++] = buffer->databuffer;
+
+                buffer->state = UNMAPPED;
+            }
+        }
+        else
+            alSetError(Context, AL_INVALID_VALUE);
+    }
+
+    ProcessContext(Context);
+}
+
+/*
+*    alDatabeleteBuffersEXT(ALsizei n, ALuint *puiBuffers)
+*
+*    Deletes the n AL Databuffers pointed to by puiBuffers
+*/
+AL_API ALvoid AL_APIENTRY alDeleteDatabuffersEXT(ALsizei n, const ALuint *puiBuffers)
+{
+    ALCcontext *Context;
+    ALdatabuffer *ALBuf;
+    ALsizei i;
+    ALboolean bFailed = AL_FALSE;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    /* Check we are actually Deleting some Databuffers */
+    if(n >= 0)
+    {
+        ALCdevice *device = Context->Device;
+
+        /* Check that all the databuffers are valid and can actually be
+         * deleted */
+        for(i = 0;i < n;i++)
+        {
+            if(!puiBuffers[i])
+                continue;
+
+            /* Check for valid Buffer ID */
+            if((ALBuf=LookupDatabuffer(device->DatabufferMap, puiBuffers[i])) != NULL)
+            {
+                if(ALBuf->state != UNMAPPED)
+                {
+                    /* Databuffer still in use, cannot be deleted */
+                    alSetError(Context, AL_INVALID_OPERATION);
+                    bFailed = AL_TRUE;
+                    break;
+                }
+            }
+            else
+            {
+                /* Invalid Databuffer */
+                alSetError(Context, AL_INVALID_NAME);
+                bFailed = AL_TRUE;
+                break;
+            }
+        }
+
+        /* If all the Databuffers were valid (and unmapped), then we can
+         * delete them */
+        if(!bFailed)
+        {
+            for(i = 0;i < n;i++)
+            {
+                if((ALBuf=LookupDatabuffer(device->DatabufferMap, puiBuffers[i])) != NULL)
+                {
+                    if(ALBuf == Context->SampleSource)
+                        Context->SampleSource = NULL;
+                    if(ALBuf == Context->SampleSink)
+                        Context->SampleSink = NULL;
+
+                    // Release the memory used to store audio data
+                    free(ALBuf->data);
+
+                    // Release buffer structure
+                    RemoveUIntMapKey(&device->DatabufferMap, ALBuf->databuffer);
+                    ALTHUNK_REMOVEENTRY(puiBuffers[i]);
+
+                    memset(ALBuf, 0, sizeof(ALdatabuffer));
+                    free(ALBuf);
+                }
+            }
+        }
+    }
+    else
+        alSetError(Context, AL_INVALID_VALUE);
+
+    ProcessContext(Context);
+}
+
+/*
+*    alIsDatabufferEXT(ALuint uiBuffer)
+*
+*    Checks if ulBuffer is a valid Databuffer Name
+*/
+AL_API ALboolean AL_APIENTRY alIsDatabufferEXT(ALuint buffer)
+{
+    ALCcontext *Context;
+    ALboolean  result;
+    ALCdevice *device;
+
+    Context = GetContextSuspended();
+    if(!Context) return AL_FALSE;
+
+    device = Context->Device;
+    result = ((!buffer || LookupDatabuffer(device->DatabufferMap, buffer)) ?
+              AL_TRUE : AL_FALSE);
+
+    ProcessContext(Context);
+
+    return result;
+}
+
+/*
+*    alDatabufferDataEXT(ALuint buffer,ALvoid *data,ALsizei size,ALenum usage)
+*
+*    Fill databuffer with data
+*/
+AL_API ALvoid AL_APIENTRY alDatabufferDataEXT(ALuint buffer,const ALvoid *data,ALsizeiptrEXT size,ALenum usage)
+{
+    ALCcontext *Context;
+    ALdatabuffer *ALBuf;
+    ALCdevice *Device;
+    ALvoid *temp;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if((ALBuf=LookupDatabuffer(Device->DatabufferMap, buffer)) != NULL)
+    {
+        if(ALBuf->state == UNMAPPED)
+        {
+            if(usage == AL_STREAM_WRITE_EXT || usage == AL_STREAM_READ_EXT ||
+               usage == AL_STREAM_COPY_EXT || usage == AL_STATIC_WRITE_EXT ||
+               usage == AL_STATIC_READ_EXT || usage == AL_STATIC_COPY_EXT ||
+               usage == AL_DYNAMIC_WRITE_EXT || usage == AL_DYNAMIC_READ_EXT ||
+               usage == AL_DYNAMIC_COPY_EXT)
+            {
+                if(size >= 0)
+                {
+                    /* (Re)allocate data */
+                    temp = realloc(ALBuf->data, size);
+                    if(temp)
+                    {
+                        ALBuf->data = temp;
+                        ALBuf->size = size;
+                        ALBuf->usage = usage;
+                        if(data)
+                            memcpy(ALBuf->data, data, size);
+                    }
+                    else
+                        alSetError(Context, AL_OUT_OF_MEMORY);
+                }
+                else
+                    alSetError(Context, AL_INVALID_VALUE);
+            }
+            else
+                alSetError(Context, AL_INVALID_ENUM);
+        }
+        else
+            alSetError(Context, AL_INVALID_OPERATION);
+    }
+    else
+        alSetError(Context, AL_INVALID_NAME);
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alDatabufferSubDataEXT(ALuint uiBuffer, ALintptrEXT start, ALsizeiptrEXT length, const ALvoid *data)
+{
+    ALCcontext    *pContext;
+    ALdatabuffer  *pBuffer;
+    ALCdevice     *Device;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    Device = pContext->Device;
+    if((pBuffer=LookupDatabuffer(Device->DatabufferMap, uiBuffer)) != NULL)
+    {
+        if(start >= 0 && length >= 0 && start+length <= pBuffer->size)
+        {
+            if(pBuffer->state == UNMAPPED)
+                memcpy(pBuffer->data+start, data, length);
+            else
+                alSetError(pContext, AL_INVALID_OPERATION);
+        }
+        else
+            alSetError(pContext, AL_INVALID_VALUE);
+    }
+    else
+        alSetError(pContext, AL_INVALID_NAME);
+
+    ProcessContext(pContext);
+}
+
+AL_API ALvoid AL_APIENTRY alGetDatabufferSubDataEXT(ALuint uiBuffer, ALintptrEXT start, ALsizeiptrEXT length, ALvoid *data)
+{
+    ALCcontext    *pContext;
+    ALdatabuffer  *pBuffer;
+    ALCdevice     *Device;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    Device = pContext->Device;
+    if((pBuffer=LookupDatabuffer(Device->DatabufferMap, uiBuffer)) != NULL)
+    {
+        if(start >= 0 && length >= 0 && start+length <= pBuffer->size)
+        {
+            if(pBuffer->state == UNMAPPED)
+                memcpy(data, pBuffer->data+start, length);
+            else
+                alSetError(pContext, AL_INVALID_OPERATION);
+        }
+        else
+            alSetError(pContext, AL_INVALID_VALUE);
+    }
+    else
+        alSetError(pContext, AL_INVALID_NAME);
+
+    ProcessContext(pContext);
+}
+
+
+AL_API ALvoid AL_APIENTRY alDatabufferfEXT(ALuint buffer, ALenum eParam, ALfloat flValue)
+{
+    ALCcontext    *pContext;
+    ALCdevice     *Device;
+
+    (void)flValue;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    Device = pContext->Device;
+    if(LookupDatabuffer(Device->DatabufferMap, buffer) != NULL)
+    {
+        switch(eParam)
+        {
+        default:
+            alSetError(pContext, AL_INVALID_ENUM);
+            break;
+        }
+    }
+    else
+        alSetError(pContext, AL_INVALID_NAME);
+
+    ProcessContext(pContext);
+}
+
+AL_API ALvoid AL_APIENTRY alDatabufferfvEXT(ALuint buffer, ALenum eParam, const ALfloat* flValues)
+{
+    ALCcontext    *pContext;
+    ALCdevice     *Device;
+
+    (void)flValues;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    Device = pContext->Device;
+    if(LookupDatabuffer(Device->DatabufferMap, buffer) != NULL)
+    {
+        switch(eParam)
+        {
+        default:
+            alSetError(pContext, AL_INVALID_ENUM);
+            break;
+        }
+    }
+    else
+        alSetError(pContext, AL_INVALID_NAME);
+
+    ProcessContext(pContext);
+}
+
+
+AL_API ALvoid AL_APIENTRY alDatabufferiEXT(ALuint buffer, ALenum eParam, ALint lValue)
+{
+    ALCcontext    *pContext;
+    ALCdevice     *Device;
+
+    (void)lValue;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    Device = pContext->Device;
+    if(LookupDatabuffer(Device->DatabufferMap, buffer) != NULL)
+    {
+        switch(eParam)
+        {
+        default:
+            alSetError(pContext, AL_INVALID_ENUM);
+            break;
+        }
+    }
+    else
+        alSetError(pContext, AL_INVALID_NAME);
+
+    ProcessContext(pContext);
+}
+
+AL_API ALvoid AL_APIENTRY alDatabufferivEXT(ALuint buffer, ALenum eParam, const ALint* plValues)
+{
+    ALCcontext    *pContext;
+    ALCdevice     *Device;
+
+    (void)plValues;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    Device = pContext->Device;
+    if(LookupDatabuffer(Device->DatabufferMap, buffer) != NULL)
+    {
+        switch(eParam)
+        {
+        default:
+            alSetError(pContext, AL_INVALID_ENUM);
+            break;
+        }
+    }
+    else
+        alSetError(pContext, AL_INVALID_NAME);
+
+    ProcessContext(pContext);
+}
+
+
+AL_API ALvoid AL_APIENTRY alGetDatabufferfEXT(ALuint buffer, ALenum eParam, ALfloat *pflValue)
+{
+    ALCcontext    *pContext;
+    ALCdevice     *Device;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    if(pflValue)
+    {
+        Device = pContext->Device;
+        if(LookupDatabuffer(Device->DatabufferMap, buffer) != NULL)
+        {
+            switch(eParam)
+            {
+            default:
+                alSetError(pContext, AL_INVALID_ENUM);
+                break;
+            }
+        }
+        else
+            alSetError(pContext, AL_INVALID_NAME);
+    }
+    else
+        alSetError(pContext, AL_INVALID_VALUE);
+
+    ProcessContext(pContext);
+}
+
+AL_API ALvoid AL_APIENTRY alGetDatabufferfvEXT(ALuint buffer, ALenum eParam, ALfloat* pflValues)
+{
+    ALCcontext    *pContext;
+    ALCdevice     *Device;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    if(pflValues)
+    {
+        Device = pContext->Device;
+        if(LookupDatabuffer(Device->DatabufferMap, buffer) != NULL)
+        {
+            switch(eParam)
+            {
+            default:
+                alSetError(pContext, AL_INVALID_ENUM);
+                break;
+            }
+        }
+        else
+            alSetError(pContext, AL_INVALID_NAME);
+    }
+    else
+        alSetError(pContext, AL_INVALID_VALUE);
+
+    ProcessContext(pContext);
+}
+
+AL_API ALvoid AL_APIENTRY alGetDatabufferiEXT(ALuint buffer, ALenum eParam, ALint *plValue)
+{
+    ALCcontext    *pContext;
+    ALdatabuffer  *pBuffer;
+    ALCdevice     *Device;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    if(plValue)
+    {
+        Device = pContext->Device;
+        if((pBuffer=LookupDatabuffer(Device->DatabufferMap, buffer)) != NULL)
+        {
+            switch(eParam)
+            {
+            case AL_SIZE:
+                *plValue = (ALint)pBuffer->size;
+                break;
+
+            default:
+                alSetError(pContext, AL_INVALID_ENUM);
+                break;
+            }
+        }
+        else
+            alSetError(pContext, AL_INVALID_NAME);
+    }
+    else
+        alSetError(pContext, AL_INVALID_VALUE);
+
+    ProcessContext(pContext);
+}
+
+AL_API ALvoid AL_APIENTRY alGetDatabufferivEXT(ALuint buffer, ALenum eParam, ALint* plValues)
+{
+    ALCcontext    *pContext;
+    ALCdevice     *Device;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    if(plValues)
+    {
+        Device = pContext->Device;
+        if(LookupDatabuffer(Device->DatabufferMap, buffer) != NULL)
+        {
+            switch (eParam)
+            {
+            case AL_SIZE:
+                alGetDatabufferiEXT(buffer, eParam, plValues);
+                break;
+
+            default:
+                alSetError(pContext, AL_INVALID_ENUM);
+                break;
+            }
+        }
+        else
+            alSetError(pContext, AL_INVALID_NAME);
+    }
+    else
+        alSetError(pContext, AL_INVALID_VALUE);
+
+    ProcessContext(pContext);
+}
+
+
+AL_API ALvoid AL_APIENTRY alSelectDatabufferEXT(ALenum target, ALuint uiBuffer)
+{
+    ALCcontext    *pContext;
+    ALdatabuffer  *pBuffer = NULL;
+    ALCdevice     *Device;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    Device = pContext->Device;
+    if(uiBuffer == 0 ||
+       (pBuffer=LookupDatabuffer(Device->DatabufferMap, uiBuffer)) != NULL)
+    {
+        if(target == AL_SAMPLE_SOURCE_EXT)
+            pContext->SampleSource = pBuffer;
+        else if(target == AL_SAMPLE_SINK_EXT)
+            pContext->SampleSink = pBuffer;
+        else
+            alSetError(pContext, AL_INVALID_VALUE);
+    }
+    else
+        alSetError(pContext, AL_INVALID_NAME);
+
+    ProcessContext(pContext);
+}
+
+
+AL_API ALvoid* AL_APIENTRY alMapDatabufferEXT(ALuint uiBuffer, ALintptrEXT start, ALsizeiptrEXT length, ALenum access)
+{
+    ALCcontext    *pContext;
+    ALdatabuffer  *pBuffer;
+    ALvoid        *ret = NULL;
+    ALCdevice     *Device;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return NULL;
+
+    Device = pContext->Device;
+    if((pBuffer=LookupDatabuffer(Device->DatabufferMap, uiBuffer)) != NULL)
+    {
+        if(start >= 0 && length >= 0 && start+length <= pBuffer->size)
+        {
+            if(access == AL_READ_ONLY_EXT || access == AL_WRITE_ONLY_EXT ||
+               access == AL_READ_WRITE_EXT)
+            {
+                if(pBuffer->state == UNMAPPED)
+                {
+                    ret = pBuffer->data + start;
+                    pBuffer->state = MAPPED;
+                }
+                else
+                    alSetError(pContext, AL_INVALID_OPERATION);
+            }
+            else
+                alSetError(pContext, AL_INVALID_ENUM);
+        }
+        else
+            alSetError(pContext, AL_INVALID_VALUE);
+    }
+    else
+        alSetError(pContext, AL_INVALID_NAME);
+
+    ProcessContext(pContext);
+
+    return ret;
+}
+
+AL_API ALvoid AL_APIENTRY alUnmapDatabufferEXT(ALuint uiBuffer)
+{
+    ALCcontext    *pContext;
+    ALdatabuffer  *pBuffer;
+    ALCdevice     *Device;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    Device = pContext->Device;
+    if((pBuffer=LookupDatabuffer(Device->DatabufferMap, uiBuffer)) != NULL)
+    {
+        if(pBuffer->state == MAPPED)
+            pBuffer->state = UNMAPPED;
+        else
+            alSetError(pContext, AL_INVALID_OPERATION);
+    }
+    else
+        alSetError(pContext, AL_INVALID_NAME);
+
+    ProcessContext(pContext);
+}
+
+
+/*
+*    ReleaseALDatabuffers()
+*
+*    INTERNAL FN : Called by DLLMain on exit to destroy any buffers that still exist
+*/
+ALvoid ReleaseALDatabuffers(ALCdevice *device)
+{
+    ALsizei i;
+    for(i = 0;i < device->DatabufferMap.size;i++)
+    {
+        ALdatabuffer *temp = device->DatabufferMap.array[i].value;
+        device->DatabufferMap.array[i].value = NULL;
+
+        // Release buffer data
+        free(temp->data);
+
+        // Release Buffer structure
+        ALTHUNK_REMOVEENTRY(temp->databuffer);
+        memset(temp, 0, sizeof(ALdatabuffer));
+        free(temp);
+    }
+}

project/jni/openal/src/OpenAL32/alError.c

@@ -0,0 +1,47 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2000 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include "alMain.h"
+#include "AL/alc.h"
+#include "alError.h"
+
+AL_API ALenum AL_APIENTRY alGetError(ALvoid)
+{
+    ALCcontext *Context;
+    ALenum errorCode;
+
+    Context = GetContextSuspended();
+    if(!Context) return AL_INVALID_OPERATION;
+
+    errorCode = Context->LastError;
+    Context->LastError = AL_NO_ERROR;
+
+    ProcessContext(Context);
+
+    return errorCode;
+}
+
+ALvoid alSetError(ALCcontext *Context, ALenum errorCode)
+{
+    if(Context->LastError == AL_NO_ERROR)
+        Context->LastError = errorCode;
+}

project/jni/openal/src/OpenAL32/alExtension.c

@@ -0,0 +1,329 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "alError.h"
+#include "alMain.h"
+#include "alFilter.h"
+#include "alEffect.h"
+#include "alAuxEffectSlot.h"
+#include "alDatabuffer.h"
+#include "alSource.h"
+#include "alBuffer.h"
+#include "AL/al.h"
+#include "AL/alc.h"
+
+typedef struct ALenums {
+    const ALchar *enumName;
+    ALenum value;
+} ALenums;
+
+
+static const ALenums enumeration[] = {
+    // Types
+    { "AL_INVALID",                           AL_INVALID                          },
+    { "AL_NONE",                              AL_NONE                             },
+    { "AL_FALSE",                             AL_FALSE                            },
+    { "AL_TRUE",                              AL_TRUE                             },
+
+    // Source and Listener Properties
+    { "AL_SOURCE_RELATIVE",                   AL_SOURCE_RELATIVE                  },
+    { "AL_CONE_INNER_ANGLE",                  AL_CONE_INNER_ANGLE                 },
+    { "AL_CONE_OUTER_ANGLE",                  AL_CONE_OUTER_ANGLE                 },
+    { "AL_PITCH",                             AL_PITCH                            },
+    { "AL_POSITION",                          AL_POSITION                         },
+    { "AL_DIRECTION",                         AL_DIRECTION                        },
+    { "AL_VELOCITY",                          AL_VELOCITY                         },
+    { "AL_LOOPING",                           AL_LOOPING                          },
+    { "AL_BUFFER",                            AL_BUFFER                           },
+    { "AL_GAIN",                              AL_GAIN                             },
+    { "AL_MIN_GAIN",                          AL_MIN_GAIN                         },
+    { "AL_MAX_GAIN",                          AL_MAX_GAIN                         },
+    { "AL_ORIENTATION",                       AL_ORIENTATION                      },
+    { "AL_REFERENCE_DISTANCE",                AL_REFERENCE_DISTANCE               },
+    { "AL_ROLLOFF_FACTOR",                    AL_ROLLOFF_FACTOR                   },
+    { "AL_CONE_OUTER_GAIN",                   AL_CONE_OUTER_GAIN                  },
+    { "AL_MAX_DISTANCE",                      AL_MAX_DISTANCE                     },
+    { "AL_SEC_OFFSET",                        AL_SEC_OFFSET                       },
+    { "AL_SAMPLE_OFFSET",                     AL_SAMPLE_OFFSET                    },
+    { "AL_BYTE_OFFSET",                       AL_BYTE_OFFSET                      },
+    { "AL_SOURCE_TYPE",                       AL_SOURCE_TYPE                      },
+    { "AL_STATIC",                            AL_STATIC                           },
+    { "AL_STREAMING",                         AL_STREAMING                        },
+    { "AL_UNDETERMINED",                      AL_UNDETERMINED                     },
+    { "AL_METERS_PER_UNIT",                   AL_METERS_PER_UNIT                  },
+
+    // Source EFX Properties
+    { "AL_DIRECT_FILTER",                     AL_DIRECT_FILTER                    },
+    { "AL_AUXILIARY_SEND_FILTER",             AL_AUXILIARY_SEND_FILTER            },
+    { "AL_AIR_ABSORPTION_FACTOR",             AL_AIR_ABSORPTION_FACTOR            },
+    { "AL_ROOM_ROLLOFF_FACTOR",               AL_ROOM_ROLLOFF_FACTOR              },
+    { "AL_CONE_OUTER_GAINHF",                 AL_CONE_OUTER_GAINHF                },
+    { "AL_DIRECT_FILTER_GAINHF_AUTO",         AL_DIRECT_FILTER_GAINHF_AUTO        },
+    { "AL_AUXILIARY_SEND_FILTER_GAIN_AUTO",   AL_AUXILIARY_SEND_FILTER_GAIN_AUTO  },
+    { "AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO", AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO},
+
+    // Source State information
+    { "AL_SOURCE_STATE",                      AL_SOURCE_STATE                     },
+    { "AL_INITIAL",                           AL_INITIAL                          },
+    { "AL_PLAYING",                           AL_PLAYING                          },
+    { "AL_PAUSED",                            AL_PAUSED                           },
+    { "AL_STOPPED",                           AL_STOPPED                          },
+
+    // Queue information
+    { "AL_BUFFERS_QUEUED",                    AL_BUFFERS_QUEUED                   },
+    { "AL_BUFFERS_PROCESSED",                 AL_BUFFERS_PROCESSED                },
+
+    // Buffer Formats
+    { "AL_FORMAT_MONO8",                      AL_FORMAT_MONO8                     },
+    { "AL_FORMAT_MONO16",                     AL_FORMAT_MONO16                    },
+    { "AL_FORMAT_MONO_FLOAT32",               AL_FORMAT_MONO_FLOAT32              },
+    { "AL_FORMAT_MONO_DOUBLE_EXT",            AL_FORMAT_MONO_DOUBLE_EXT           },
+    { "AL_FORMAT_STEREO8",                    AL_FORMAT_STEREO8                   },
+    { "AL_FORMAT_STEREO16",                   AL_FORMAT_STEREO16                  },
+    { "AL_FORMAT_STEREO_FLOAT32",             AL_FORMAT_STEREO_FLOAT32            },
+    { "AL_FORMAT_STEREO_DOUBLE_EXT",          AL_FORMAT_STEREO_DOUBLE_EXT         },
+    { "AL_FORMAT_MONO_IMA4",                  AL_FORMAT_MONO_IMA4                 },
+    { "AL_FORMAT_STEREO_IMA4",                AL_FORMAT_STEREO_IMA4               },
+    { "AL_FORMAT_QUAD8_LOKI",                 AL_FORMAT_QUAD8_LOKI                },
+    { "AL_FORMAT_QUAD16_LOKI",                AL_FORMAT_QUAD16_LOKI               },
+    { "AL_FORMAT_QUAD8",                      AL_FORMAT_QUAD8                     },
+    { "AL_FORMAT_QUAD16",                     AL_FORMAT_QUAD16                    },
+    { "AL_FORMAT_QUAD32",                     AL_FORMAT_QUAD32                    },
+    { "AL_FORMAT_51CHN8",                     AL_FORMAT_51CHN8                    },
+    { "AL_FORMAT_51CHN16",                    AL_FORMAT_51CHN16                   },
+    { "AL_FORMAT_51CHN32",                    AL_FORMAT_51CHN32                   },
+    { "AL_FORMAT_61CHN8",                     AL_FORMAT_61CHN8                    },
+    { "AL_FORMAT_61CHN16",                    AL_FORMAT_61CHN16                   },
+    { "AL_FORMAT_61CHN32",                    AL_FORMAT_61CHN32                   },
+    { "AL_FORMAT_71CHN8",                     AL_FORMAT_71CHN8                    },
+    { "AL_FORMAT_71CHN16",                    AL_FORMAT_71CHN16                   },
+    { "AL_FORMAT_71CHN32",                    AL_FORMAT_71CHN32                   },
+    { "AL_FORMAT_REAR8",                      AL_FORMAT_REAR8                     },
+    { "AL_FORMAT_REAR16",                     AL_FORMAT_REAR16                    },
+    { "AL_FORMAT_REAR32",                     AL_FORMAT_REAR32                    },
+    { "AL_FORMAT_MONO_MULAW",                 AL_FORMAT_MONO_MULAW                },
+    { "AL_FORMAT_MONO_MULAW_EXT",             AL_FORMAT_MONO_MULAW                },
+    { "AL_FORMAT_STEREO_MULAW",               AL_FORMAT_STEREO_MULAW              },
+    { "AL_FORMAT_STEREO_MULAW_EXT",           AL_FORMAT_STEREO_MULAW              },
+    { "AL_FORMAT_QUAD_MULAW",                 AL_FORMAT_QUAD_MULAW                },
+    { "AL_FORMAT_51CHN_MULAW",                AL_FORMAT_51CHN_MULAW               },
+    { "AL_FORMAT_61CHN_MULAW",                AL_FORMAT_61CHN_MULAW               },
+    { "AL_FORMAT_71CHN_MULAW",                AL_FORMAT_71CHN_MULAW               },
+    { "AL_FORMAT_REAR_MULAW",                 AL_FORMAT_REAR_MULAW                },
+
+    // Buffer attributes
+    { "AL_FREQUENCY",                         AL_FREQUENCY                        },
+    { "AL_BITS",                              AL_BITS                             },
+    { "AL_CHANNELS",                          AL_CHANNELS                         },
+    { "AL_SIZE",                              AL_SIZE                             },
+
+    // Buffer States (not supported yet)
+    { "AL_UNUSED",                            AL_UNUSED                           },
+    { "AL_PENDING",                           AL_PENDING                          },
+    { "AL_PROCESSED",                         AL_PROCESSED                        },
+
+    // AL Error Messages
+    { "AL_NO_ERROR",                          AL_NO_ERROR                         },
+    { "AL_INVALID_NAME",                      AL_INVALID_NAME                     },
+    { "AL_INVALID_ENUM",                      AL_INVALID_ENUM                     },
+    { "AL_INVALID_VALUE",                     AL_INVALID_VALUE                    },
+    { "AL_INVALID_OPERATION",                 AL_INVALID_OPERATION                },
+    { "AL_OUT_OF_MEMORY",                     AL_OUT_OF_MEMORY                    },
+
+    // Context strings
+    { "AL_VENDOR",                            AL_VENDOR                           },
+    { "AL_VERSION",                           AL_VERSION                          },
+    { "AL_RENDERER",                          AL_RENDERER                         },
+    { "AL_EXTENSIONS",                        AL_EXTENSIONS                       },
+
+    // Global states
+    { "AL_DOPPLER_FACTOR",                    AL_DOPPLER_FACTOR                   },
+    { "AL_DOPPLER_VELOCITY",                  AL_DOPPLER_VELOCITY                 },
+    { "AL_DISTANCE_MODEL",                    AL_DISTANCE_MODEL                   },
+    { "AL_SPEED_OF_SOUND",                    AL_SPEED_OF_SOUND                   },
+    { "AL_SOURCE_DISTANCE_MODEL",             AL_SOURCE_DISTANCE_MODEL            },
+
+    // Distance Models
+    { "AL_INVERSE_DISTANCE",                  AL_INVERSE_DISTANCE                 },
+    { "AL_INVERSE_DISTANCE_CLAMPED",          AL_INVERSE_DISTANCE_CLAMPED         },
+    { "AL_LINEAR_DISTANCE",                   AL_LINEAR_DISTANCE                  },
+    { "AL_LINEAR_DISTANCE_CLAMPED",           AL_LINEAR_DISTANCE_CLAMPED          },
+    { "AL_EXPONENT_DISTANCE",                 AL_EXPONENT_DISTANCE                },
+    { "AL_EXPONENT_DISTANCE_CLAMPED",         AL_EXPONENT_DISTANCE_CLAMPED        },
+
+    // Filter types
+    { "AL_FILTER_TYPE",                       AL_FILTER_TYPE                      },
+    { "AL_FILTER_NULL",                       AL_FILTER_NULL                      },
+    { "AL_FILTER_LOWPASS",                    AL_FILTER_LOWPASS                   },
+#if 0
+    { "AL_FILTER_HIGHPASS",                   AL_FILTER_HIGHPASS                  },
+    { "AL_FILTER_BANDPASS",                   AL_FILTER_BANDPASS                  },
+#endif
+
+    // Filter params
+    { "AL_LOWPASS_GAIN",                      AL_LOWPASS_GAIN                     },
+    { "AL_LOWPASS_GAINHF",                    AL_LOWPASS_GAINHF                   },
+
+    // Effect types
+    { "AL_EFFECT_TYPE",                       AL_EFFECT_TYPE                      },
+    { "AL_EFFECT_NULL",                       AL_EFFECT_NULL                      },
+    { "AL_EFFECT_REVERB",                     AL_EFFECT_REVERB                    },
+    { "AL_EFFECT_EAXREVERB",                  AL_EFFECT_EAXREVERB                 },
+#if 0
+    { "AL_EFFECT_CHORUS",                     AL_EFFECT_CHORUS                    },
+    { "AL_EFFECT_DISTORTION",                 AL_EFFECT_DISTORTION                },
+#endif
+    { "AL_EFFECT_ECHO",                       AL_EFFECT_ECHO                      },
+#if 0
+    { "AL_EFFECT_FLANGER",                    AL_EFFECT_FLANGER                   },
+    { "AL_EFFECT_FREQUENCY_SHIFTER",          AL_EFFECT_FREQUENCY_SHIFTER         },
+    { "AL_EFFECT_VOCAL_MORPHER",              AL_EFFECT_VOCAL_MORPHER             },
+    { "AL_EFFECT_PITCH_SHIFTER",              AL_EFFECT_PITCH_SHIFTER             },
+#endif
+    { "AL_EFFECT_RING_MODULATOR",             AL_EFFECT_RING_MODULATOR            },
+#if 0
+    { "AL_EFFECT_AUTOWAH",                    AL_EFFECT_AUTOWAH                   },
+    { "AL_EFFECT_COMPRESSOR",                 AL_EFFECT_COMPRESSOR                },
+    { "AL_EFFECT_EQUALIZER",                  AL_EFFECT_EQUALIZER                 },
+#endif
+
+    // Reverb params
+    { "AL_REVERB_DENSITY",                    AL_REVERB_DENSITY                   },
+    { "AL_REVERB_DIFFUSION",                  AL_REVERB_DIFFUSION                 },
+    { "AL_REVERB_GAIN",                       AL_REVERB_GAIN                      },
+    { "AL_REVERB_GAINHF",                     AL_REVERB_GAINHF                    },
+    { "AL_REVERB_DECAY_TIME",                 AL_REVERB_DECAY_TIME                },
+    { "AL_REVERB_DECAY_HFRATIO",              AL_REVERB_DECAY_HFRATIO             },
+    { "AL_REVERB_REFLECTIONS_GAIN",           AL_REVERB_REFLECTIONS_GAIN          },
+    { "AL_REVERB_REFLECTIONS_DELAY",          AL_REVERB_REFLECTIONS_DELAY         },
+    { "AL_REVERB_LATE_REVERB_GAIN",           AL_REVERB_LATE_REVERB_GAIN          },
+    { "AL_REVERB_LATE_REVERB_DELAY",          AL_REVERB_LATE_REVERB_DELAY         },
+    { "AL_REVERB_AIR_ABSORPTION_GAINHF",      AL_REVERB_AIR_ABSORPTION_GAINHF     },
+    { "AL_REVERB_ROOM_ROLLOFF_FACTOR",        AL_REVERB_ROOM_ROLLOFF_FACTOR       },
+    { "AL_REVERB_DECAY_HFLIMIT",              AL_REVERB_DECAY_HFLIMIT             },
+
+    // EAX Reverb params
+    { "AL_EAXREVERB_DENSITY",                 AL_EAXREVERB_DENSITY                },
+    { "AL_EAXREVERB_DIFFUSION",               AL_EAXREVERB_DIFFUSION              },
+    { "AL_EAXREVERB_GAIN",                    AL_EAXREVERB_GAIN                   },
+    { "AL_EAXREVERB_GAINHF",                  AL_EAXREVERB_GAINHF                 },
+    { "AL_EAXREVERB_GAINLF",                  AL_EAXREVERB_GAINLF                 },
+    { "AL_EAXREVERB_DECAY_TIME",              AL_EAXREVERB_DECAY_TIME             },
+    { "AL_EAXREVERB_DECAY_HFRATIO",           AL_EAXREVERB_DECAY_HFRATIO          },
+    { "AL_EAXREVERB_DECAY_LFRATIO",           AL_EAXREVERB_DECAY_LFRATIO          },
+    { "AL_EAXREVERB_REFLECTIONS_GAIN",        AL_EAXREVERB_REFLECTIONS_GAIN       },
+    { "AL_EAXREVERB_REFLECTIONS_DELAY",       AL_EAXREVERB_REFLECTIONS_DELAY      },
+    { "AL_EAXREVERB_REFLECTIONS_PAN",         AL_EAXREVERB_REFLECTIONS_PAN        },
+    { "AL_EAXREVERB_LATE_REVERB_GAIN",        AL_EAXREVERB_LATE_REVERB_GAIN       },
+    { "AL_EAXREVERB_LATE_REVERB_DELAY",       AL_EAXREVERB_LATE_REVERB_DELAY      },
+    { "AL_EAXREVERB_LATE_REVERB_PAN",         AL_EAXREVERB_LATE_REVERB_PAN        },
+    { "AL_EAXREVERB_ECHO_TIME",               AL_EAXREVERB_ECHO_TIME              },
+    { "AL_EAXREVERB_ECHO_DEPTH",              AL_EAXREVERB_ECHO_DEPTH             },
+    { "AL_EAXREVERB_MODULATION_TIME",         AL_EAXREVERB_MODULATION_TIME        },
+    { "AL_EAXREVERB_MODULATION_DEPTH",        AL_EAXREVERB_MODULATION_DEPTH       },
+    { "AL_EAXREVERB_AIR_ABSORPTION_GAINHF",   AL_EAXREVERB_AIR_ABSORPTION_GAINHF  },
+    { "AL_EAXREVERB_HFREFERENCE",             AL_EAXREVERB_HFREFERENCE            },
+    { "AL_EAXREVERB_LFREFERENCE",             AL_EAXREVERB_LFREFERENCE            },
+    { "AL_EAXREVERB_ROOM_ROLLOFF_FACTOR",     AL_EAXREVERB_ROOM_ROLLOFF_FACTOR    },
+    { "AL_EAXREVERB_DECAY_HFLIMIT",           AL_EAXREVERB_DECAY_HFLIMIT          },
+
+    // Echo params
+    { "AL_ECHO_DELAY",                        AL_ECHO_DELAY                       },
+    { "AL_ECHO_LRDELAY",                      AL_ECHO_LRDELAY                     },
+    { "AL_ECHO_DAMPING",                      AL_ECHO_DAMPING                     },
+    { "AL_ECHO_FEEDBACK",                     AL_ECHO_FEEDBACK                    },
+    { "AL_ECHO_SPREAD",                       AL_ECHO_SPREAD                      },
+
+    // Ring Modulator params
+    { "AL_RING_MODULATOR_FREQUENCY",          AL_RING_MODULATOR_FREQUENCY         },
+    { "AL_RING_MODULATOR_HIGHPASS_CUTOFF",    AL_RING_MODULATOR_HIGHPASS_CUTOFF   },
+    { "AL_RING_MODULATOR_WAVEFORM",           AL_RING_MODULATOR_WAVEFORM          },
+
+
+    // Default
+    { NULL,                                   (ALenum)0                           }
+};
+
+
+
+AL_API ALboolean AL_APIENTRY alIsExtensionPresent(const ALchar *extName)
+{
+    ALboolean bIsSupported = AL_FALSE;
+    ALCcontext *pContext;
+    const char *ptr;
+    size_t len;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return AL_FALSE;
+
+    if(!extName)
+    {
+        alSetError(pContext, AL_INVALID_VALUE);
+        ProcessContext(pContext);
+        return AL_FALSE;
+    }
+
+    len = strlen(extName);
+    ptr = pContext->ExtensionList;
+    while(ptr && *ptr)
+    {
+        if(strncasecmp(ptr, extName, len) == 0 &&
+           (ptr[len] == '\0' || isspace(ptr[len])))
+        {
+            bIsSupported = AL_TRUE;
+            break;
+        }
+        if((ptr=strchr(ptr, ' ')) != NULL)
+        {
+            do {
+                ++ptr;
+            } while(isspace(*ptr));
+        }
+    }
+
+    ProcessContext(pContext);
+
+    return bIsSupported;
+}
+
+
+AL_API ALvoid* AL_APIENTRY alGetProcAddress(const ALchar *funcName)
+{
+    if(!funcName)
+        return NULL;
+    return alcGetProcAddress(NULL, funcName);
+}
+
+AL_API ALenum AL_APIENTRY alGetEnumValue(const ALchar *enumName)
+{
+    ALsizei i = 0;
+
+    while(enumeration[i].enumName &&
+          strcmp(enumeration[i].enumName, enumName) != 0)
+        i++;
+
+    return enumeration[i].value;
+}

project/jni/openal/src/OpenAL32/alFilter.c

@@ -0,0 +1,431 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "alMain.h"
+#include "alFilter.h"
+#include "alThunk.h"
+#include "alError.h"
+
+
+static void InitFilterParams(ALfilter *filter, ALenum type);
+
+#define LookupFilter(m, k) ((ALfilter*)LookupUIntMapKey(&(m), (k)))
+
+AL_API ALvoid AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters)
+{
+    ALCcontext *Context;
+    ALsizei i=0;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    if (n > 0)
+    {
+        ALCdevice *device = Context->Device;
+
+        // Check that enough memory has been allocted in the 'filters' array for n Filters
+        if (!IsBadWritePtr((void*)filters, n * sizeof(ALuint)))
+        {
+            ALenum err;
+
+            while(i < n)
+            {
+                ALfilter *filter = calloc(1, sizeof(ALfilter));
+                if(!filter)
+                {
+                    alSetError(Context, AL_OUT_OF_MEMORY);
+                    alDeleteFilters(i, filters);
+                    break;
+                }
+
+                filter->filter = ALTHUNK_ADDENTRY(filter);
+                err = InsertUIntMapEntry(&device->FilterMap, filter->filter,
+                                         filter);
+                if(err != AL_NO_ERROR)
+                {
+                    ALTHUNK_REMOVEENTRY(filter->filter);
+                    memset(filter, 0, sizeof(ALfilter));
+                    free(filter);
+
+                    alSetError(Context, err);
+                    alDeleteFilters(i, filters);
+                    break;
+                }
+
+                filters[i++] = filter->filter;
+                InitFilterParams(filter, AL_FILTER_NULL);
+            }
+        }
+    }
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alDeleteFilters(ALsizei n, ALuint *filters)
+{
+    ALCcontext *Context;
+    ALfilter *ALFilter;
+    ALsizei i;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    if (n >= 0)
+    {
+        ALCdevice *device = Context->Device;
+
+        // Check that all filters are valid
+        for (i = 0; i < n; i++)
+        {
+            if(!filters[i])
+                continue;
+
+            if(!LookupFilter(device->FilterMap, filters[i]))
+            {
+                alSetError(Context, AL_INVALID_NAME);
+                break;
+            }
+        }
+
+        if (i == n)
+        {
+            // All filters are valid
+            for (i = 0; i < n; i++)
+            {
+                // Recheck that the filter is valid, because there could be duplicated names
+                if((ALFilter=LookupFilter(device->FilterMap, filters[i])) != NULL)
+                {
+                    RemoveUIntMapKey(&device->FilterMap, ALFilter->filter);
+                    ALTHUNK_REMOVEENTRY(ALFilter->filter);
+
+                    memset(ALFilter, 0, sizeof(ALfilter));
+                    free(ALFilter);
+                }
+            }
+        }
+    }
+    else
+        alSetError(Context, AL_INVALID_VALUE);
+
+    ProcessContext(Context);
+}
+
+AL_API ALboolean AL_APIENTRY alIsFilter(ALuint filter)
+{
+    ALCcontext *Context;
+    ALboolean  result;
+
+    Context = GetContextSuspended();
+    if(!Context) return AL_FALSE;
+
+    result = ((!filter || LookupFilter(Context->Device->FilterMap, filter)) ?
+              AL_TRUE : AL_FALSE);
+
+    ProcessContext(Context);
+
+    return result;
+}
+
+AL_API ALvoid AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint iValue)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+    ALfilter   *ALFilter;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if((ALFilter=LookupFilter(Device->FilterMap, filter)) != NULL)
+    {
+        switch(param)
+        {
+        case AL_FILTER_TYPE:
+            if(iValue == AL_FILTER_NULL ||
+               iValue == AL_FILTER_LOWPASS)
+                InitFilterParams(ALFilter, iValue);
+            else
+                alSetError(Context, AL_INVALID_VALUE);
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_ENUM);
+            break;
+        }
+    }
+    else
+        alSetError(Context, AL_INVALID_NAME);
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alFilteriv(ALuint filter, ALenum param, ALint *piValues)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if(LookupFilter(Device->FilterMap, filter) != NULL)
+    {
+        switch(param)
+        {
+        case AL_FILTER_TYPE:
+            alFilteri(filter, param, piValues[0]);
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_ENUM);
+            break;
+        }
+    }
+    else
+        alSetError(Context, AL_INVALID_NAME);
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat flValue)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+    ALfilter   *ALFilter;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if((ALFilter=LookupFilter(Device->FilterMap, filter)) != NULL)
+    {
+        switch(ALFilter->type)
+        {
+        case AL_FILTER_LOWPASS:
+            switch(param)
+            {
+            case AL_LOWPASS_GAIN:
+                if(flValue >= 0.0f && flValue <= 1.0f)
+                    ALFilter->Gain = flValue;
+                else
+                    alSetError(Context, AL_INVALID_VALUE);
+                break;
+
+            case AL_LOWPASS_GAINHF:
+                if(flValue >= 0.0f && flValue <= 1.0f)
+                    ALFilter->GainHF = flValue;
+                else
+                    alSetError(Context, AL_INVALID_VALUE);
+                break;
+
+            default:
+                alSetError(Context, AL_INVALID_ENUM);
+                break;
+            }
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_ENUM);
+            break;
+        }
+    }
+    else
+        alSetError(Context, AL_INVALID_NAME);
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alFilterfv(ALuint filter, ALenum param, ALfloat *pflValues)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if(LookupFilter(Device->FilterMap, filter) != NULL)
+    {
+        switch(param)
+        {
+        default:
+            alFilterf(filter, param, pflValues[0]);
+            break;
+        }
+    }
+    else
+        alSetError(Context, AL_INVALID_NAME);
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *piValue)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+    ALfilter   *ALFilter;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if((ALFilter=LookupFilter(Device->FilterMap, filter)) != NULL)
+    {
+        switch(param)
+        {
+        case AL_FILTER_TYPE:
+            *piValue = ALFilter->type;
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_ENUM);
+            break;
+        }
+    }
+    else
+        alSetError(Context, AL_INVALID_NAME);
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *piValues)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if(LookupFilter(Device->FilterMap, filter) != NULL)
+    {
+        switch(param)
+        {
+        case AL_FILTER_TYPE:
+            alGetFilteri(filter, param, piValues);
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_ENUM);
+            break;
+        }
+    }
+    else
+        alSetError(Context, AL_INVALID_NAME);
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pflValue)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+    ALfilter   *ALFilter;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if((ALFilter=LookupFilter(Device->FilterMap, filter)) != NULL)
+    {
+        switch(ALFilter->type)
+        {
+        case AL_FILTER_LOWPASS:
+            switch(param)
+            {
+            case AL_LOWPASS_GAIN:
+                *pflValue = ALFilter->Gain;
+                break;
+
+            case AL_LOWPASS_GAINHF:
+                *pflValue = ALFilter->GainHF;
+                break;
+
+            default:
+                alSetError(Context, AL_INVALID_ENUM);
+                break;
+            }
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_ENUM);
+            break;
+        }
+    }
+    else
+        alSetError(Context, AL_INVALID_NAME);
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *pflValues)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if(LookupFilter(Device->FilterMap, filter) != NULL)
+    {
+        switch(param)
+        {
+        default:
+            alGetFilterf(filter, param, pflValues);
+            break;
+        }
+    }
+    else
+        alSetError(Context, AL_INVALID_NAME);
+
+    ProcessContext(Context);
+}
+
+
+ALvoid ReleaseALFilters(ALCdevice *device)
+{
+    ALsizei i;
+    for(i = 0;i < device->FilterMap.size;i++)
+    {
+        ALfilter *temp = device->FilterMap.array[i].value;
+        device->FilterMap.array[i].value = NULL;
+
+        // Release filter structure
+        ALTHUNK_REMOVEENTRY(temp->filter);
+        memset(temp, 0, sizeof(ALfilter));
+        free(temp);
+    }
+}
+
+
+static void InitFilterParams(ALfilter *filter, ALenum type)
+{
+    filter->type = type;
+
+    filter->Gain = 1.0;
+    filter->GainHF = 1.0;
+}

project/jni/openal/src/OpenAL32/alListener.c

@@ -0,0 +1,484 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2000 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include "alMain.h"
+#include "AL/alc.h"
+#include "alError.h"
+#include "alListener.h"
+#include "alSource.h"
+
+AL_API ALvoid AL_APIENTRY alListenerf(ALenum eParam, ALfloat flValue)
+{
+    ALCcontext *pContext;
+    ALboolean updateAll = AL_FALSE;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    switch(eParam)
+    {
+        case AL_GAIN:
+            if(flValue >= 0.0f)
+            {
+                pContext->Listener.Gain = flValue;
+                updateAll = AL_TRUE;
+            }
+            else
+                alSetError(pContext, AL_INVALID_VALUE);
+            break;
+
+        case AL_METERS_PER_UNIT:
+            if(flValue > 0.0f)
+            {
+                pContext->Listener.MetersPerUnit = flValue;
+                updateAll = AL_TRUE;
+            }
+            else
+                alSetError(pContext, AL_INVALID_VALUE);
+            break;
+
+        default:
+            alSetError(pContext, AL_INVALID_ENUM);
+            break;
+    }
+
+    // Force updating the sources for these parameters, since even head-
+    // relative sources are affected
+    if(updateAll)
+    {
+        ALsizei pos;
+        for(pos = 0;pos < pContext->SourceMap.size;pos++)
+        {
+            ALsource *source = pContext->SourceMap.array[pos].value;
+            source->NeedsUpdate = AL_TRUE;
+        }
+    }
+
+    ProcessContext(pContext);
+}
+
+
+AL_API ALvoid AL_APIENTRY alListener3f(ALenum eParam, ALfloat flValue1, ALfloat flValue2, ALfloat flValue3)
+{
+    ALCcontext *pContext;
+    ALboolean updateWorld = AL_FALSE;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    switch(eParam)
+    {
+        case AL_POSITION:
+            pContext->Listener.Position[0] = flValue1;
+            pContext->Listener.Position[1] = flValue2;
+            pContext->Listener.Position[2] = flValue3;
+            updateWorld = AL_TRUE;
+            break;
+
+        case AL_VELOCITY:
+            pContext->Listener.Velocity[0] = flValue1;
+            pContext->Listener.Velocity[1] = flValue2;
+            pContext->Listener.Velocity[2] = flValue3;
+            updateWorld = AL_TRUE;
+            break;
+
+        default:
+            alSetError(pContext, AL_INVALID_ENUM);
+            break;
+    }
+
+    if(updateWorld)
+    {
+        ALsizei pos;
+        for(pos = 0;pos < pContext->SourceMap.size;pos++)
+        {
+            ALsource *source = pContext->SourceMap.array[pos].value;
+            if(!source->bHeadRelative)
+                source->NeedsUpdate = AL_TRUE;
+        }
+    }
+
+    ProcessContext(pContext);
+}
+
+
+AL_API ALvoid AL_APIENTRY alListenerfv(ALenum eParam, const ALfloat *pflValues)
+{
+    ALCcontext *pContext;
+    ALboolean updateWorld = AL_FALSE;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    if(pflValues)
+    {
+        switch(eParam)
+        {
+            case AL_GAIN:
+            case AL_METERS_PER_UNIT:
+                alListenerf(eParam, pflValues[0]);
+                break;
+
+            case AL_POSITION:
+            case AL_VELOCITY:
+                alListener3f(eParam, pflValues[0], pflValues[1], pflValues[2]);
+                break;
+
+            case AL_ORIENTATION:
+                // AT then UP
+                pContext->Listener.Forward[0] = pflValues[0];
+                pContext->Listener.Forward[1] = pflValues[1];
+                pContext->Listener.Forward[2] = pflValues[2];
+                pContext->Listener.Up[0] = pflValues[3];
+                pContext->Listener.Up[1] = pflValues[4];
+                pContext->Listener.Up[2] = pflValues[5];
+                updateWorld = AL_TRUE;
+                break;
+
+            default:
+                alSetError(pContext, AL_INVALID_ENUM);
+                break;
+        }
+    }
+    else
+        alSetError(pContext, AL_INVALID_VALUE);
+
+    if(updateWorld)
+    {
+        ALsizei pos;
+        for(pos = 0;pos < pContext->SourceMap.size;pos++)
+        {
+            ALsource *source = pContext->SourceMap.array[pos].value;
+            if(!source->bHeadRelative)
+                source->NeedsUpdate = AL_TRUE;
+        }
+    }
+
+    ProcessContext(pContext);
+}
+
+
+AL_API ALvoid AL_APIENTRY alListeneri(ALenum eParam, ALint lValue)
+{
+    ALCcontext *pContext;
+
+    (void)lValue;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    switch(eParam)
+    {
+        default:
+            alSetError(pContext, AL_INVALID_ENUM);
+            break;
+    }
+
+    ProcessContext(pContext);
+}
+
+
+AL_API void AL_APIENTRY alListener3i(ALenum eParam, ALint lValue1, ALint lValue2, ALint lValue3)
+{
+    ALCcontext *pContext;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    switch(eParam)
+    {
+        case AL_POSITION:
+        case AL_VELOCITY:
+            alListener3f(eParam, (ALfloat)lValue1, (ALfloat)lValue2, (ALfloat)lValue3);
+            break;
+
+        default:
+            alSetError(pContext, AL_INVALID_ENUM);
+            break;
+    }
+
+    ProcessContext(pContext);
+}
+
+
+AL_API void AL_APIENTRY alListeneriv( ALenum eParam, const ALint* plValues )
+{
+    ALCcontext *pContext;
+    ALfloat flValues[6];
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    if(plValues)
+    {
+        switch(eParam)
+        {
+            case AL_POSITION:
+            case AL_VELOCITY:
+                flValues[0] = (ALfloat)plValues[0];
+                flValues[1] = (ALfloat)plValues[1];
+                flValues[2] = (ALfloat)plValues[2];
+                alListenerfv(eParam, flValues);
+                break;
+
+            case AL_ORIENTATION:
+                flValues[0] = (ALfloat)plValues[0];
+                flValues[1] = (ALfloat)plValues[1];
+                flValues[2] = (ALfloat)plValues[2];
+                flValues[3] = (ALfloat)plValues[3];
+                flValues[4] = (ALfloat)plValues[4];
+                flValues[5] = (ALfloat)plValues[5];
+                alListenerfv(eParam, flValues);
+                break;
+
+            default:
+                alSetError(pContext, AL_INVALID_ENUM);
+                break;
+        }
+    }
+    else
+        alSetError(pContext, AL_INVALID_VALUE);
+
+    ProcessContext(pContext);
+}
+
+
+AL_API ALvoid AL_APIENTRY alGetListenerf(ALenum eParam, ALfloat *pflValue)
+{
+    ALCcontext *pContext;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    if(pflValue)
+    {
+        switch(eParam)
+        {
+            case AL_GAIN:
+                *pflValue = pContext->Listener.Gain;
+                break;
+
+            case AL_METERS_PER_UNIT:
+                *pflValue = pContext->Listener.MetersPerUnit;
+                break;
+
+            default:
+                alSetError(pContext, AL_INVALID_ENUM);
+                break;
+        }
+    }
+    else
+        alSetError(pContext, AL_INVALID_VALUE);
+
+    ProcessContext(pContext);
+}
+
+
+AL_API ALvoid AL_APIENTRY alGetListener3f(ALenum eParam, ALfloat *pflValue1, ALfloat *pflValue2, ALfloat *pflValue3)
+{
+    ALCcontext *pContext;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    if(pflValue1 && pflValue2 && pflValue3)
+    {
+        switch(eParam)
+        {
+            case AL_POSITION:
+                *pflValue1 = pContext->Listener.Position[0];
+                *pflValue2 = pContext->Listener.Position[1];
+                *pflValue3 = pContext->Listener.Position[2];
+                break;
+
+            case AL_VELOCITY:
+                *pflValue1 = pContext->Listener.Velocity[0];
+                *pflValue2 = pContext->Listener.Velocity[1];
+                *pflValue3 = pContext->Listener.Velocity[2];
+                break;
+
+            default:
+                alSetError(pContext, AL_INVALID_ENUM);
+                break;
+        }
+    }
+    else
+        alSetError(pContext, AL_INVALID_VALUE);
+
+    ProcessContext(pContext);
+}
+
+
+AL_API ALvoid AL_APIENTRY alGetListenerfv(ALenum eParam, ALfloat *pflValues)
+{
+    ALCcontext *pContext;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    if(pflValues)
+    {
+        switch(eParam)
+        {
+            case AL_GAIN:
+                pflValues[0] = pContext->Listener.Gain;
+                break;
+
+            case AL_METERS_PER_UNIT:
+                pflValues[0] = pContext->Listener.MetersPerUnit;
+                break;
+
+            case AL_POSITION:
+                pflValues[0] = pContext->Listener.Position[0];
+                pflValues[1] = pContext->Listener.Position[1];
+                pflValues[2] = pContext->Listener.Position[2];
+                break;
+
+            case AL_VELOCITY:
+                pflValues[0] = pContext->Listener.Velocity[0];
+                pflValues[1] = pContext->Listener.Velocity[1];
+                pflValues[2] = pContext->Listener.Velocity[2];
+                break;
+
+            case AL_ORIENTATION:
+                // AT then UP
+                pflValues[0] = pContext->Listener.Forward[0];
+                pflValues[1] = pContext->Listener.Forward[1];
+                pflValues[2] = pContext->Listener.Forward[2];
+                pflValues[3] = pContext->Listener.Up[0];
+                pflValues[4] = pContext->Listener.Up[1];
+                pflValues[5] = pContext->Listener.Up[2];
+                break;
+
+            default:
+                alSetError(pContext, AL_INVALID_ENUM);
+                break;
+        }
+    }
+    else
+        alSetError(pContext, AL_INVALID_VALUE);
+
+    ProcessContext(pContext);
+}
+
+
+AL_API ALvoid AL_APIENTRY alGetListeneri(ALenum eParam, ALint *plValue)
+{
+    ALCcontext *pContext;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    if(plValue)
+    {
+        switch(eParam)
+        {
+            default:
+                alSetError(pContext, AL_INVALID_ENUM);
+                break;
+        }
+    }
+    else
+        alSetError(pContext, AL_INVALID_VALUE);
+
+    ProcessContext(pContext);
+}
+
+
+AL_API void AL_APIENTRY alGetListener3i(ALenum eParam, ALint *plValue1, ALint *plValue2, ALint *plValue3)
+{
+    ALCcontext *pContext;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    if(plValue1 && plValue2 && plValue3)
+    {
+        switch (eParam)
+        {
+            case AL_POSITION:
+                *plValue1 = (ALint)pContext->Listener.Position[0];
+                *plValue2 = (ALint)pContext->Listener.Position[1];
+                *plValue3 = (ALint)pContext->Listener.Position[2];
+                break;
+
+            case AL_VELOCITY:
+                *plValue1 = (ALint)pContext->Listener.Velocity[0];
+                *plValue2 = (ALint)pContext->Listener.Velocity[1];
+                *plValue3 = (ALint)pContext->Listener.Velocity[2];
+                break;
+
+            default:
+                alSetError(pContext, AL_INVALID_ENUM);
+                break;
+        }
+    }
+    else
+        alSetError(pContext, AL_INVALID_VALUE);
+
+    ProcessContext(pContext);
+}
+
+
+AL_API void AL_APIENTRY alGetListeneriv(ALenum eParam, ALint* plValues)
+{
+    ALCcontext *pContext;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    if(plValues)
+    {
+        switch(eParam)
+        {
+            case AL_POSITION:
+                plValues[0] = (ALint)pContext->Listener.Position[0];
+                plValues[1] = (ALint)pContext->Listener.Position[1];
+                plValues[2] = (ALint)pContext->Listener.Position[2];
+                break;
+
+            case AL_VELOCITY:
+                plValues[0] = (ALint)pContext->Listener.Velocity[0];
+                plValues[1] = (ALint)pContext->Listener.Velocity[1];
+                plValues[2] = (ALint)pContext->Listener.Velocity[2];
+                break;
+
+            case AL_ORIENTATION:
+                // AT then UP
+                plValues[0] = (ALint)pContext->Listener.Forward[0];
+                plValues[1] = (ALint)pContext->Listener.Forward[1];
+                plValues[2] = (ALint)pContext->Listener.Forward[2];
+                plValues[3] = (ALint)pContext->Listener.Up[0];
+                plValues[4] = (ALint)pContext->Listener.Up[1];
+                plValues[5] = (ALint)pContext->Listener.Up[2];
+                break;
+
+            default:
+                alSetError(pContext, AL_INVALID_ENUM);
+                break;
+        }
+    }
+    else
+        alSetError(pContext, AL_INVALID_VALUE);
+
+    ProcessContext(pContext);
+}

project/jni/openal/src/OpenAL32/alState.c

@@ -0,0 +1,661 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2000 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include "alMain.h"
+#include "AL/alc.h"
+#include "AL/alext.h"
+#include "alError.h"
+#include "alSource.h"
+#include "alState.h"
+#include "alDatabuffer.h"
+
+static const ALchar alVendor[] = "OpenAL Community";
+static const ALchar alVersion[] = "1.1 ALSOFT "ALSOFT_VERSION;
+static const ALchar alRenderer[] = "OpenAL Soft";
+
+// Error Messages
+static const ALchar alNoError[] = "No Error";
+static const ALchar alErrInvalidName[] = "Invalid Name";
+static const ALchar alErrInvalidEnum[] = "Invalid Enum";
+static const ALchar alErrInvalidValue[] = "Invalid Value";
+static const ALchar alErrInvalidOp[] = "Invalid Operation";
+static const ALchar alErrOutOfMemory[] = "Out of Memory";
+
+AL_API ALvoid AL_APIENTRY alEnable(ALenum capability)
+{
+    ALCcontext *Context;
+    ALboolean  updateSources = AL_FALSE;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    switch(capability)
+    {
+        case AL_SOURCE_DISTANCE_MODEL:
+            Context->SourceDistanceModel = AL_TRUE;
+            updateSources = AL_TRUE;
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_ENUM);
+            break;
+    }
+
+    if(updateSources)
+    {
+        ALsizei pos;
+        for(pos = 0;pos < Context->SourceMap.size;pos++)
+        {
+            ALsource *source = Context->SourceMap.array[pos].value;
+            source->NeedsUpdate = AL_TRUE;
+        }
+    }
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alDisable(ALenum capability)
+{
+    ALCcontext *Context;
+    ALboolean  updateSources = AL_FALSE;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    switch(capability)
+    {
+        case AL_SOURCE_DISTANCE_MODEL:
+            Context->SourceDistanceModel = AL_FALSE;
+            updateSources = AL_TRUE;
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_ENUM);
+            break;
+    }
+
+    if(updateSources)
+    {
+        ALsizei pos;
+        for(pos = 0;pos < Context->SourceMap.size;pos++)
+        {
+            ALsource *source = Context->SourceMap.array[pos].value;
+            source->NeedsUpdate = AL_TRUE;
+        }
+    }
+
+    ProcessContext(Context);
+}
+
+AL_API ALboolean AL_APIENTRY alIsEnabled(ALenum capability)
+{
+    ALCcontext *Context;
+    ALboolean value=AL_FALSE;
+
+    Context = GetContextSuspended();
+    if(!Context) return AL_FALSE;
+
+    switch(capability)
+    {
+        case AL_SOURCE_DISTANCE_MODEL:
+            value = Context->SourceDistanceModel;
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_ENUM);
+            break;
+    }
+
+    ProcessContext(Context);
+
+    return value;
+}
+
+AL_API ALboolean AL_APIENTRY alGetBoolean(ALenum pname)
+{
+    ALCcontext *Context;
+    ALboolean value=AL_FALSE;
+
+    Context = GetContextSuspended();
+    if(!Context) return AL_FALSE;
+
+    switch(pname)
+    {
+        case AL_DOPPLER_FACTOR:
+            if(Context->DopplerFactor != 0.0f)
+                value = AL_TRUE;
+            break;
+
+        case AL_DOPPLER_VELOCITY:
+            if(Context->DopplerVelocity != 0.0f)
+                value = AL_TRUE;
+            break;
+
+        case AL_DISTANCE_MODEL:
+            if(Context->DistanceModel == AL_INVERSE_DISTANCE_CLAMPED)
+                value = AL_TRUE;
+            break;
+
+        case AL_SPEED_OF_SOUND:
+            if(Context->flSpeedOfSound != 0.0f)
+                value = AL_TRUE;
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_ENUM);
+            break;
+    }
+
+    ProcessContext(Context);
+
+    return value;
+}
+
+AL_API ALdouble AL_APIENTRY alGetDouble(ALenum pname)
+{
+    ALCcontext *Context;
+    ALdouble value = 0.0;
+
+    Context = GetContextSuspended();
+    if(!Context) return 0.0;
+
+    switch(pname)
+    {
+        case AL_DOPPLER_FACTOR:
+            value = (double)Context->DopplerFactor;
+            break;
+
+        case AL_DOPPLER_VELOCITY:
+            value = (double)Context->DopplerVelocity;
+            break;
+
+        case AL_DISTANCE_MODEL:
+            value = (double)Context->DistanceModel;
+            break;
+
+        case AL_SPEED_OF_SOUND:
+            value = (double)Context->flSpeedOfSound;
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_ENUM);
+            break;
+    }
+
+    ProcessContext(Context);
+
+    return value;
+}
+
+AL_API ALfloat AL_APIENTRY alGetFloat(ALenum pname)
+{
+    ALCcontext *Context;
+    ALfloat value = 0.0f;
+
+    Context = GetContextSuspended();
+    if(!Context) return 0.0f;
+
+    switch(pname)
+    {
+        case AL_DOPPLER_FACTOR:
+            value = Context->DopplerFactor;
+            break;
+
+        case AL_DOPPLER_VELOCITY:
+            value = Context->DopplerVelocity;
+            break;
+
+        case AL_DISTANCE_MODEL:
+            value = (float)Context->DistanceModel;
+            break;
+
+        case AL_SPEED_OF_SOUND:
+            value = Context->flSpeedOfSound;
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_ENUM);
+            break;
+    }
+
+    ProcessContext(Context);
+
+    return value;
+}
+
+AL_API ALint AL_APIENTRY alGetInteger(ALenum pname)
+{
+    ALCcontext *Context;
+    ALint value = 0;
+
+    Context = GetContextSuspended();
+    if(!Context) return 0;
+
+    switch(pname)
+    {
+        case AL_DOPPLER_FACTOR:
+            value = (ALint)Context->DopplerFactor;
+            break;
+
+        case AL_DOPPLER_VELOCITY:
+            value = (ALint)Context->DopplerVelocity;
+            break;
+
+        case AL_DISTANCE_MODEL:
+            value = (ALint)Context->DistanceModel;
+            break;
+
+        case AL_SPEED_OF_SOUND:
+            value = (ALint)Context->flSpeedOfSound;
+            break;
+
+        case AL_SAMPLE_SOURCE_EXT:
+            if(Context->SampleSource)
+                value = (ALint)Context->SampleSource->databuffer;
+            else
+                value = 0;
+            break;
+
+        case AL_SAMPLE_SINK_EXT:
+            if(Context->SampleSink)
+                value = (ALint)Context->SampleSink->databuffer;
+            else
+                value = 0;
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_ENUM);
+            break;
+    }
+
+    ProcessContext(Context);
+
+    return value;
+}
+
+AL_API ALvoid AL_APIENTRY alGetBooleanv(ALenum pname,ALboolean *data)
+{
+    ALCcontext *Context;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    if(data)
+    {
+        switch(pname)
+        {
+            case AL_DOPPLER_FACTOR:
+                *data = (ALboolean)((Context->DopplerFactor != 0.0f) ? AL_TRUE : AL_FALSE);
+                break;
+
+            case AL_DOPPLER_VELOCITY:
+                *data = (ALboolean)((Context->DopplerVelocity != 0.0f) ? AL_TRUE : AL_FALSE);
+                break;
+
+            case AL_DISTANCE_MODEL:
+                *data = (ALboolean)((Context->DistanceModel == AL_INVERSE_DISTANCE_CLAMPED) ? AL_TRUE : AL_FALSE);
+                break;
+
+            case AL_SPEED_OF_SOUND:
+                *data = (ALboolean)((Context->flSpeedOfSound != 0.0f) ? AL_TRUE : AL_FALSE);
+                break;
+
+            default:
+                alSetError(Context, AL_INVALID_ENUM);
+                break;
+        }
+    }
+    else
+    {
+        // data is a NULL pointer
+        alSetError(Context, AL_INVALID_VALUE);
+    }
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetDoublev(ALenum pname,ALdouble *data)
+{
+    ALCcontext *Context;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    if(data)
+    {
+        switch(pname)
+        {
+            case AL_DOPPLER_FACTOR:
+                *data = (double)Context->DopplerFactor;
+                break;
+
+            case AL_DOPPLER_VELOCITY:
+                *data = (double)Context->DopplerVelocity;
+                break;
+
+            case AL_DISTANCE_MODEL:
+                *data = (double)Context->DistanceModel;
+                break;
+
+            case AL_SPEED_OF_SOUND:
+                *data = (double)Context->flSpeedOfSound;
+                break;
+
+            default:
+                alSetError(Context, AL_INVALID_ENUM);
+                break;
+        }
+    }
+    else
+    {
+        // data is a NULL pointer
+        alSetError(Context, AL_INVALID_VALUE);
+    }
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetFloatv(ALenum pname,ALfloat *data)
+{
+    ALCcontext *Context;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    if(data)
+    {
+        switch(pname)
+        {
+            case AL_DOPPLER_FACTOR:
+                *data = Context->DopplerFactor;
+                break;
+
+            case AL_DOPPLER_VELOCITY:
+                *data = Context->DopplerVelocity;
+                break;
+
+            case AL_DISTANCE_MODEL:
+                *data = (float)Context->DistanceModel;
+                break;
+
+            case AL_SPEED_OF_SOUND:
+                *data = Context->flSpeedOfSound;
+                break;
+
+            default:
+                alSetError(Context, AL_INVALID_ENUM);
+                break;
+        }
+    }
+    else
+    {
+        // data is a NULL pointer
+        alSetError(Context, AL_INVALID_VALUE);
+    }
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetIntegerv(ALenum pname,ALint *data)
+{
+    ALCcontext *Context;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    if(data)
+    {
+        switch(pname)
+        {
+            case AL_DOPPLER_FACTOR:
+                *data = (ALint)Context->DopplerFactor;
+                break;
+
+            case AL_DOPPLER_VELOCITY:
+                *data = (ALint)Context->DopplerVelocity;
+                break;
+
+            case AL_DISTANCE_MODEL:
+                *data = (ALint)Context->DistanceModel;
+                break;
+
+            case AL_SPEED_OF_SOUND:
+                *data = (ALint)Context->flSpeedOfSound;
+                break;
+
+            case AL_SAMPLE_SOURCE_EXT:
+                if(Context->SampleSource)
+                    *data = (ALint)Context->SampleSource->databuffer;
+                else
+                    *data = 0;
+                break;
+
+            case AL_SAMPLE_SINK_EXT:
+                if(Context->SampleSink)
+                    *data = (ALint)Context->SampleSink->databuffer;
+                else
+                    *data = 0;
+                break;
+
+            default:
+                alSetError(Context, AL_INVALID_ENUM);
+                break;
+        }
+    }
+    else
+    {
+        // data is a NULL pointer
+        alSetError(Context, AL_INVALID_VALUE);
+    }
+
+    ProcessContext(Context);
+}
+
+AL_API const ALchar* AL_APIENTRY alGetString(ALenum pname)
+{
+    const ALchar *value;
+    ALCcontext *pContext;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return NULL;
+
+    switch(pname)
+    {
+        case AL_VENDOR:
+            value=alVendor;
+            break;
+
+        case AL_VERSION:
+            value=alVersion;
+            break;
+
+        case AL_RENDERER:
+            value=alRenderer;
+            break;
+
+        case AL_EXTENSIONS:
+            value=pContext->ExtensionList;//alExtensions;
+            break;
+
+        case AL_NO_ERROR:
+            value=alNoError;
+            break;
+
+        case AL_INVALID_NAME:
+            value=alErrInvalidName;
+            break;
+
+        case AL_INVALID_ENUM:
+            value=alErrInvalidEnum;
+            break;
+
+        case AL_INVALID_VALUE:
+            value=alErrInvalidValue;
+            break;
+
+        case AL_INVALID_OPERATION:
+            value=alErrInvalidOp;
+            break;
+
+        case AL_OUT_OF_MEMORY:
+            value=alErrOutOfMemory;
+            break;
+
+        default:
+            value=NULL;
+            alSetError(pContext, AL_INVALID_ENUM);
+            break;
+    }
+
+    ProcessContext(pContext);
+
+    return value;
+}
+
+AL_API ALvoid AL_APIENTRY alDopplerFactor(ALfloat value)
+{
+    ALCcontext *Context;
+    ALboolean updateSources = AL_FALSE;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    if(value >= 0.0f)
+    {
+        Context->DopplerFactor = value;
+        updateSources = AL_TRUE;
+    }
+    else
+        alSetError(Context, AL_INVALID_VALUE);
+
+    // Force updating the sources for these parameters, since even head-
+    // relative sources are affected
+    if(updateSources)
+    {
+        ALsizei pos;
+        for(pos = 0;pos < Context->SourceMap.size;pos++)
+        {
+            ALsource *source = Context->SourceMap.array[pos].value;
+            source->NeedsUpdate = AL_TRUE;
+        }
+    }
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alDopplerVelocity(ALfloat value)
+{
+    ALCcontext *Context;
+    ALboolean updateSources = AL_FALSE;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    if(value > 0.0f)
+    {
+        Context->DopplerVelocity=value;
+        updateSources = AL_TRUE;
+    }
+    else
+        alSetError(Context, AL_INVALID_VALUE);
+
+    if(updateSources)
+    {
+        ALsizei pos;
+        for(pos = 0;pos < Context->SourceMap.size;pos++)
+        {
+            ALsource *source = Context->SourceMap.array[pos].value;
+            source->NeedsUpdate = AL_TRUE;
+        }
+    }
+
+    ProcessContext(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alSpeedOfSound(ALfloat flSpeedOfSound)
+{
+    ALCcontext *pContext;
+    ALboolean updateSources = AL_FALSE;
+
+    pContext = GetContextSuspended();
+    if(!pContext) return;
+
+    if(flSpeedOfSound > 0.0f)
+    {
+        pContext->flSpeedOfSound = flSpeedOfSound;
+        updateSources = AL_TRUE;
+    }
+    else
+        alSetError(pContext, AL_INVALID_VALUE);
+
+    if(updateSources)
+    {
+        ALsizei pos;
+        for(pos = 0;pos < pContext->SourceMap.size;pos++)
+        {
+            ALsource *source = pContext->SourceMap.array[pos].value;
+            source->NeedsUpdate = AL_TRUE;
+        }
+    }
+
+    ProcessContext(pContext);
+}
+
+AL_API ALvoid AL_APIENTRY alDistanceModel(ALenum value)
+{
+    ALCcontext *Context;
+    ALboolean updateSources = AL_FALSE;
+
+    Context = GetContextSuspended();
+    if(!Context) return;
+
+    switch(value)
+    {
+        case AL_NONE:
+        case AL_INVERSE_DISTANCE:
+        case AL_INVERSE_DISTANCE_CLAMPED:
+        case AL_LINEAR_DISTANCE:
+        case AL_LINEAR_DISTANCE_CLAMPED:
+        case AL_EXPONENT_DISTANCE:
+        case AL_EXPONENT_DISTANCE_CLAMPED:
+            Context->DistanceModel = value;
+            updateSources = !Context->SourceDistanceModel;
+            break;
+
+        default:
+            alSetError(Context, AL_INVALID_VALUE);
+            break;
+    }
+
+    if(updateSources)
+    {
+        ALsizei pos;
+        for(pos = 0;pos < Context->SourceMap.size;pos++)
+        {
+            ALsource *source = Context->SourceMap.array[pos].value;
+            source->NeedsUpdate = AL_TRUE;
+        }
+    }
+
+    ProcessContext(Context);
+}

project/jni/openal/src/OpenAL32/alThunk.c

@@ -0,0 +1,111 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+
+#include "alMain.h"
+#include "alThunk.h"
+
+typedef struct {
+    ALvoid *ptr;
+    ALboolean InUse;
+} ThunkEntry;
+
+static ThunkEntry *g_ThunkArray;
+static ALuint      g_ThunkArraySize;
+
+static CRITICAL_SECTION g_ThunkLock;
+
+void alThunkInit(void)
+{
+    InitializeCriticalSection(&g_ThunkLock);
+    g_ThunkArraySize = 1;
+    g_ThunkArray = calloc(1, g_ThunkArraySize * sizeof(ThunkEntry));
+}
+
+void alThunkExit(void)
+{
+    free(g_ThunkArray);
+    g_ThunkArray = NULL;
+    g_ThunkArraySize = 0;
+    DeleteCriticalSection(&g_ThunkLock);
+}
+
+ALuint alThunkAddEntry(ALvoid *ptr)
+{
+    ALuint index;
+
+    EnterCriticalSection(&g_ThunkLock);
+
+    for(index = 0;index < g_ThunkArraySize;index++)
+    {
+        if(g_ThunkArray[index].InUse == AL_FALSE)
+            break;
+    }
+
+    if(index == g_ThunkArraySize)
+    {
+        ThunkEntry *NewList;
+
+        NewList = realloc(g_ThunkArray, g_ThunkArraySize*2 * sizeof(ThunkEntry));
+        if(!NewList)
+        {
+            LeaveCriticalSection(&g_ThunkLock);
+            AL_PRINT("Realloc failed to increase to %u enties!\n", g_ThunkArraySize*2);
+            return 0;
+        }
+        memset(&NewList[g_ThunkArraySize], 0, g_ThunkArraySize*sizeof(ThunkEntry));
+        g_ThunkArraySize *= 2;
+        g_ThunkArray = NewList;
+    }
+
+    g_ThunkArray[index].ptr = ptr;
+    g_ThunkArray[index].InUse = AL_TRUE;
+
+    LeaveCriticalSection(&g_ThunkLock);
+
+    return index+1;
+}
+
+void alThunkRemoveEntry(ALuint index)
+{
+    EnterCriticalSection(&g_ThunkLock);
+
+    if(index > 0 && index <= g_ThunkArraySize)
+        g_ThunkArray[index-1].InUse = AL_FALSE;
+
+    LeaveCriticalSection(&g_ThunkLock);
+}
+
+ALvoid *alThunkLookupEntry(ALuint index)
+{
+    ALvoid *ptr = NULL;
+
+    EnterCriticalSection(&g_ThunkLock);
+
+    if(index > 0 && index <= g_ThunkArraySize)
+        ptr = g_ThunkArray[index-1].ptr;
+
+    LeaveCriticalSection(&g_ThunkLock);
+
+    return ptr;
+}

project/jni/openal/src/config.h

@@ -0,0 +1,82 @@
+#ifndef CONFIG_H
+#define CONFIG_H
+
+/* Define to the library version */
+#define ALSOFT_VERSION "1.0.0"
+
+/* Define if we have the PulseAudio backend */
+#define HAVE_ANDROID 1
+
+/* Define if we have dlfcn.h */
+#define HAVE_DLFCN_H 1
+
+/* Define if we have the stat function */
+#define HAVE_STAT 1
+
+/* Define if we have the powf function */
+#define HAVE_POWF
+
+/* Define if we have the sqrtf function */
+#define HAVE_SQRTF
+
+/* Define if we have the acosf function */
+#define HAVE_ACOSF
+
+/* Define if we have the atanf function */
+#define HAVE_ATANF
+
+/* Define if we have the fabsf function */
+#define HAVE_FABSF
+
+/* Define if we have the strtof function */
+#define HAVE_STRTOF
+
+/* Define if we have stdint.h */
+#define HAVE_STDINT_H
+
+/* Define if we have the __int64 type */
+#define HAVE___INT64
+
+/* Define to the size of a long int type */
+#define SIZEOF_LONG 4
+
+/* Define to the size of a long long int type */
+#define SIZEOF_LONG_LONG 8
+
+/* Define to the size of an unsigned int type */
+#define SIZEOF_UINT 4
+
+/* Define to the size of a void pointer type */
+#define SIZEOF_VOIDP 4
+
+/* Define if we have GCC's destructor attribute */
+#define HAVE_GCC_DESTRUCTOR 1
+
+/* Define if we have GCC's format attribute */
+#define HAVE_GCC_FORMAT 1
+
+/* Define if we have pthread_np.h */
+/*
+#define HAVE_PTHREAD_NP_H
+*/
+
+/* Define if we have float.h */
+/*
+#define HAVE_FLOAT_H
+*/
+
+/* Define if we have fenv.h */
+#define HAVE_FENV_H 1
+
+/* Define if we have fesetround() */
+#define HAVE_FESETROUND 1
+
+/* Define if we have _controlfp() */
+/*
+#define HAVE__CONTROLFP
+*/
+
+/* Define if we have pthread_setschedparam() */
+#define HAVE_PTHREAD_SETSCHEDPARAM 1
+
+#endif