rlm@0: /**
rlm@0:  * OpenAL cross platform audio library
rlm@0:  * Copyright (C) 1999-2007 by authors.
rlm@0:  * This library is free software; you can redistribute it and/or
rlm@0:  *  modify it under the terms of the GNU Library General Public
rlm@0:  *  License as published by the Free Software Foundation; either
rlm@0:  *  version 2 of the License, or (at your option) any later version.
rlm@0:  *
rlm@0:  * This library is distributed in the hope that it will be useful,
rlm@0:  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
rlm@0:  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
rlm@0:  *  Library General Public License for more details.
rlm@0:  *
rlm@0:  * You should have received a copy of the GNU Library General Public
rlm@0:  *  License along with this library; if not, write to the
rlm@0:  *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
rlm@0:  *  Boston, MA  02111-1307, USA.
rlm@0:  * Or go to http://www.gnu.org/copyleft/lgpl.html
rlm@0:  */
rlm@0: 
rlm@0: #include "config.h"
rlm@0: 
rlm@0: #include <math.h>
rlm@0: #include <stdlib.h>
rlm@0: #include <stdio.h>
rlm@0: #include <memory.h>
rlm@0: #include <ctype.h>
rlm@0: 
rlm@0: #include "alMain.h"
rlm@0: #include "alSource.h"
rlm@0: #include "AL/al.h"
rlm@0: #include "AL/alc.h"
rlm@0: #include "alThunk.h"
rlm@0: #include "alSource.h"
rlm@0: #include "alBuffer.h"
rlm@0: #include "alAuxEffectSlot.h"
rlm@0: #include "bs2b.h"
rlm@0: #include "alu.h"
rlm@0: 
rlm@0: // RLM: try to include the file here.
rlm@0: 
rlm@0: 
rlm@0: 
rlm@0: #define EmptyFuncs { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
rlm@0: static struct BackendInfo BackendList[] = {
rlm@0:     { "null", alc_null_init, alc_null_deinit, alc_null_probe, EmptyFuncs },
rlm@0:     { "send", alc_send_init, alc_send_deinit, alc_send_probe, EmptyFuncs },
rlm@0:     // this entry is so that the list is terminated by a "null" object,
rlm@0:     // and helps things to tell when they've reached the end of the list.
rlm@0:     { NULL, NULL, NULL, NULL, EmptyFuncs }
rlm@0: };
rlm@0: static struct BackendInfo BackendLoopback = {
rlm@0:     "loopback", alc_loopback_init, alc_loopback_deinit, alc_loopback_probe, EmptyFuncs
rlm@0: };
rlm@0: #undef EmptyFuncs
rlm@0: 
rlm@0: static struct BackendInfo PlaybackBackend;
rlm@0: static struct BackendInfo CaptureBackend;
rlm@0: 
rlm@0: ///////////////////////////////////////////////////////
rlm@0: // STRING and EXTENSIONS
rlm@0: 
rlm@0: typedef struct ALCfunction {
rlm@0:     const ALCchar *funcName;
rlm@0:     ALCvoid *address;
rlm@0: } ALCfunction;
rlm@0: 
rlm@0: typedef struct ALCenums {
rlm@0:     const ALCchar *enumName;
rlm@0:     ALCenum value;
rlm@0: } ALCenums;
rlm@0: 
rlm@0: 
rlm@0: static const ALCfunction alcFunctions[] = {
rlm@0:     { "alcCreateContext",           (ALCvoid *) alcCreateContext         },
rlm@0:     { "alcMakeContextCurrent",      (ALCvoid *) alcMakeContextCurrent    },
rlm@0:     { "alcProcessContext",          (ALCvoid *) alcProcessContext        },
rlm@0:     { "alcSuspendContext",          (ALCvoid *) alcSuspendContext        },
rlm@0:     { "alcDestroyContext",          (ALCvoid *) alcDestroyContext        },
rlm@0:     { "alcGetCurrentContext",       (ALCvoid *) alcGetCurrentContext     },
rlm@0:     { "alcGetContextsDevice",       (ALCvoid *) alcGetContextsDevice     },
rlm@0:     { "alcOpenDevice",              (ALCvoid *) alcOpenDevice            },
rlm@0:     { "alcCloseDevice",             (ALCvoid *) alcCloseDevice           },
rlm@0:     { "alcGetError",                (ALCvoid *) alcGetError              },
rlm@0:     { "alcIsExtensionPresent",      (ALCvoid *) alcIsExtensionPresent    },
rlm@0:     { "alcGetProcAddress",          (ALCvoid *) alcGetProcAddress        },
rlm@0:     { "alcGetEnumValue",            (ALCvoid *) alcGetEnumValue          },
rlm@0:     { "alcGetString",               (ALCvoid *) alcGetString             },
rlm@0:     { "alcGetIntegerv",             (ALCvoid *) alcGetIntegerv           },
rlm@0:     { "alcCaptureOpenDevice",       (ALCvoid *) alcCaptureOpenDevice     },
rlm@0:     { "alcCaptureCloseDevice",      (ALCvoid *) alcCaptureCloseDevice    },
rlm@0:     { "alcCaptureStart",            (ALCvoid *) alcCaptureStart          },
rlm@0:     { "alcCaptureStop",             (ALCvoid *) alcCaptureStop           },
rlm@0:     { "alcCaptureSamples",          (ALCvoid *) alcCaptureSamples        },
rlm@0: 
rlm@0:     { "alcSetThreadContext",        (ALCvoid *) alcSetThreadContext      },
rlm@0:     { "alcGetThreadContext",        (ALCvoid *) alcGetThreadContext      },
rlm@0: 
rlm@0:     { "alcLoopbackOpenDeviceSOFT",  (ALCvoid *) alcLoopbackOpenDeviceSOFT},
rlm@0:     { "alcIsRenderFormatSupportedSOFT",(ALCvoid *) alcIsRenderFormatSupportedSOFT},
rlm@0:     { "alcRenderSamplesSOFT",       (ALCvoid *) alcRenderSamplesSOFT         },
rlm@0: 
rlm@0:     { "alEnable",                   (ALCvoid *) alEnable                 },
rlm@0:     { "alDisable",                  (ALCvoid *) alDisable                },
rlm@0:     { "alIsEnabled",                (ALCvoid *) alIsEnabled              },
rlm@0:     { "alGetString",                (ALCvoid *) alGetString              },
rlm@0:     { "alGetBooleanv",              (ALCvoid *) alGetBooleanv            },
rlm@0:     { "alGetIntegerv",              (ALCvoid *) alGetIntegerv            },
rlm@0:     { "alGetFloatv",                (ALCvoid *) alGetFloatv              },
rlm@0:     { "alGetDoublev",               (ALCvoid *) alGetDoublev             },
rlm@0:     { "alGetBoolean",               (ALCvoid *) alGetBoolean             },
rlm@0:     { "alGetInteger",               (ALCvoid *) alGetInteger             },
rlm@0:     { "alGetFloat",                 (ALCvoid *) alGetFloat               },
rlm@0:     { "alGetDouble",                (ALCvoid *) alGetDouble              },
rlm@0:     { "alGetError",                 (ALCvoid *) alGetError               },
rlm@0:     { "alIsExtensionPresent",       (ALCvoid *) alIsExtensionPresent     },
rlm@0:     { "alGetProcAddress",           (ALCvoid *) alGetProcAddress         },
rlm@0:     { "alGetEnumValue",             (ALCvoid *) alGetEnumValue           },
rlm@0:     { "alListenerf",                (ALCvoid *) alListenerf              },
rlm@0:     { "alListener3f",               (ALCvoid *) alListener3f             },
rlm@0:     { "alListenerfv",               (ALCvoid *) alListenerfv             },
rlm@0:     { "alListeneri",                (ALCvoid *) alListeneri              },
rlm@0:     { "alListener3i",               (ALCvoid *) alListener3i             },
rlm@0:     { "alListeneriv",               (ALCvoid *) alListeneriv             },
rlm@0:     { "alGetListenerf",             (ALCvoid *) alGetListenerf           },
rlm@0:     { "alGetListener3f",            (ALCvoid *) alGetListener3f          },
rlm@0:     { "alGetListenerfv",            (ALCvoid *) alGetListenerfv          },
rlm@0:     { "alGetListeneri",             (ALCvoid *) alGetListeneri           },
rlm@0:     { "alGetListener3i",            (ALCvoid *) alGetListener3i          },
rlm@0:     { "alGetListeneriv",            (ALCvoid *) alGetListeneriv          },
rlm@0:     { "alGenSources",               (ALCvoid *) alGenSources             },
rlm@0:     { "alDeleteSources",            (ALCvoid *) alDeleteSources          },
rlm@0:     { "alIsSource",                 (ALCvoid *) alIsSource               },
rlm@0:     { "alSourcef",                  (ALCvoid *) alSourcef                },
rlm@0:     { "alSource3f",                 (ALCvoid *) alSource3f               },
rlm@0:     { "alSourcefv",                 (ALCvoid *) alSourcefv               },
rlm@0:     { "alSourcei",                  (ALCvoid *) alSourcei                },
rlm@0:     { "alSource3i",                 (ALCvoid *) alSource3i               },
rlm@0:     { "alSourceiv",                 (ALCvoid *) alSourceiv               },
rlm@0:     { "alGetSourcef",               (ALCvoid *) alGetSourcef             },
rlm@0:     { "alGetSource3f",              (ALCvoid *) alGetSource3f            },
rlm@0:     { "alGetSourcefv",              (ALCvoid *) alGetSourcefv            },
rlm@0:     { "alGetSourcei",               (ALCvoid *) alGetSourcei             },
rlm@0:     { "alGetSource3i",              (ALCvoid *) alGetSource3i            },
rlm@0:     { "alGetSourceiv",              (ALCvoid *) alGetSourceiv            },
rlm@0:     { "alSourcePlayv",              (ALCvoid *) alSourcePlayv            },
rlm@0:     { "alSourceStopv",              (ALCvoid *) alSourceStopv            },
rlm@0:     { "alSourceRewindv",            (ALCvoid *) alSourceRewindv          },
rlm@0:     { "alSourcePausev",             (ALCvoid *) alSourcePausev           },
rlm@0:     { "alSourcePlay",               (ALCvoid *) alSourcePlay             },
rlm@0:     { "alSourceStop",               (ALCvoid *) alSourceStop             },
rlm@0:     { "alSourceRewind",             (ALCvoid *) alSourceRewind           },
rlm@0:     { "alSourcePause",              (ALCvoid *) alSourcePause            },
rlm@0:     { "alSourceQueueBuffers",       (ALCvoid *) alSourceQueueBuffers     },
rlm@0:     { "alSourceUnqueueBuffers",     (ALCvoid *) alSourceUnqueueBuffers   },
rlm@0:     { "alGenBuffers",               (ALCvoid *) alGenBuffers             },
rlm@0:     { "alDeleteBuffers",            (ALCvoid *) alDeleteBuffers          },
rlm@0:     { "alIsBuffer",                 (ALCvoid *) alIsBuffer               },
rlm@0:     { "alBufferData",               (ALCvoid *) alBufferData             },
rlm@0:     { "alBufferf",                  (ALCvoid *) alBufferf                },
rlm@0:     { "alBuffer3f",                 (ALCvoid *) alBuffer3f               },
rlm@0:     { "alBufferfv",                 (ALCvoid *) alBufferfv               },
rlm@0:     { "alBufferi",                  (ALCvoid *) alBufferi                },
rlm@0:     { "alBuffer3i",                 (ALCvoid *) alBuffer3i               },
rlm@0:     { "alBufferiv",                 (ALCvoid *) alBufferiv               },
rlm@0:     { "alGetBufferf",               (ALCvoid *) alGetBufferf             },
rlm@0:     { "alGetBuffer3f",              (ALCvoid *) alGetBuffer3f            },
rlm@0:     { "alGetBufferfv",              (ALCvoid *) alGetBufferfv            },
rlm@0:     { "alGetBufferi",               (ALCvoid *) alGetBufferi             },
rlm@0:     { "alGetBuffer3i",              (ALCvoid *) alGetBuffer3i            },
rlm@0:     { "alGetBufferiv",              (ALCvoid *) alGetBufferiv            },
rlm@0:     { "alDopplerFactor",            (ALCvoid *) alDopplerFactor          },
rlm@0:     { "alDopplerVelocity",          (ALCvoid *) alDopplerVelocity        },
rlm@0:     { "alSpeedOfSound",             (ALCvoid *) alSpeedOfSound           },
rlm@0:     { "alDistanceModel",            (ALCvoid *) alDistanceModel          },
rlm@0: 
rlm@0:     { "alGenFilters",               (ALCvoid *) alGenFilters             },
rlm@0:     { "alDeleteFilters",            (ALCvoid *) alDeleteFilters          },
rlm@0:     { "alIsFilter",                 (ALCvoid *) alIsFilter               },
rlm@0:     { "alFilteri",                  (ALCvoid *) alFilteri                },
rlm@0:     { "alFilteriv",                 (ALCvoid *) alFilteriv               },
rlm@0:     { "alFilterf",                  (ALCvoid *) alFilterf                },
rlm@0:     { "alFilterfv",                 (ALCvoid *) alFilterfv               },
rlm@0:     { "alGetFilteri",               (ALCvoid *) alGetFilteri             },
rlm@0:     { "alGetFilteriv",              (ALCvoid *) alGetFilteriv            },
rlm@0:     { "alGetFilterf",               (ALCvoid *) alGetFilterf             },
rlm@0:     { "alGetFilterfv",              (ALCvoid *) alGetFilterfv            },
rlm@0:     { "alGenEffects",               (ALCvoid *) alGenEffects             },
rlm@0:     { "alDeleteEffects",            (ALCvoid *) alDeleteEffects          },
rlm@0:     { "alIsEffect",                 (ALCvoid *) alIsEffect               },
rlm@0:     { "alEffecti",                  (ALCvoid *) alEffecti                },
rlm@0:     { "alEffectiv",                 (ALCvoid *) alEffectiv               },
rlm@0:     { "alEffectf",                  (ALCvoid *) alEffectf                },
rlm@0:     { "alEffectfv",                 (ALCvoid *) alEffectfv               },
rlm@0:     { "alGetEffecti",               (ALCvoid *) alGetEffecti             },
rlm@0:     { "alGetEffectiv",              (ALCvoid *) alGetEffectiv            },
rlm@0:     { "alGetEffectf",               (ALCvoid *) alGetEffectf             },
rlm@0:     { "alGetEffectfv",              (ALCvoid *) alGetEffectfv            },
rlm@0:     { "alGenAuxiliaryEffectSlots",  (ALCvoid *) alGenAuxiliaryEffectSlots},
rlm@0:     { "alDeleteAuxiliaryEffectSlots",(ALCvoid *) alDeleteAuxiliaryEffectSlots},
rlm@0:     { "alIsAuxiliaryEffectSlot",    (ALCvoid *) alIsAuxiliaryEffectSlot  },
rlm@0:     { "alAuxiliaryEffectSloti",     (ALCvoid *) alAuxiliaryEffectSloti   },
rlm@0:     { "alAuxiliaryEffectSlotiv",    (ALCvoid *) alAuxiliaryEffectSlotiv  },
rlm@0:     { "alAuxiliaryEffectSlotf",     (ALCvoid *) alAuxiliaryEffectSlotf   },
rlm@0:     { "alAuxiliaryEffectSlotfv",    (ALCvoid *) alAuxiliaryEffectSlotfv  },
rlm@0:     { "alGetAuxiliaryEffectSloti",  (ALCvoid *) alGetAuxiliaryEffectSloti},
rlm@0:     { "alGetAuxiliaryEffectSlotiv", (ALCvoid *) alGetAuxiliaryEffectSlotiv},
rlm@0:     { "alGetAuxiliaryEffectSlotf",  (ALCvoid *) alGetAuxiliaryEffectSlotf},
rlm@0:     { "alGetAuxiliaryEffectSlotfv", (ALCvoid *) alGetAuxiliaryEffectSlotfv},
rlm@0: 
rlm@0:     { "alBufferSubDataSOFT",        (ALCvoid *) alBufferSubDataSOFT      },
rlm@0: 
rlm@0:     { "alBufferSamplesSOFT",        (ALCvoid *) alBufferSamplesSOFT      },
rlm@0:     { "alBufferSubSamplesSOFT",     (ALCvoid *) alBufferSubSamplesSOFT   },
rlm@0:     { "alGetBufferSamplesSOFT",     (ALCvoid *) alGetBufferSamplesSOFT   },
rlm@0:     { "alIsBufferFormatSupportedSOFT",(ALCvoid *) alIsBufferFormatSupportedSOFT},
rlm@0: 
rlm@0:     { "alDeferUpdatesSOFT",         (ALCvoid *) alDeferUpdatesSOFT       },
rlm@0:     { "alProcessUpdatesSOFT",       (ALCvoid *) alProcessUpdatesSOFT     },
rlm@0: 
rlm@0:     { NULL,                         (ALCvoid *) NULL                     }
rlm@0: };
rlm@0: 
rlm@0: static const ALCenums enumeration[] = {
rlm@0:     // Types
rlm@0:     { "ALC_INVALID",                          ALC_INVALID                         },
rlm@0:     { "ALC_FALSE",                            ALC_FALSE                           },
rlm@0:     { "ALC_TRUE",                             ALC_TRUE                            },
rlm@0: 
rlm@0:     // ALC Properties
rlm@0:     { "ALC_MAJOR_VERSION",                    ALC_MAJOR_VERSION                   },
rlm@0:     { "ALC_MINOR_VERSION",                    ALC_MINOR_VERSION                   },
rlm@0:     { "ALC_ATTRIBUTES_SIZE",                  ALC_ATTRIBUTES_SIZE                 },
rlm@0:     { "ALC_ALL_ATTRIBUTES",                   ALC_ALL_ATTRIBUTES                  },
rlm@0:     { "ALC_DEFAULT_DEVICE_SPECIFIER",         ALC_DEFAULT_DEVICE_SPECIFIER        },
rlm@0:     { "ALC_DEVICE_SPECIFIER",                 ALC_DEVICE_SPECIFIER                },
rlm@0:     { "ALC_ALL_DEVICES_SPECIFIER",            ALC_ALL_DEVICES_SPECIFIER           },
rlm@0:     { "ALC_DEFAULT_ALL_DEVICES_SPECIFIER",    ALC_DEFAULT_ALL_DEVICES_SPECIFIER   },
rlm@0:     { "ALC_EXTENSIONS",                       ALC_EXTENSIONS                      },
rlm@0:     { "ALC_FREQUENCY",                        ALC_FREQUENCY                       },
rlm@0:     { "ALC_REFRESH",                          ALC_REFRESH                         },
rlm@0:     { "ALC_SYNC",                             ALC_SYNC                            },
rlm@0:     { "ALC_MONO_SOURCES",                     ALC_MONO_SOURCES                    },
rlm@0:     { "ALC_STEREO_SOURCES",                   ALC_STEREO_SOURCES                  },
rlm@0:     { "ALC_CAPTURE_DEVICE_SPECIFIER",         ALC_CAPTURE_DEVICE_SPECIFIER        },
rlm@0:     { "ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER", ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER},
rlm@0:     { "ALC_CAPTURE_SAMPLES",                  ALC_CAPTURE_SAMPLES                 },
rlm@0:     { "ALC_CONNECTED",                        ALC_CONNECTED                       },
rlm@0: 
rlm@0:     // EFX Properties
rlm@0:     { "ALC_EFX_MAJOR_VERSION",                ALC_EFX_MAJOR_VERSION               },
rlm@0:     { "ALC_EFX_MINOR_VERSION",                ALC_EFX_MINOR_VERSION               },
rlm@0:     { "ALC_MAX_AUXILIARY_SENDS",              ALC_MAX_AUXILIARY_SENDS             },
rlm@0: 
rlm@0:     // Loopback device Properties
rlm@0:     { "ALC_FORMAT_CHANNELS_SOFT",             ALC_FORMAT_CHANNELS_SOFT            },
rlm@0:     { "ALC_FORMAT_TYPE_SOFT",                 ALC_FORMAT_TYPE_SOFT                },
rlm@0: 
rlm@0:     // Buffer Channel Configurations
rlm@0:     { "ALC_MONO",                             ALC_MONO                            },
rlm@0:     { "ALC_STEREO",                           ALC_STEREO                          },
rlm@0:     { "ALC_QUAD",                             ALC_QUAD                            },
rlm@0:     { "ALC_5POINT1",                          ALC_5POINT1                         },
rlm@0:     { "ALC_6POINT1",                          ALC_6POINT1                         },
rlm@0:     { "ALC_7POINT1",                          ALC_7POINT1                         },
rlm@0: 
rlm@0:     // Buffer Sample Types
rlm@0:     { "ALC_BYTE",                             ALC_BYTE                            },
rlm@0:     { "ALC_UNSIGNED_BYTE",                    ALC_UNSIGNED_BYTE                   },
rlm@0:     { "ALC_SHORT",                            ALC_SHORT                           },
rlm@0:     { "ALC_UNSIGNED_SHORT",                   ALC_UNSIGNED_SHORT                  },
rlm@0:     { "ALC_INT",                              ALC_INT                             },
rlm@0:     { "ALC_UNSIGNED_INT",                     ALC_UNSIGNED_INT                    },
rlm@0:     { "ALC_FLOAT",                            ALC_FLOAT                           },
rlm@0: 
rlm@0:     // ALC Error Message
rlm@0:     { "ALC_NO_ERROR",                         ALC_NO_ERROR                        },
rlm@0:     { "ALC_INVALID_DEVICE",                   ALC_INVALID_DEVICE                  },
rlm@0:     { "ALC_INVALID_CONTEXT",                  ALC_INVALID_CONTEXT                 },
rlm@0:     { "ALC_INVALID_ENUM",                     ALC_INVALID_ENUM                    },
rlm@0:     { "ALC_INVALID_VALUE",                    ALC_INVALID_VALUE                   },
rlm@0:     { "ALC_OUT_OF_MEMORY",                    ALC_OUT_OF_MEMORY                   },
rlm@0: 
rlm@0:     { NULL,                                   (ALCenum)0 }
rlm@0: };
rlm@0: // Error strings
rlm@0: static const ALCchar alcNoError[] = "No Error";
rlm@0: static const ALCchar alcErrInvalidDevice[] = "Invalid Device";
rlm@0: static const ALCchar alcErrInvalidContext[] = "Invalid Context";
rlm@0: static const ALCchar alcErrInvalidEnum[] = "Invalid Enum";
rlm@0: static const ALCchar alcErrInvalidValue[] = "Invalid Value";
rlm@0: static const ALCchar alcErrOutOfMemory[] = "Out of Memory";
rlm@0: 
rlm@0: /* Device lists. Sizes only include the first ending null character, not the
rlm@0:  * second */
rlm@0: static ALCchar *alcDeviceList;
rlm@0: static size_t alcDeviceListSize;
rlm@0: static ALCchar *alcAllDeviceList;
rlm@0: static size_t alcAllDeviceListSize;
rlm@0: static ALCchar *alcCaptureDeviceList;
rlm@0: static size_t alcCaptureDeviceListSize;
rlm@0: /* Default is always the first in the list */
rlm@0: static ALCchar *alcDefaultDeviceSpecifier;
rlm@0: static ALCchar *alcDefaultAllDeviceSpecifier;
rlm@0: static ALCchar *alcCaptureDefaultDeviceSpecifier;
rlm@0: 
rlm@0: 
rlm@0: static const ALCchar alcNoDeviceExtList[] =
rlm@0:     "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "
rlm@0:     "ALC_EXT_thread_local_context ALC_SOFTX_loopback_device";
rlm@0: static const ALCchar alcExtensionList[] =
rlm@0:     "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "
rlm@0:     "ALC_EXT_DEDICATED ALC_EXT_disconnect ALC_EXT_EFX "
rlm@0:     "ALC_EXT_thread_local_context ALC_SOFTX_loopback_device";
rlm@0: static const ALCint alcMajorVersion = 1;
rlm@0: static const ALCint alcMinorVersion = 1;
rlm@0: 
rlm@0: static const ALCint alcEFXMajorVersion = 1;
rlm@0: static const ALCint alcEFXMinorVersion = 0;
rlm@0: 
rlm@0: ///////////////////////////////////////////////////////
rlm@0: 
rlm@0: 
rlm@0: ///////////////////////////////////////////////////////
rlm@0: // Global Variables
rlm@0: 
rlm@0: static CRITICAL_SECTION ListLock;
rlm@0: 
rlm@0: /* Device List */
rlm@0: static ALCdevice *g_pDeviceList = NULL;
rlm@0: static ALCuint    g_ulDeviceCount = 0;
rlm@0: 
rlm@0: // Context List
rlm@0: static ALCcontext *g_pContextList = NULL;
rlm@0: static ALCuint     g_ulContextCount = 0;
rlm@0: 
rlm@0: // Thread-local current context
rlm@0: static tls_type LocalContext;
rlm@0: // Process-wide current context
rlm@0: static ALCcontext *GlobalContext;
rlm@0: 
rlm@0: // Context Error
rlm@0: static ALCenum g_eLastNullDeviceError = ALC_NO_ERROR;
rlm@0: 
rlm@0: // Default context extensions
rlm@0: static const ALchar alExtList[] =
rlm@0:     "AL_EXT_DOUBLE AL_EXT_EXPONENT_DISTANCE AL_EXT_FLOAT32 AL_EXT_IMA4 "
rlm@0:     "AL_EXT_LINEAR_DISTANCE AL_EXT_MCFORMATS AL_EXT_MULAW "
rlm@0:     "AL_EXT_MULAW_MCFORMATS AL_EXT_OFFSET AL_EXT_source_distance_model "
rlm@0:     "AL_LOKI_quadriphonic AL_SOFTX_buffer_samples AL_SOFT_buffer_sub_data "
rlm@0:     "AL_SOFTX_deferred_updates AL_SOFT_loop_points "
rlm@0:     "AL_SOFTX_non_virtual_channels";
rlm@0: 
rlm@0: // Mixing Priority Level
rlm@0: ALint RTPrioLevel;
rlm@0: 
rlm@0: // Output Log File
rlm@0: FILE *LogFile;
rlm@0: 
rlm@0: // Output Log Level
rlm@0: #ifdef _DEBUG
rlm@0: enum LogLevel LogLevel = LogWarning;
rlm@0: #else
rlm@0: enum LogLevel LogLevel = LogError;
rlm@0: #endif
rlm@0: 
rlm@0: // Cone scalar
rlm@0: ALdouble ConeScale = 0.5;
rlm@0: 
rlm@0: // Localized Z scalar for mono sources
rlm@0: ALdouble ZScale = 1.0;
rlm@0: 
rlm@0: /* One-time configuration init control */
rlm@0: static pthread_once_t alc_config_once = PTHREAD_ONCE_INIT;
rlm@0: 
rlm@0: ///////////////////////////////////////////////////////
rlm@0: 
rlm@0: 
rlm@0: ///////////////////////////////////////////////////////
rlm@0: // ALC Related helper functions
rlm@0: static void ReleaseALC(ALCboolean doclose);
rlm@0: 
rlm@0: static void alc_initconfig(void);
rlm@0: #define DO_INITCONFIG() pthread_once(&alc_config_once, alc_initconfig)
rlm@0: 
rlm@0: #if defined(_WIN32)
rlm@0: static void alc_init(void);
rlm@0: static void alc_deinit(void);
rlm@0: static void alc_deinit_safe(void);
rlm@0: 
rlm@0: #ifndef AL_LIBTYPE_STATIC
rlm@0: BOOL APIENTRY DllMain(HANDLE hModule,DWORD ul_reason_for_call,LPVOID lpReserved)
rlm@0: {
rlm@0:     // Perform actions based on the reason for calling.
rlm@0:     switch(ul_reason_for_call)
rlm@0:     {
rlm@0:         case DLL_PROCESS_ATTACH:
rlm@0:             DisableThreadLibraryCalls(hModule);
rlm@0:             alc_init();
rlm@0:             break;
rlm@0: 
rlm@0:         case DLL_PROCESS_DETACH:
rlm@0:             if(!lpReserved)
rlm@0:                 alc_deinit();
rlm@0:             else
rlm@0:                 alc_deinit_safe();
rlm@0:             break;
rlm@0:     }
rlm@0:     return TRUE;
rlm@0: }
rlm@0: #elif defined(_MSC_VER)
rlm@0: #pragma section(".CRT$XCU",read)
rlm@0: static void alc_constructor(void);
rlm@0: static void alc_destructor(void);
rlm@0: __declspec(allocate(".CRT$XCU")) void (__cdecl* alc_constructor_)(void) = alc_constructor;
rlm@0: 
rlm@0: static void alc_constructor(void)
rlm@0: {
rlm@0:     atexit(alc_destructor);
rlm@0:     alc_init();
rlm@0: }
rlm@0: 
rlm@0: static void alc_destructor(void)
rlm@0: {
rlm@0:     alc_deinit();
rlm@0: }
rlm@0: #elif defined(HAVE_GCC_DESTRUCTOR)
rlm@0: static void alc_init(void) __attribute__((constructor));
rlm@0: static void alc_deinit(void) __attribute__((destructor));
rlm@0: #else
rlm@0: #error "No static initialization available on this platform!"
rlm@0: #endif
rlm@0: #elif defined(HAVE_GCC_DESTRUCTOR)
rlm@0: static void alc_init(void) __attribute__((constructor));
rlm@0: static void alc_deinit(void) __attribute__((destructor));
rlm@0: #else
rlm@0: #error "No global initialization available on this platform!"
rlm@0: #endif
rlm@0: 
rlm@0: static void alc_init(void)
rlm@0: {
rlm@0:     const char *str;
rlm@0: 
rlm@0:     LogFile = stderr;
rlm@0: 
rlm@0:     str = getenv("__ALSOFT_HALF_ANGLE_CONES");
rlm@0:     if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
rlm@0:         ConeScale = 1.0;
rlm@0: 
rlm@0:     str = getenv("__ALSOFT_REVERSE_Z");
rlm@0:     if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
rlm@0:         ZScale = -1.0;
rlm@0: 
rlm@0:     tls_create(&LocalContext);
rlm@0:     InitializeCriticalSection(&ListLock);
rlm@0:     ThunkInit();
rlm@0: }
rlm@0: 
rlm@0: static void alc_deinit_safe(void)
rlm@0: {
rlm@0:     ReleaseALC(ALC_FALSE);
rlm@0: 
rlm@0:     FreeALConfig();
rlm@0: 
rlm@0:     ThunkExit();
rlm@0:     DeleteCriticalSection(&ListLock);
rlm@0:     tls_delete(LocalContext);
rlm@0: 
rlm@0:     if(LogFile != stderr)
rlm@0:         fclose(LogFile);
rlm@0:     LogFile = NULL;
rlm@0: }
rlm@0: 
rlm@0: static void alc_deinit(void)
rlm@0: {
rlm@0:     int i;
rlm@0: 
rlm@0:     ReleaseALC(ALC_TRUE);
rlm@0: 
rlm@0:     memset(&PlaybackBackend, 0, sizeof(PlaybackBackend));
rlm@0:     memset(&CaptureBackend, 0, sizeof(CaptureBackend));
rlm@0: 
rlm@0:     for(i = 0;BackendList[i].Deinit;i++)
rlm@0:         BackendList[i].Deinit();
rlm@0:     BackendLoopback.Deinit();
rlm@0: 
rlm@0:     alc_deinit_safe();
rlm@0: }
rlm@0: 
rlm@0: static void alc_initconfig(void)
rlm@0: {
rlm@0:   printf("OPENAL-AURELLEM: alc_init_config!!\n");
rlm@0:     const char *devs, *str;
rlm@0:     int i, n;
rlm@0: 
rlm@0:     str = getenv("ALSOFT_LOGLEVEL");
rlm@0:     if(str)
rlm@0:     {
rlm@0:         long lvl = strtol(str, NULL, 0);
rlm@0:         if(lvl >= NoLog && lvl <= LogTrace)
rlm@0:             LogLevel = lvl;
rlm@0:     }
rlm@0: 
rlm@0:     str = getenv("ALSOFT_LOGFILE");
rlm@0:     if(str && str[0])
rlm@0:     {
rlm@0:         FILE *logfile = fopen(str, "wat");
rlm@0:         if(logfile) LogFile = logfile;
rlm@0:         else ERR("Failed to open log file '%s'\n", str);
rlm@0:     }
rlm@0: 
rlm@0:     ReadALConfig();
rlm@0: 
rlm@0:     InitHrtf();
rlm@0: 
rlm@0: #ifdef _WIN32
rlm@0:     RTPrioLevel = GetConfigValueInt(NULL, "rt-prio", 1);
rlm@0: #else
rlm@0:     RTPrioLevel = GetConfigValueInt(NULL, "rt-prio", 0);
rlm@0: #endif
rlm@0: 
rlm@0:     DefaultResampler = GetConfigValueInt(NULL, "resampler", RESAMPLER_DEFAULT);
rlm@0:     if(DefaultResampler >= RESAMPLER_MAX || DefaultResampler <= RESAMPLER_MIN)
rlm@0:         DefaultResampler = RESAMPLER_DEFAULT;
rlm@0: 
rlm@0:     ReverbBoost *= aluPow(10.0f, GetConfigValueFloat("reverb", "boost", 0.0f) /
rlm@0:                                  20.0f);
rlm@0:     EmulateEAXReverb = GetConfigValueBool("reverb", "emulate-eax", AL_FALSE);
rlm@0: 
rlm@6:     // RLM: This was previously taken from the config file
rlm@6:     // where the user had their choice of backend
rlm@6:     // for this special version of open-al the option is 
rlm@6:     // disabled since there is only the "send" device.
rlm@6:     devs = "send";
rlm@6: 
rlm@0:     //printf("these are the devices: %s\n", devs);
rlm@0: 
rlm@0:     if(devs[0])
rlm@0:     {
rlm@0:         int n;
rlm@0:         size_t len;
rlm@0:         const char *next = devs;
rlm@0:         int endlist, delitem;
rlm@0: 
rlm@0:         i = 0;
rlm@0:         do {
rlm@0:             devs = next;
rlm@0: 	    //printf("AURELLEM: devs is %s\n",devs);
rlm@0:             next = strchr(devs, ',');
rlm@0: 
rlm@0:             delitem = (devs[0] == '-');
rlm@0:             if(devs[0] == '-') devs++;
rlm@0: 
rlm@0:             if(!devs[0] || devs[0] == ',')
rlm@0:             {
rlm@0:                 endlist = 0;
rlm@0:                 continue;
rlm@0:             }
rlm@0:             endlist = 1;
rlm@0: 
rlm@0:             len = (next ? ((size_t)(next-devs)) : strlen(devs));
rlm@0:             for(n = i;BackendList[n].Init;n++)
rlm@0:             {
rlm@0: 	      //printf("AURELLEM: device-name -- %s\n",BackendList[n].name);
rlm@0:                 if(len == strlen(BackendList[n].name) &&
rlm@0:                    strncmp(BackendList[n].name, devs, len) == 0)
rlm@0:                 {
rlm@0:                     if(delitem)
rlm@0:                     {
rlm@0:                         do {
rlm@0:                             BackendList[n] = BackendList[n+1];
rlm@0:                             ++n;
rlm@0:                         } 
rlm@0: 			// this relies on the last entry being terminated by an
rlm@0: 			// entry with all nulls.  
rlm@0: 			while(BackendList[n].Init);
rlm@0:                     }
rlm@0:                     else
rlm@0:                     {
rlm@0:                         struct BackendInfo Bkp = BackendList[n];
rlm@0:                         while(n > i)
rlm@0:                         {
rlm@0:                             BackendList[n] = BackendList[n-1];
rlm@0:                             --n;
rlm@0:                         }
rlm@0:                         BackendList[n] = Bkp;
rlm@0: 
rlm@0:                         i++;
rlm@0:                     }
rlm@0:                     break;
rlm@0:                 }
rlm@0:             }
rlm@0:         } while(next++);
rlm@0: 
rlm@0:         if(endlist)
rlm@0:         {
rlm@0:             BackendList[i].name = NULL;
rlm@0:             BackendList[i].Init = NULL;
rlm@0:             BackendList[i].Deinit = NULL;
rlm@0:             BackendList[i].Probe = NULL;
rlm@0:         }
rlm@0:     }
rlm@0: 
rlm@0:     for(i = 0;BackendList[i].Init && (!PlaybackBackend.name || !CaptureBackend.name);i++)
rlm@0:     {
rlm@0:         if(!BackendList[i].Init(&BackendList[i].Funcs))
rlm@0:         {
rlm@0:             WARN("Failed to initialize backend \"%s\"\n", BackendList[i].name);
rlm@0:             continue;
rlm@0:         }
rlm@0: 
rlm@0:         TRACE("Initialized backend \"%s\"\n", BackendList[i].name);
rlm@0:         if(BackendList[i].Funcs.OpenPlayback && !PlaybackBackend.name)
rlm@0:         {
rlm@0:             PlaybackBackend = BackendList[i];
rlm@0:             TRACE("Added \"%s\" for playback\n", PlaybackBackend.name);
rlm@0:         }
rlm@0:         if(BackendList[i].Funcs.OpenCapture && !CaptureBackend.name)
rlm@0:         {
rlm@0:             CaptureBackend = BackendList[i];
rlm@0:             TRACE("Added \"%s\" for capture\n", CaptureBackend.name);
rlm@0:         }
rlm@0:     }
rlm@0:     BackendLoopback.Init(&BackendLoopback.Funcs);
rlm@0: 
rlm@0:     str = GetConfigValue(NULL, "excludefx", "");
rlm@0:     if(str[0])
rlm@0:     {
rlm@0:         size_t len;
rlm@0:         const char *next = str;
rlm@0: 
rlm@0:         do {
rlm@0:             str = next;
rlm@0:             next = strchr(str, ',');
rlm@0: 
rlm@0:             if(!str[0] || next == str)
rlm@0:                 continue;
rlm@0: 
rlm@0:             len = (next ? ((size_t)(next-str)) : strlen(str));
rlm@0:             for(n = 0;EffectList[n].name;n++)
rlm@0:             {
rlm@0:                 if(len == strlen(EffectList[n].name) &&
rlm@0:                    strncmp(EffectList[n].name, str, len) == 0)
rlm@0:                     DisabledEffects[EffectList[n].type] = AL_TRUE;
rlm@0:             }
rlm@0:         } while(next++);
rlm@0:     }
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: static void ProbeList(ALCchar **list, size_t *listsize, enum DevProbe type)
rlm@0: {
rlm@0:     free(*list);
rlm@0:     *list = NULL;
rlm@0:     *listsize = 0;
rlm@0: 
rlm@0:     DO_INITCONFIG();
rlm@0:     if(type == CAPTURE_DEVICE_PROBE)
rlm@0:         CaptureBackend.Probe(type);
rlm@0:     else
rlm@0:         PlaybackBackend.Probe(type);
rlm@0: }
rlm@0: 
rlm@0: static void ProbeDeviceList(void)
rlm@0: { ProbeList(&alcDeviceList, &alcDeviceListSize, DEVICE_PROBE); }
rlm@0: static void ProbeAllDeviceList(void)
rlm@0: { ProbeList(&alcAllDeviceList, &alcAllDeviceListSize, ALL_DEVICE_PROBE); }
rlm@0: static void ProbeCaptureDeviceList(void)
rlm@0: { ProbeList(&alcCaptureDeviceList, &alcCaptureDeviceListSize, CAPTURE_DEVICE_PROBE); }
rlm@0: 
rlm@0: 
rlm@0: static void AppendList(const ALCchar *name, ALCchar **List, size_t *ListSize)
rlm@0: {
rlm@0:     size_t len = strlen(name);
rlm@0:     void *temp;
rlm@0: 
rlm@0:     if(len == 0)
rlm@0:         return;
rlm@0: 
rlm@0:     temp = realloc(*List, (*ListSize) + len + 2);
rlm@0:     if(!temp)
rlm@0:     {
rlm@0:         ERR("Realloc failed to add %s!\n", name);
rlm@0:         return;
rlm@0:     }
rlm@0:     *List = temp;
rlm@0: 
rlm@0:     memcpy((*List)+(*ListSize), name, len+1);
rlm@0:     *ListSize += len+1;
rlm@0:     (*List)[*ListSize] = 0;
rlm@0: }
rlm@0: 
rlm@0: #define DECL_APPEND_LIST_FUNC(type)                                          \
rlm@0: void Append##type##List(const ALCchar *name)                                 \
rlm@0: { AppendList(name, &alc##type##List, &alc##type##ListSize); }
rlm@0: 
rlm@0: DECL_APPEND_LIST_FUNC(Device)
rlm@0: DECL_APPEND_LIST_FUNC(AllDevice)
rlm@0: DECL_APPEND_LIST_FUNC(CaptureDevice)
rlm@0: 
rlm@0: #undef DECL_APPEND_LIST_FUNC
rlm@0: 
rlm@0: 
rlm@0: /* Sets the default channel order used by most non-WaveFormatEx-based APIs */
rlm@0: void SetDefaultChannelOrder(ALCdevice *device)
rlm@0: {
rlm@0:     switch(device->FmtChans)
rlm@0:     {
rlm@0:     case DevFmtX51: device->DevChannels[0] = FRONT_LEFT;
rlm@0:                     device->DevChannels[1] = FRONT_RIGHT;
rlm@0:                     device->DevChannels[2] = BACK_LEFT;
rlm@0:                     device->DevChannels[3] = BACK_RIGHT;
rlm@0:                     device->DevChannels[4] = FRONT_CENTER;
rlm@0:                     device->DevChannels[5] = LFE;
rlm@0:                     return;
rlm@0: 
rlm@0:     case DevFmtX71: device->DevChannels[0] = FRONT_LEFT;
rlm@0:                     device->DevChannels[1] = FRONT_RIGHT;
rlm@0:                     device->DevChannels[2] = BACK_LEFT;
rlm@0:                     device->DevChannels[3] = BACK_RIGHT;
rlm@0:                     device->DevChannels[4] = FRONT_CENTER;
rlm@0:                     device->DevChannels[5] = LFE;
rlm@0:                     device->DevChannels[6] = SIDE_LEFT;
rlm@0:                     device->DevChannels[7] = SIDE_RIGHT;
rlm@0:                     return;
rlm@0: 
rlm@0:     /* Same as WFX order */
rlm@0:     case DevFmtMono:
rlm@0:     case DevFmtStereo:
rlm@0:     case DevFmtQuad:
rlm@0:     case DevFmtX51Side:
rlm@0:     case DevFmtX61:
rlm@0:         break;
rlm@0:     }
rlm@0:     SetDefaultWFXChannelOrder(device);
rlm@0: }
rlm@0: /* Sets the default order used by WaveFormatEx */
rlm@0: void SetDefaultWFXChannelOrder(ALCdevice *device)
rlm@0: {
rlm@0:     switch(device->FmtChans)
rlm@0:     {
rlm@0:     case DevFmtMono: device->DevChannels[0] = FRONT_CENTER; break;
rlm@0: 
rlm@0:     case DevFmtStereo: device->DevChannels[0] = FRONT_LEFT;
rlm@0:                        device->DevChannels[1] = FRONT_RIGHT; break;
rlm@0: 
rlm@0:     case DevFmtQuad: device->DevChannels[0] = FRONT_LEFT;
rlm@0:                      device->DevChannels[1] = FRONT_RIGHT;
rlm@0:                      device->DevChannels[2] = BACK_LEFT;
rlm@0:                      device->DevChannels[3] = BACK_RIGHT; break;
rlm@0: 
rlm@0:     case DevFmtX51: device->DevChannels[0] = FRONT_LEFT;
rlm@0:                     device->DevChannels[1] = FRONT_RIGHT;
rlm@0:                     device->DevChannels[2] = FRONT_CENTER;
rlm@0:                     device->DevChannels[3] = LFE;
rlm@0:                     device->DevChannels[4] = BACK_LEFT;
rlm@0:                     device->DevChannels[5] = BACK_RIGHT; break;
rlm@0: 
rlm@0:     case DevFmtX51Side: device->DevChannels[0] = FRONT_LEFT;
rlm@0:                         device->DevChannels[1] = FRONT_RIGHT;
rlm@0:                         device->DevChannels[2] = FRONT_CENTER;
rlm@0:                         device->DevChannels[3] = LFE;
rlm@0:                         device->DevChannels[4] = SIDE_LEFT;
rlm@0:                         device->DevChannels[5] = SIDE_RIGHT; break;
rlm@0: 
rlm@0:     case DevFmtX61: device->DevChannels[0] = FRONT_LEFT;
rlm@0:                     device->DevChannels[1] = FRONT_RIGHT;
rlm@0:                     device->DevChannels[2] = FRONT_CENTER;
rlm@0:                     device->DevChannels[3] = LFE;
rlm@0:                     device->DevChannels[4] = BACK_CENTER;
rlm@0:                     device->DevChannels[5] = SIDE_LEFT;
rlm@0:                     device->DevChannels[6] = SIDE_RIGHT; break;
rlm@0: 
rlm@0:     case DevFmtX71: device->DevChannels[0] = FRONT_LEFT;
rlm@0:                     device->DevChannels[1] = FRONT_RIGHT;
rlm@0:                     device->DevChannels[2] = FRONT_CENTER;
rlm@0:                     device->DevChannels[3] = LFE;
rlm@0:                     device->DevChannels[4] = BACK_LEFT;
rlm@0:                     device->DevChannels[5] = BACK_RIGHT;
rlm@0:                     device->DevChannels[6] = SIDE_LEFT;
rlm@0:                     device->DevChannels[7] = SIDE_RIGHT; break;
rlm@0:     }
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: const ALCchar *DevFmtTypeString(enum DevFmtType type)
rlm@0: {
rlm@0:     switch(type)
rlm@0:     {
rlm@0:     case DevFmtByte: return "Signed Byte";
rlm@0:     case DevFmtUByte: return "Unsigned Byte";
rlm@0:     case DevFmtShort: return "Signed Short";
rlm@0:     case DevFmtUShort: return "Unsigned Short";
rlm@0:     case DevFmtFloat: return "Float";
rlm@0:     }
rlm@0:     return "(unknown type)";
rlm@0: }
rlm@0: const ALCchar *DevFmtChannelsString(enum DevFmtChannels chans)
rlm@0: {
rlm@0:     switch(chans)
rlm@0:     {
rlm@0:     case DevFmtMono: return "Mono";
rlm@0:     case DevFmtStereo: return "Stereo";
rlm@0:     case DevFmtQuad: return "Quadraphonic";
rlm@0:     case DevFmtX51: return "5.1 Surround";
rlm@0:     case DevFmtX51Side: return "5.1 Side";
rlm@0:     case DevFmtX61: return "6.1 Surround";
rlm@0:     case DevFmtX71: return "7.1 Surround";
rlm@0:     }
rlm@0:     return "(unknown channels)";
rlm@0: }
rlm@0: 
rlm@0: ALuint BytesFromDevFmt(enum DevFmtType type)
rlm@0: {
rlm@0:     switch(type)
rlm@0:     {
rlm@0:     case DevFmtByte: return sizeof(ALbyte);
rlm@0:     case DevFmtUByte: return sizeof(ALubyte);
rlm@0:     case DevFmtShort: return sizeof(ALshort);
rlm@0:     case DevFmtUShort: return sizeof(ALushort);
rlm@0:     case DevFmtFloat: return sizeof(ALfloat);
rlm@0:     }
rlm@0:     return 0;
rlm@0: }
rlm@0: ALuint ChannelsFromDevFmt(enum DevFmtChannels chans)
rlm@0: {
rlm@0:     switch(chans)
rlm@0:     {
rlm@0:     case DevFmtMono: return 1;
rlm@0:     case DevFmtStereo: return 2;
rlm@0:     case DevFmtQuad: return 4;
rlm@0:     case DevFmtX51: return 6;
rlm@0:     case DevFmtX51Side: return 6;
rlm@0:     case DevFmtX61: return 7;
rlm@0:     case DevFmtX71: return 8;
rlm@0:     }
rlm@0:     return 0;
rlm@0: }
rlm@0: ALboolean DecomposeDevFormat(ALenum format, enum DevFmtChannels *chans,
rlm@0:                              enum DevFmtType *type)
rlm@0: {
rlm@0:     switch(format)
rlm@0:     {
rlm@0:         case AL_FORMAT_MONO8:
rlm@0:             *chans = DevFmtMono;
rlm@0:             *type  = DevFmtUByte;
rlm@0:             return AL_TRUE;
rlm@0:         case AL_FORMAT_MONO16:
rlm@0:             *chans = DevFmtMono;
rlm@0:             *type  = DevFmtShort;
rlm@0:             return AL_TRUE;
rlm@0:         case AL_FORMAT_MONO_FLOAT32:
rlm@0:             *chans = DevFmtMono;
rlm@0:             *type  = DevFmtFloat;
rlm@0:             return AL_TRUE;
rlm@0:         case AL_FORMAT_STEREO8:
rlm@0:             *chans = DevFmtStereo;
rlm@0:             *type  = DevFmtUByte;
rlm@0:             return AL_TRUE;
rlm@0:         case AL_FORMAT_STEREO16:
rlm@0:             *chans = DevFmtStereo;
rlm@0:             *type  = DevFmtShort;
rlm@0:             return AL_TRUE;
rlm@0:         case AL_FORMAT_STEREO_FLOAT32:
rlm@0:             *chans = DevFmtStereo;
rlm@0:             *type  = DevFmtFloat;
rlm@0:             return AL_TRUE;
rlm@0:         case AL_FORMAT_QUAD8:
rlm@0:             *chans = DevFmtQuad;
rlm@0:             *type  = DevFmtUByte;
rlm@0:             return AL_TRUE;
rlm@0:         case AL_FORMAT_QUAD16:
rlm@0:             *chans = DevFmtQuad;
rlm@0:             *type  = DevFmtShort;
rlm@0:             return AL_TRUE;
rlm@0:         case AL_FORMAT_QUAD32:
rlm@0:             *chans = DevFmtQuad;
rlm@0:             *type  = DevFmtFloat;
rlm@0:             return AL_TRUE;
rlm@0:         case AL_FORMAT_51CHN8:
rlm@0:             *chans = DevFmtX51;
rlm@0:             *type  = DevFmtUByte;
rlm@0:             return AL_TRUE;
rlm@0:         case AL_FORMAT_51CHN16:
rlm@0:             *chans = DevFmtX51;
rlm@0:             *type  = DevFmtShort;
rlm@0:             return AL_TRUE;
rlm@0:         case AL_FORMAT_51CHN32:
rlm@0:             *chans = DevFmtX51;
rlm@0:             *type  = DevFmtFloat;
rlm@0:             return AL_TRUE;
rlm@0:         case AL_FORMAT_61CHN8:
rlm@0:             *chans = DevFmtX61;
rlm@0:             *type  = DevFmtUByte;
rlm@0:             return AL_TRUE;
rlm@0:         case AL_FORMAT_61CHN16:
rlm@0:             *chans = DevFmtX61;
rlm@0:             *type  = DevFmtShort;
rlm@0:             return AL_TRUE;
rlm@0:         case AL_FORMAT_61CHN32:
rlm@0:             *chans = DevFmtX61;
rlm@0:             *type  = DevFmtFloat;
rlm@0:             return AL_TRUE;
rlm@0:         case AL_FORMAT_71CHN8:
rlm@0:             *chans = DevFmtX71;
rlm@0:             *type  = DevFmtUByte;
rlm@0:             return AL_TRUE;
rlm@0:         case AL_FORMAT_71CHN16:
rlm@0:             *chans = DevFmtX71;
rlm@0:             *type  = DevFmtShort;
rlm@0:             return AL_TRUE;
rlm@0:         case AL_FORMAT_71CHN32:
rlm@0:             *chans = DevFmtX71;
rlm@0:             *type  = DevFmtFloat;
rlm@0:             return AL_TRUE;
rlm@0:     }
rlm@0:     return AL_FALSE;
rlm@0: }
rlm@0: 
rlm@0: static ALCboolean IsValidALCType(ALCenum type)
rlm@0: {
rlm@0:     switch(type)
rlm@0:     {
rlm@0:         case ALC_BYTE:
rlm@0:         case ALC_UNSIGNED_BYTE:
rlm@0:         case ALC_SHORT:
rlm@0:         case ALC_UNSIGNED_SHORT:
rlm@0:         case ALC_INT:
rlm@0:         case ALC_UNSIGNED_INT:
rlm@0:         case ALC_FLOAT:
rlm@0:             return ALC_TRUE;
rlm@0:     }
rlm@0:     return ALC_FALSE;
rlm@0: }
rlm@0: 
rlm@0: static ALCboolean IsValidALCChannels(ALCenum channels)
rlm@0: {
rlm@0:     switch(channels)
rlm@0:     {
rlm@0:         case ALC_MONO:
rlm@0:         case ALC_STEREO:
rlm@0:         case ALC_QUAD:
rlm@0:         case ALC_5POINT1:
rlm@0:         case ALC_6POINT1:
rlm@0:         case ALC_7POINT1:
rlm@0:             return ALC_TRUE;
rlm@0:     }
rlm@0:     return ALC_FALSE;
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: static void LockLists(void)
rlm@0: {
rlm@0:     EnterCriticalSection(&ListLock);
rlm@0: }
rlm@0: 
rlm@0: static void UnlockLists(void)
rlm@0: {
rlm@0:     LeaveCriticalSection(&ListLock);
rlm@0: }
rlm@0: 
rlm@0: /*
rlm@0:     IsDevice
rlm@0: 
rlm@0:     Check pDevice is a valid Device pointer
rlm@0: */
rlm@0: static ALCboolean IsDevice(ALCdevice *pDevice)
rlm@0: {
rlm@0:     ALCdevice *pTempDevice;
rlm@0: 
rlm@0:     pTempDevice = g_pDeviceList;
rlm@0:     while(pTempDevice && pTempDevice != pDevice)
rlm@0:         pTempDevice = pTempDevice->next;
rlm@0: 
rlm@0:     return (pTempDevice ? ALC_TRUE : ALC_FALSE);
rlm@0: }
rlm@0: 
rlm@0: /*
rlm@0:     IsContext
rlm@0: 
rlm@0:     Check pContext is a valid Context pointer
rlm@0: */
rlm@0: static ALCboolean IsContext(ALCcontext *pContext)
rlm@0: {
rlm@0:     ALCcontext *pTempContext;
rlm@0: 
rlm@0:     pTempContext = g_pContextList;
rlm@0:     while (pTempContext && pTempContext != pContext)
rlm@0:         pTempContext = pTempContext->next;
rlm@0: 
rlm@0:     return (pTempContext ? ALC_TRUE : ALC_FALSE);
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: /*
rlm@0:     alcSetError
rlm@0: 
rlm@0:     Store latest ALC Error
rlm@0: */
rlm@0: ALCvoid alcSetError(ALCdevice *device, ALenum errorCode)
rlm@0: {
rlm@0:     LockLists();
rlm@0:     if(IsDevice(device))
rlm@0:         device->LastError = errorCode;
rlm@0:     else
rlm@0:         g_eLastNullDeviceError = errorCode;
rlm@0:     UnlockLists();
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: /* UpdateDeviceParams:
rlm@0:  *
rlm@0:  * Updates device parameters according to the attribute list.
rlm@0:  */
rlm@0: static ALCboolean UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
rlm@0: {
rlm@0:     ALuint i;
rlm@0: 
rlm@0:     // Check for attributes
rlm@0:     if(attrList && attrList[0])
rlm@0:     {
rlm@0:         ALCuint freq, numMono, numStereo, numSends;
rlm@0:         enum DevFmtChannels schans;
rlm@0:         enum DevFmtType stype;
rlm@0:         ALuint attrIdx;
rlm@0: 
rlm@0:         // If a context is already running on the device, stop playback so the
rlm@0:         // device attributes can be updated
rlm@0:         if((device->Flags&DEVICE_RUNNING))
rlm@0:             ALCdevice_StopPlayback(device);
rlm@0:         device->Flags &= ~DEVICE_RUNNING;
rlm@0: 
rlm@0:         freq = device->Frequency;
rlm@0:         schans = device->FmtChans;
rlm@0:         stype = device->FmtType;
rlm@0:         numMono = device->NumMonoSources;
rlm@0:         numStereo = device->NumStereoSources;
rlm@0:         numSends = device->NumAuxSends;
rlm@0: 
rlm@0:         freq = GetConfigValueInt(NULL, "frequency", freq);
rlm@0:         if(freq < 8000) freq = 8000;
rlm@0: 
rlm@0:         attrIdx = 0;
rlm@0:         while(attrList[attrIdx])
rlm@0:         {
rlm@0:             if(attrList[attrIdx] == ALC_FORMAT_CHANNELS_SOFT &&
rlm@0:                device->IsLoopbackDevice)
rlm@0:             {
rlm@0:                 ALCint val = attrList[attrIdx + 1];
rlm@0:                 if(!IsValidALCChannels(val) || !ChannelsFromDevFmt(val))
rlm@0:                 {
rlm@0:                     alcSetError(device, ALC_INVALID_VALUE);
rlm@0:                     return ALC_FALSE;
rlm@0:                 }
rlm@0:                 schans = val;
rlm@0:             }
rlm@0: 
rlm@0:             if(attrList[attrIdx] == ALC_FORMAT_TYPE_SOFT &&
rlm@0:                device->IsLoopbackDevice)
rlm@0:             {
rlm@0:                 ALCint val = attrList[attrIdx + 1];
rlm@0:                 if(!IsValidALCType(val) || !BytesFromDevFmt(val))
rlm@0:                 {
rlm@0:                     alcSetError(device, ALC_INVALID_VALUE);
rlm@0:                     return ALC_FALSE;
rlm@0:                 }
rlm@0:                 stype = val;
rlm@0:             }
rlm@0: 
rlm@0:             if(attrList[attrIdx] == ALC_FREQUENCY)
rlm@0:             {
rlm@0:                 if(device->IsLoopbackDevice)
rlm@0:                 {
rlm@0:                     freq = attrList[attrIdx + 1];
rlm@0:                     if(freq < 8000)
rlm@0:                     {
rlm@0:                         alcSetError(device, ALC_INVALID_VALUE);
rlm@0:                         return ALC_FALSE;
rlm@0:                     }
rlm@0:                 }
rlm@0:                 else if(!ConfigValueExists(NULL, "frequency"))
rlm@0:                 {
rlm@0:                     freq = attrList[attrIdx + 1];
rlm@0:                     if(freq < 8000) freq = 8000;
rlm@0:                     device->Flags |= DEVICE_FREQUENCY_REQUEST;
rlm@0:                 }
rlm@0:             }
rlm@0: 
rlm@0:             if(attrList[attrIdx] == ALC_STEREO_SOURCES)
rlm@0:             {
rlm@0:                 numStereo = attrList[attrIdx + 1];
rlm@0:                 if(numStereo > device->MaxNoOfSources)
rlm@0:                     numStereo = device->MaxNoOfSources;
rlm@0: 
rlm@0:                 numMono = device->MaxNoOfSources - numStereo;
rlm@0:             }
rlm@0: 
rlm@0:             if(attrList[attrIdx] == ALC_MAX_AUXILIARY_SENDS &&
rlm@0:                !ConfigValueExists(NULL, "sends"))
rlm@0:             {
rlm@0:                 numSends = attrList[attrIdx + 1];
rlm@0:                 if(numSends > MAX_SENDS)
rlm@0:                     numSends = MAX_SENDS;
rlm@0:             }
rlm@0: 
rlm@0:             attrIdx += 2;
rlm@0:         }
rlm@0: 
rlm@0:         device->UpdateSize = (ALuint64)device->UpdateSize * freq /
rlm@0:                              device->Frequency;
rlm@0: 
rlm@0:         device->Frequency = freq;
rlm@0:         device->FmtChans = schans;
rlm@0:         device->FmtType = stype;
rlm@0:         device->NumMonoSources = numMono;
rlm@0:         device->NumStereoSources = numStereo;
rlm@0:         device->NumAuxSends = numSends;
rlm@0:     }
rlm@0: 
rlm@0:     if((device->Flags&DEVICE_RUNNING))
rlm@0:         return ALC_TRUE;
rlm@0: 
rlm@0:     LockDevice(device);
rlm@0:     TRACE("Format pre-setup: %s%s, %s, %uhz%s, %u update size x%d\n",
rlm@0:           DevFmtChannelsString(device->FmtChans),
rlm@0:           (device->Flags&DEVICE_CHANNELS_REQUEST)?" (requested)":"",
rlm@0:           DevFmtTypeString(device->FmtType), device->Frequency,
rlm@0:           (device->Flags&DEVICE_FREQUENCY_REQUEST)?" (requested)":"",
rlm@0:           device->UpdateSize, device->NumUpdates);
rlm@0:     if(ALCdevice_ResetPlayback(device) == ALC_FALSE)
rlm@0:     {
rlm@0:         UnlockDevice(device);
rlm@0:         return ALC_FALSE;
rlm@0:     }
rlm@0:     device->Flags |= DEVICE_RUNNING;
rlm@0:     TRACE("Format post-setup: %s%s, %s, %uhz%s, %u update size x%d\n",
rlm@0:           DevFmtChannelsString(device->FmtChans),
rlm@0:           (device->Flags&DEVICE_CHANNELS_REQUEST)?" (requested)":"",
rlm@0:           DevFmtTypeString(device->FmtType), device->Frequency,
rlm@0:           (device->Flags&DEVICE_FREQUENCY_REQUEST)?" (requested)":"",
rlm@0:           device->UpdateSize, device->NumUpdates);
rlm@0: 
rlm@0:     aluInitPanning(device);
rlm@0: 
rlm@0:     for(i = 0;i < MAXCHANNELS;i++)
rlm@0:     {
rlm@0:         device->ClickRemoval[i] = 0.0f;
rlm@0:         device->PendingClicks[i] = 0.0f;
rlm@0:     }
rlm@0: 
rlm@0:     if(!device->IsLoopbackDevice && GetConfigValueBool(NULL, "hrtf", AL_FALSE))
rlm@0:         device->Flags |= DEVICE_USE_HRTF;
rlm@0:     if((device->Flags&DEVICE_USE_HRTF) && !IsHrtfCompatible(device))
rlm@0:         device->Flags &= ~DEVICE_USE_HRTF;
rlm@0:     TRACE("HRTF %s\n", (device->Flags&DEVICE_USE_HRTF)?"enabled":"disabled");
rlm@0: 
rlm@0:     if(!(device->Flags&DEVICE_USE_HRTF) && device->Bs2bLevel > 0 && device->Bs2bLevel <= 6)
rlm@0:     {
rlm@0:         if(!device->Bs2b)
rlm@0:         {
rlm@0:             device->Bs2b = calloc(1, sizeof(*device->Bs2b));
rlm@0:             bs2b_clear(device->Bs2b);
rlm@0:         }
rlm@0:         bs2b_set_srate(device->Bs2b, device->Frequency);
rlm@0:         bs2b_set_level(device->Bs2b, device->Bs2bLevel);
rlm@0:         TRACE("BS2B level %d\n", device->Bs2bLevel);
rlm@0:     }
rlm@0:     else
rlm@0:     {
rlm@0:         free(device->Bs2b);
rlm@0:         device->Bs2b = NULL;
rlm@0:         TRACE("BS2B disabled\n");
rlm@0:     }
rlm@0: 
rlm@0:     device->Flags &= ~DEVICE_DUPLICATE_STEREO;
rlm@0:     switch(device->FmtChans)
rlm@0:     {
rlm@0:         case DevFmtMono:
rlm@0:         case DevFmtStereo:
rlm@0:             break;
rlm@0:         case DevFmtQuad:
rlm@0:         case DevFmtX51:
rlm@0:         case DevFmtX51Side:
rlm@0:         case DevFmtX61:
rlm@0:         case DevFmtX71:
rlm@0:             if(GetConfigValueBool(NULL, "stereodup", AL_TRUE))
rlm@0:                 device->Flags |= DEVICE_DUPLICATE_STEREO;
rlm@0:             break;
rlm@0:     }
rlm@0:     TRACE("Stereo duplication %s\n", (device->Flags&DEVICE_DUPLICATE_STEREO)?"enabled":"disabled");
rlm@0: 
rlm@0:     for(i = 0;i < device->NumContexts;i++)
rlm@0:     {
rlm@0:         ALCcontext *context = device->Contexts[i];
rlm@0:         ALsizei pos;
rlm@0: 
rlm@0:         context->UpdateSources = AL_FALSE;
rlm@0:         for(pos = 0;pos < context->EffectSlotMap.size;pos++)
rlm@0:         {
rlm@0:             ALeffectslot *slot = context->EffectSlotMap.array[pos].value;
rlm@0: 
rlm@0:             if(ALEffect_DeviceUpdate(slot->EffectState, device) == AL_FALSE)
rlm@0:             {
rlm@0:                 UnlockDevice(device);
rlm@0:                 ALCdevice_StopPlayback(device);
rlm@0:                 device->Flags &= ~DEVICE_RUNNING;
rlm@0:                 return ALC_FALSE;
rlm@0:             }
rlm@0:             slot->NeedsUpdate = AL_FALSE;
rlm@0:             ALEffect_Update(slot->EffectState, context, slot);
rlm@0:         }
rlm@0: 
rlm@0:         for(pos = 0;pos < context->SourceMap.size;pos++)
rlm@0:         {
rlm@0:             ALsource *source = context->SourceMap.array[pos].value;
rlm@0:             ALuint s = device->NumAuxSends;
rlm@0:             while(s < MAX_SENDS)
rlm@0:             {
rlm@0:                 if(source->Send[s].Slot)
rlm@0:                     source->Send[s].Slot->refcount--;
rlm@0:                 source->Send[s].Slot = NULL;
rlm@0:                 source->Send[s].WetFilter.type = 0;
rlm@0:                 source->Send[s].WetFilter.filter = 0;
rlm@0:                 s++;
rlm@0:             }
rlm@0:             source->NeedsUpdate = AL_FALSE;
rlm@0:             ALsource_Update(source, context);
rlm@0:         }
rlm@0:     }
rlm@0:     UnlockDevice(device);
rlm@0: 
rlm@0:     return ALC_TRUE;
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: ALCvoid LockDevice(ALCdevice *device)
rlm@0: {
rlm@0:     EnterCriticalSection(&device->Mutex);
rlm@0: }
rlm@0: 
rlm@0: ALCvoid UnlockDevice(ALCdevice *device)
rlm@0: {
rlm@0:     LeaveCriticalSection(&device->Mutex);
rlm@0: }
rlm@0: 
rlm@0: /*
rlm@0:     LockContext
rlm@0: 
rlm@0:     Thread-safe entry
rlm@0: */
rlm@0: ALCvoid LockContext(ALCcontext *context)
rlm@0: {
rlm@0:     EnterCriticalSection(&context->Device->Mutex);
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: /*
rlm@0:     UnlockContext
rlm@0: 
rlm@0:     Thread-safe exit
rlm@0: */
rlm@0: ALCvoid UnlockContext(ALCcontext *context)
rlm@0: {
rlm@0:     LeaveCriticalSection(&context->Device->Mutex);
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: /*
rlm@0:     GetLockedContext
rlm@0: 
rlm@0:     Returns the currently active Context, in a locked state
rlm@0: */
rlm@0: ALCcontext *GetLockedContext(void)
rlm@0: {
rlm@0:     ALCcontext *pContext = NULL;
rlm@0: 
rlm@0:     LockLists();
rlm@0: 
rlm@0:     pContext = tls_get(LocalContext);
rlm@0:     if(pContext && !IsContext(pContext))
rlm@0:     {
rlm@0:         tls_set(LocalContext, NULL);
rlm@0:         pContext = NULL;
rlm@0:     }
rlm@0:     if(!pContext)
rlm@0:         pContext = GlobalContext;
rlm@0:     if(pContext)
rlm@0:         LockContext(pContext);
rlm@0: 
rlm@0:     UnlockLists();
rlm@0: 
rlm@0:     return pContext;
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: /*
rlm@0:     InitContext
rlm@0: 
rlm@0:     Initialize Context variables
rlm@0: */
rlm@0: static ALvoid InitContext(ALCcontext *pContext)
rlm@0: {
rlm@0:     //Initialise listener
rlm@0:     pContext->Listener.Gain = 1.0f;
rlm@0:     pContext->Listener.MetersPerUnit = 1.0f;
rlm@0:     pContext->Listener.Position[0] = 0.0f;
rlm@0:     pContext->Listener.Position[1] = 0.0f;
rlm@0:     pContext->Listener.Position[2] = 0.0f;
rlm@0:     pContext->Listener.Velocity[0] = 0.0f;
rlm@0:     pContext->Listener.Velocity[1] = 0.0f;
rlm@0:     pContext->Listener.Velocity[2] = 0.0f;
rlm@0:     pContext->Listener.Forward[0] = 0.0f;
rlm@0:     pContext->Listener.Forward[1] = 0.0f;
rlm@0:     pContext->Listener.Forward[2] = -1.0f;
rlm@0:     pContext->Listener.Up[0] = 0.0f;
rlm@0:     pContext->Listener.Up[1] = 1.0f;
rlm@0:     pContext->Listener.Up[2] = 0.0f;
rlm@0: 
rlm@0:     //Validate pContext
rlm@0:     pContext->LastError = AL_NO_ERROR;
rlm@0:     pContext->UpdateSources = AL_FALSE;
rlm@0:     pContext->ActiveSourceCount = 0;
rlm@0:     InitUIntMap(&pContext->SourceMap);
rlm@0:     InitUIntMap(&pContext->EffectSlotMap);
rlm@0: 
rlm@0:     //Set globals
rlm@0:     pContext->DistanceModel = AL_INVERSE_DISTANCE_CLAMPED;
rlm@0:     pContext->SourceDistanceModel = AL_FALSE;
rlm@0:     pContext->DopplerFactor = 1.0f;
rlm@0:     pContext->DopplerVelocity = 1.0f;
rlm@0:     pContext->flSpeedOfSound = SPEEDOFSOUNDMETRESPERSEC;
rlm@0:     pContext->DeferUpdates = AL_FALSE;
rlm@0: 
rlm@0:     pContext->ExtensionList = alExtList;
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: /*
rlm@0:     FreeContext
rlm@0: 
rlm@0:     Clean up Context, destroy any remaining Sources
rlm@0: */
rlm@0: static ALCvoid FreeContext(ALCcontext *context)
rlm@0: {
rlm@0:     //Invalidate context
rlm@0:     memset(context, 0, sizeof(ALCcontext));
rlm@0:     free(context);
rlm@0: }
rlm@0: 
rlm@0: ///////////////////////////////////////////////////////
rlm@0: 
rlm@0: 
rlm@0: ///////////////////////////////////////////////////////
rlm@0: // ALC Functions calls
rlm@0: 
rlm@0: 
rlm@0: // This should probably move to another c file but for now ...
rlm@0: ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
rlm@0: {
rlm@0:     ALCdevice *device = NULL;
rlm@0: 
rlm@0:     DO_INITCONFIG();
rlm@0: 
rlm@0:     if(!CaptureBackend.name)
rlm@0:     {
rlm@0:         alcSetError(NULL, ALC_INVALID_VALUE);
rlm@0:         return NULL;
rlm@0:     }
rlm@0: 
rlm@0:     if(SampleSize <= 0)
rlm@0:     {
rlm@0:         alcSetError(NULL, ALC_INVALID_VALUE);
rlm@0:         return NULL;
rlm@0:     }
rlm@0: 
rlm@0:     if(deviceName && (!deviceName[0] || strcasecmp(deviceName, "openal soft") == 0 || strcasecmp(deviceName, "openal-soft") == 0))
rlm@0:         deviceName = NULL;
rlm@0: 
rlm@0:     device = calloc(1, sizeof(ALCdevice));
rlm@0:     if(!device)
rlm@0:     {
rlm@0:         alcSetError(NULL, ALC_OUT_OF_MEMORY);
rlm@0:         return NULL;
rlm@0:     }
rlm@0: 
rlm@0:     //Validate device
rlm@0:     device->Funcs = &CaptureBackend.Funcs;
rlm@0:     device->Connected = ALC_TRUE;
rlm@0:     device->IsCaptureDevice = AL_TRUE;
rlm@0:     device->IsLoopbackDevice = AL_FALSE;
rlm@0:     InitializeCriticalSection(&device->Mutex);
rlm@0: 
rlm@0:     device->szDeviceName = NULL;
rlm@0: 
rlm@0:     device->Flags |= DEVICE_FREQUENCY_REQUEST;
rlm@0:     device->Frequency = frequency;
rlm@0: 
rlm@0:     device->Flags |= DEVICE_CHANNELS_REQUEST;
rlm@0:     if(DecomposeDevFormat(format, &device->FmtChans, &device->FmtType) == AL_FALSE)
rlm@0:     {
rlm@0:         free(device);
rlm@0:         alcSetError(NULL, ALC_INVALID_ENUM);
rlm@0:         return NULL;
rlm@0:     }
rlm@0: 
rlm@0:     device->UpdateSize = SampleSize;
rlm@0:     device->NumUpdates = 1;
rlm@0: 
rlm@0:     LockLists();
rlm@0:     if(ALCdevice_OpenCapture(device, deviceName))
rlm@0:     {
rlm@0:         device->next = g_pDeviceList;
rlm@0:         g_pDeviceList = device;
rlm@0:         g_ulDeviceCount++;
rlm@0:     }
rlm@0:     else
rlm@0:     {
rlm@0:         DeleteCriticalSection(&device->Mutex);
rlm@0:         free(device);
rlm@0:         device = NULL;
rlm@0:         alcSetError(NULL, ALC_INVALID_VALUE);
rlm@0:     }
rlm@0:     UnlockLists();
rlm@0: 
rlm@0:     return device;
rlm@0: }
rlm@0: 
rlm@0: ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *pDevice)
rlm@0: {
rlm@0:     ALCdevice **list;
rlm@0: 
rlm@0:     LockLists();
rlm@0:     list = &g_pDeviceList;
rlm@0:     while(*list && *list != pDevice)
rlm@0:         list = &(*list)->next;
rlm@0: 
rlm@0:     if(!*list || !(*list)->IsCaptureDevice)
rlm@0:     {
rlm@0:         alcSetError(*list, ALC_INVALID_DEVICE);
rlm@0:         UnlockLists();
rlm@0:         return ALC_FALSE;
rlm@0:     }
rlm@0: 
rlm@0:     *list = (*list)->next;
rlm@0:     g_ulDeviceCount--;
rlm@0: 
rlm@0:     UnlockLists();
rlm@0: 
rlm@0:     LockDevice(pDevice);
rlm@0:     ALCdevice_CloseCapture(pDevice);
rlm@0:     UnlockDevice(pDevice);
rlm@0: 
rlm@0:     free(pDevice->szDeviceName);
rlm@0:     pDevice->szDeviceName = NULL;
rlm@0: 
rlm@0:     DeleteCriticalSection(&pDevice->Mutex);
rlm@0: 
rlm@0:     free(pDevice);
rlm@0: 
rlm@0:     return ALC_TRUE;
rlm@0: }
rlm@0: 
rlm@0: ALC_API void ALC_APIENTRY alcCaptureStart(ALCdevice *device)
rlm@0: {
rlm@0:     LockLists();
rlm@0:     if(!IsDevice(device) || !device->IsCaptureDevice)
rlm@0:     {
rlm@0:         alcSetError(device, ALC_INVALID_DEVICE);
rlm@0:         UnlockLists();
rlm@0:         return;
rlm@0:     }
rlm@0:     LockDevice(device);
rlm@0:     UnlockLists();
rlm@0:     if(device->Connected)
rlm@0:         ALCdevice_StartCapture(device);
rlm@0:     UnlockDevice(device);
rlm@0: }
rlm@0: 
rlm@0: ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device)
rlm@0: {
rlm@0:     LockLists();
rlm@0:     if(!IsDevice(device) || !device->IsCaptureDevice)
rlm@0:     {
rlm@0:         alcSetError(device, ALC_INVALID_DEVICE);
rlm@0:         UnlockLists();
rlm@0:         return;
rlm@0:     }
rlm@0:     LockDevice(device);
rlm@0:     UnlockLists();
rlm@0:     if(device->Connected)
rlm@0:         ALCdevice_StopCapture(device);
rlm@0:     UnlockDevice(device);
rlm@0: }
rlm@0: 
rlm@0: ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
rlm@0: {
rlm@0:     LockLists();
rlm@0:     if(!IsDevice(device) || !device->IsCaptureDevice)
rlm@0:     {
rlm@0:         alcSetError(device, ALC_INVALID_DEVICE);
rlm@0:         UnlockLists();
rlm@0:         return;
rlm@0:     }
rlm@0:     LockDevice(device);
rlm@0:     UnlockLists();
rlm@0:     if(device->Connected)
rlm@0:         ALCdevice_CaptureSamples(device, buffer, samples);
rlm@0:     UnlockDevice(device);
rlm@0: }
rlm@0: 
rlm@0: /*
rlm@0:     alcGetError
rlm@0: 
rlm@0:     Return last ALC generated error code
rlm@0: */
rlm@0: ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device)
rlm@0: {
rlm@0:     ALCenum errorCode;
rlm@0: 
rlm@0:     LockLists();
rlm@0:     if(IsDevice(device))
rlm@0:     {
rlm@0:         errorCode = device->LastError;
rlm@0:         device->LastError = ALC_NO_ERROR;
rlm@0:     }
rlm@0:     else
rlm@0:     {
rlm@0:         errorCode = g_eLastNullDeviceError;
rlm@0:         g_eLastNullDeviceError = ALC_NO_ERROR;
rlm@0:     }
rlm@0:     UnlockLists();
rlm@0:     return errorCode;
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: /*
rlm@0:     alcSuspendContext
rlm@0: 
rlm@0:     Not functional
rlm@0: */
rlm@0: ALC_API ALCvoid ALC_APIENTRY alcSuspendContext(ALCcontext *Context)
rlm@0: {
rlm@0:     (void)Context;
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: /*
rlm@0:     alcProcessContext
rlm@0: 
rlm@0:     Not functional
rlm@0: */
rlm@0: ALC_API ALCvoid ALC_APIENTRY alcProcessContext(ALCcontext *Context)
rlm@0: {
rlm@0:     (void)Context;
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: /*
rlm@0:     alcGetString
rlm@0: 
rlm@0:     Returns information about the Device, and error strings
rlm@0: */
rlm@0: ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *pDevice,ALCenum param)
rlm@0: {
rlm@0:     const ALCchar *value = NULL;
rlm@0: 
rlm@0:     switch(param)
rlm@0:     {
rlm@0:     case ALC_NO_ERROR:
rlm@0:         value = alcNoError;
rlm@0:         break;
rlm@0: 
rlm@0:     case ALC_INVALID_ENUM:
rlm@0:         value = alcErrInvalidEnum;
rlm@0:         break;
rlm@0: 
rlm@0:     case ALC_INVALID_VALUE:
rlm@0:         value = alcErrInvalidValue;
rlm@0:         break;
rlm@0: 
rlm@0:     case ALC_INVALID_DEVICE:
rlm@0:         value = alcErrInvalidDevice;
rlm@0:         break;
rlm@0: 
rlm@0:     case ALC_INVALID_CONTEXT:
rlm@0:         value = alcErrInvalidContext;
rlm@0:         break;
rlm@0: 
rlm@0:     case ALC_OUT_OF_MEMORY:
rlm@0:         value = alcErrOutOfMemory;
rlm@0:         break;
rlm@0: 
rlm@0:     case ALC_DEVICE_SPECIFIER:
rlm@0:         LockLists();
rlm@0:         if(IsDevice(pDevice))
rlm@0:             value = pDevice->szDeviceName;
rlm@0:         else
rlm@0:         {
rlm@0:             ProbeDeviceList();
rlm@0:             value = alcDeviceList;
rlm@0:         }
rlm@0:         UnlockLists();
rlm@0:         break;
rlm@0: 
rlm@0:     case ALC_ALL_DEVICES_SPECIFIER:
rlm@0:         ProbeAllDeviceList();
rlm@0:         value = alcAllDeviceList;
rlm@0:         break;
rlm@0: 
rlm@0:     case ALC_CAPTURE_DEVICE_SPECIFIER:
rlm@0:         LockLists();
rlm@0:         if(IsDevice(pDevice))
rlm@0:             value = pDevice->szDeviceName;
rlm@0:         else
rlm@0:         {
rlm@0:             ProbeCaptureDeviceList();
rlm@0:             value = alcCaptureDeviceList;
rlm@0:         }
rlm@0:         UnlockLists();
rlm@0:         break;
rlm@0: 
rlm@0:     /* Default devices are always first in the list */
rlm@0:     case ALC_DEFAULT_DEVICE_SPECIFIER:
rlm@0:         if(!alcDeviceList)
rlm@0:             ProbeDeviceList();
rlm@0: 
rlm@0:         free(alcDefaultDeviceSpecifier);
rlm@0:         alcDefaultDeviceSpecifier = strdup(alcDeviceList ? alcDeviceList : "");
rlm@0:         if(!alcDefaultDeviceSpecifier)
rlm@0:             alcSetError(pDevice, ALC_OUT_OF_MEMORY);
rlm@0:         value = alcDefaultDeviceSpecifier;
rlm@0:         break;
rlm@0: 
rlm@0:     case ALC_DEFAULT_ALL_DEVICES_SPECIFIER:
rlm@0:         if(!alcAllDeviceList)
rlm@0:             ProbeAllDeviceList();
rlm@0: 
rlm@0:         free(alcDefaultAllDeviceSpecifier);
rlm@0:         alcDefaultAllDeviceSpecifier = strdup(alcAllDeviceList ?
rlm@0:                                               alcAllDeviceList : "");
rlm@0:         if(!alcDefaultAllDeviceSpecifier)
rlm@0:             alcSetError(pDevice, ALC_OUT_OF_MEMORY);
rlm@0:         value = alcDefaultAllDeviceSpecifier;
rlm@0:         break;
rlm@0: 
rlm@0:     case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER:
rlm@0:         if(!alcCaptureDeviceList)
rlm@0:             ProbeCaptureDeviceList();
rlm@0: 
rlm@0:         free(alcCaptureDefaultDeviceSpecifier);
rlm@0:         alcCaptureDefaultDeviceSpecifier = strdup(alcCaptureDeviceList ?
rlm@0:                                                   alcCaptureDeviceList : "");
rlm@0:         if(!alcCaptureDefaultDeviceSpecifier)
rlm@0:             alcSetError(pDevice, ALC_OUT_OF_MEMORY);
rlm@0:         value = alcCaptureDefaultDeviceSpecifier;
rlm@0:         break;
rlm@0: 
rlm@0:     case ALC_EXTENSIONS:
rlm@0:         LockLists();
rlm@0:         if(IsDevice(pDevice))
rlm@0:             value = alcExtensionList;
rlm@0:         else
rlm@0:             value = alcNoDeviceExtList;
rlm@0:         UnlockLists();
rlm@0:         break;
rlm@0: 
rlm@0:     default:
rlm@0:         alcSetError(pDevice, ALC_INVALID_ENUM);
rlm@0:         break;
rlm@0:     }
rlm@0: 
rlm@0:     return value;
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: /*
rlm@0:     alcGetIntegerv
rlm@0: 
rlm@0:     Returns information about the Device and the version of Open AL
rlm@0: */
rlm@0: ALC_API ALCvoid ALC_APIENTRY alcGetIntegerv(ALCdevice *device,ALCenum param,ALsizei size,ALCint *data)
rlm@0: {
rlm@0:     if(size == 0 || data == NULL)
rlm@0:     {
rlm@0:         alcSetError(device, ALC_INVALID_VALUE);
rlm@0:         return;
rlm@0:     }
rlm@0: 
rlm@0:     LockLists();
rlm@0:     if(!IsDevice(device))
rlm@0:     {
rlm@0:         switch(param)
rlm@0:         {
rlm@0:             case ALC_MAJOR_VERSION:
rlm@0:                 *data = alcMajorVersion;
rlm@0:                 break;
rlm@0:             case ALC_MINOR_VERSION:
rlm@0:                 *data = alcMinorVersion;
rlm@0:                 break;
rlm@0: 
rlm@0:             case ALC_ATTRIBUTES_SIZE:
rlm@0:             case ALC_ALL_ATTRIBUTES:
rlm@0:             case ALC_FREQUENCY:
rlm@0:             case ALC_REFRESH:
rlm@0:             case ALC_SYNC:
rlm@0:             case ALC_MONO_SOURCES:
rlm@0:             case ALC_STEREO_SOURCES:
rlm@0:             case ALC_CAPTURE_SAMPLES:
rlm@0:             case ALC_FORMAT_CHANNELS_SOFT:
rlm@0:             case ALC_FORMAT_TYPE_SOFT:
rlm@0:                 alcSetError(NULL, ALC_INVALID_DEVICE);
rlm@0:                 break;
rlm@0: 
rlm@0:             default:
rlm@0:                 alcSetError(NULL, ALC_INVALID_ENUM);
rlm@0:                 break;
rlm@0:         }
rlm@0:     }
rlm@0:     else if(device->IsCaptureDevice)
rlm@0:     {
rlm@0:         switch(param)
rlm@0:         {
rlm@0:             case ALC_CAPTURE_SAMPLES:
rlm@0:                 LockDevice(device);
rlm@0:                 *data = ALCdevice_AvailableSamples(device);
rlm@0:                 UnlockDevice(device);
rlm@0:                 break;
rlm@0: 
rlm@0:             case ALC_CONNECTED:
rlm@0:                 *data = device->Connected;
rlm@0:                 break;
rlm@0: 
rlm@0:             default:
rlm@0:                 alcSetError(device, ALC_INVALID_ENUM);
rlm@0:                 break;
rlm@0:         }
rlm@0:     }
rlm@0:     else /* render device */
rlm@0:     {
rlm@0:         switch(param)
rlm@0:         {
rlm@0:             case ALC_MAJOR_VERSION:
rlm@0:                 *data = alcMajorVersion;
rlm@0:                 break;
rlm@0: 
rlm@0:             case ALC_MINOR_VERSION:
rlm@0:                 *data = alcMinorVersion;
rlm@0:                 break;
rlm@0: 
rlm@0:             case ALC_EFX_MAJOR_VERSION:
rlm@0:                 *data = alcEFXMajorVersion;
rlm@0:                 break;
rlm@0: 
rlm@0:             case ALC_EFX_MINOR_VERSION:
rlm@0:                 *data = alcEFXMinorVersion;
rlm@0:                 break;
rlm@0: 
rlm@0:             case ALC_ATTRIBUTES_SIZE:
rlm@0:                 *data = 13;
rlm@0:                 break;
rlm@0: 
rlm@0:             case ALC_ALL_ATTRIBUTES:
rlm@0:                 if(size < 13)
rlm@0:                     alcSetError(device, ALC_INVALID_VALUE);
rlm@0:                 else
rlm@0:                 {
rlm@0:                     int i = 0;
rlm@0: 
rlm@0:                     data[i++] = ALC_FREQUENCY;
rlm@0:                     data[i++] = device->Frequency;
rlm@0: 
rlm@0:                     if(!device->IsLoopbackDevice)
rlm@0:                     {
rlm@0:                         data[i++] = ALC_REFRESH;
rlm@0:                         data[i++] = device->Frequency / device->UpdateSize;
rlm@0: 
rlm@0:                         data[i++] = ALC_SYNC;
rlm@0:                         data[i++] = ALC_FALSE;
rlm@0:                     }
rlm@0:                     else
rlm@0:                     {
rlm@0:                         data[i++] = ALC_FORMAT_CHANNELS_SOFT;
rlm@0:                         data[i++] = device->FmtChans;
rlm@0: 
rlm@0:                         data[i++] = ALC_FORMAT_TYPE_SOFT;
rlm@0:                         data[i++] = device->FmtType;
rlm@0:                     }
rlm@0: 
rlm@0:                     data[i++] = ALC_MONO_SOURCES;
rlm@0:                     data[i++] = device->NumMonoSources;
rlm@0: 
rlm@0:                     data[i++] = ALC_STEREO_SOURCES;
rlm@0:                     data[i++] = device->NumStereoSources;
rlm@0: 
rlm@0:                     data[i++] = ALC_MAX_AUXILIARY_SENDS;
rlm@0:                     data[i++] = device->NumAuxSends;
rlm@0: 
rlm@0:                     data[i++] = 0;
rlm@0:                 }
rlm@0:                 break;
rlm@0: 
rlm@0:             case ALC_FREQUENCY:
rlm@0:                 *data = device->Frequency;
rlm@0:                 break;
rlm@0: 
rlm@0:             case ALC_REFRESH:
rlm@0:                 if(device->IsLoopbackDevice)
rlm@0:                     alcSetError(device, ALC_INVALID_DEVICE);
rlm@0:                 else
rlm@0:                     *data = device->Frequency / device->UpdateSize;
rlm@0:                 break;
rlm@0: 
rlm@0:             case ALC_SYNC:
rlm@0:                 if(device->IsLoopbackDevice)
rlm@0:                     alcSetError(device, ALC_INVALID_DEVICE);
rlm@0:                 else
rlm@0:                     *data = ALC_FALSE;
rlm@0:                 break;
rlm@0: 
rlm@0:             case ALC_FORMAT_CHANNELS_SOFT:
rlm@0:                 if(!device->IsLoopbackDevice)
rlm@0:                     alcSetError(device, ALC_INVALID_DEVICE);
rlm@0:                 else
rlm@0:                     *data = device->FmtChans;
rlm@0:                 break;
rlm@0: 
rlm@0:             case ALC_FORMAT_TYPE_SOFT:
rlm@0:                 if(!device->IsLoopbackDevice)
rlm@0:                     alcSetError(device, ALC_INVALID_DEVICE);
rlm@0:                 else
rlm@0:                     *data = device->FmtType;
rlm@0:                 break;
rlm@0: 
rlm@0:             case ALC_MONO_SOURCES:
rlm@0:                 *data = device->NumMonoSources;
rlm@0:                 break;
rlm@0: 
rlm@0:             case ALC_STEREO_SOURCES:
rlm@0:                 *data = device->NumStereoSources;
rlm@0:                 break;
rlm@0: 
rlm@0:             case ALC_MAX_AUXILIARY_SENDS:
rlm@0:                 *data = device->NumAuxSends;
rlm@0:                 break;
rlm@0: 
rlm@0:             case ALC_CONNECTED:
rlm@0:                 *data = device->Connected;
rlm@0:                 break;
rlm@0: 
rlm@0:             default:
rlm@0:                 alcSetError(device, ALC_INVALID_ENUM);
rlm@0:                 break;
rlm@0:         }
rlm@0:     }
rlm@0:     UnlockLists();
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: /*
rlm@0:     alcIsExtensionPresent
rlm@0: 
rlm@0:     Determines if there is support for a particular extension
rlm@0: */
rlm@0: ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extName)
rlm@0: {
rlm@0:     ALCboolean bResult = ALC_FALSE;
rlm@0:     const char *ptr;
rlm@0:     size_t len;
rlm@0: 
rlm@0:     if(!extName)
rlm@0:     {
rlm@0:         alcSetError(device, ALC_INVALID_VALUE);
rlm@0:         return ALC_FALSE;
rlm@0:     }
rlm@0: 
rlm@0:     len = strlen(extName);
rlm@0:     LockLists();
rlm@0:     ptr = (IsDevice(device) ? alcExtensionList : alcNoDeviceExtList);
rlm@0:     UnlockLists();
rlm@0:     while(ptr && *ptr)
rlm@0:     {
rlm@0:         if(strncasecmp(ptr, extName, len) == 0 &&
rlm@0:            (ptr[len] == '\0' || isspace(ptr[len])))
rlm@0:         {
rlm@0:             bResult = ALC_TRUE;
rlm@0:             break;
rlm@0:         }
rlm@0:         if((ptr=strchr(ptr, ' ')) != NULL)
rlm@0:         {
rlm@0:             do {
rlm@0:                 ++ptr;
rlm@0:             } while(isspace(*ptr));
rlm@0:         }
rlm@0:     }
rlm@0: 
rlm@0:     return bResult;
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: /*
rlm@0:     alcGetProcAddress
rlm@0: 
rlm@0:     Retrieves the function address for a particular extension function
rlm@0: */
rlm@0: ALC_API ALCvoid* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcName)
rlm@0: {
rlm@0:     ALsizei i = 0;
rlm@0: 
rlm@0:     if(!funcName)
rlm@0:     {
rlm@0:         alcSetError(device, ALC_INVALID_VALUE);
rlm@0:         return NULL;
rlm@0:     }
rlm@0: 
rlm@0:     while(alcFunctions[i].funcName && strcmp(alcFunctions[i].funcName,funcName) != 0)
rlm@0:         i++;
rlm@0:     return alcFunctions[i].address;
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: /*
rlm@0:     alcGetEnumValue
rlm@0: 
rlm@0:     Get the value for a particular ALC Enumerated Value
rlm@0: */
rlm@0: ALC_API ALCenum ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumName)
rlm@0: {
rlm@0:     ALsizei i = 0;
rlm@0: 
rlm@0:     if(!enumName)
rlm@0:     {
rlm@0:         alcSetError(device, ALC_INVALID_VALUE);
rlm@0:         return (ALCenum)0;
rlm@0:     }
rlm@0: 
rlm@0:     while(enumeration[i].enumName && strcmp(enumeration[i].enumName,enumName) != 0)
rlm@0:         i++;
rlm@0:     return enumeration[i].value;
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: /*
rlm@0:     alcCreateContext
rlm@0: 
rlm@0:     Create and attach a Context to a particular Device.
rlm@0: */
rlm@0: ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrList)
rlm@0: {
rlm@0:     ALCcontext *ALContext;
rlm@0:     void *temp;
rlm@0: 
rlm@0:     LockLists();
rlm@0:     if(!IsDevice(device) || device->IsCaptureDevice || !device->Connected)
rlm@0:     {
rlm@0:         alcSetError(device, ALC_INVALID_DEVICE);
rlm@0:         UnlockLists();
rlm@0:         return NULL;
rlm@0:     }
rlm@0: 
rlm@0:     // Reset Context Last Error code
rlm@0:     device->LastError = ALC_NO_ERROR;
rlm@0: 
rlm@0:     if(UpdateDeviceParams(device, attrList) == ALC_FALSE)
rlm@0:     {
rlm@0:         alcSetError(device, ALC_INVALID_DEVICE);
rlm@0:         aluHandleDisconnect(device);
rlm@0:         UnlockLists();
rlm@0:         return NULL;
rlm@0:     }
rlm@0: 
rlm@0:     LockDevice(device);
rlm@0:     ALContext = NULL;
rlm@0:     temp = realloc(device->Contexts, (device->NumContexts+1) * sizeof(*device->Contexts));
rlm@0:     if(temp)
rlm@0:     {
rlm@0:         device->Contexts = temp;
rlm@0: 
rlm@0:         ALContext = calloc(1, sizeof(ALCcontext));
rlm@0:         if(ALContext)
rlm@0:         {
rlm@0:             ALContext->MaxActiveSources = 256;
rlm@0:             ALContext->ActiveSources = malloc(sizeof(ALContext->ActiveSources[0]) *
rlm@0:                                               ALContext->MaxActiveSources);
rlm@0:         }
rlm@0:     }
rlm@0:     if(!ALContext || !ALContext->ActiveSources)
rlm@0:     {
rlm@0:         free(ALContext);
rlm@0:         alcSetError(device, ALC_OUT_OF_MEMORY);
rlm@0:         UnlockDevice(device);
rlm@0:         if(device->NumContexts == 0)
rlm@0:         {
rlm@0:             ALCdevice_StopPlayback(device);
rlm@0:             device->Flags &= ~DEVICE_RUNNING;
rlm@0:         }
rlm@0:         UnlockLists();
rlm@0:         return NULL;
rlm@0:     }
rlm@0: 
rlm@0:     device->Contexts[device->NumContexts++] = ALContext;
rlm@0:     ALContext->Device = device;
rlm@0: 
rlm@0:     InitContext(ALContext);
rlm@0:     UnlockDevice(device);
rlm@0: 
rlm@0:     ALContext->next = g_pContextList;
rlm@0:     g_pContextList = ALContext;
rlm@0:     g_ulContextCount++;
rlm@0: 
rlm@0:     UnlockLists();
rlm@0: 
rlm@0:     return ALContext;
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: /*
rlm@0:     alcDestroyContext
rlm@0: 
rlm@0:     Remove a Context
rlm@0: */
rlm@0: ALC_API ALCvoid ALC_APIENTRY alcDestroyContext(ALCcontext *context)
rlm@0: {
rlm@0:     ALCdevice *Device;
rlm@0:     ALCcontext **list;
rlm@0:     ALuint i;
rlm@0: 
rlm@0:     LockLists();
rlm@0:     list = &g_pContextList;
rlm@0:     while(*list && *list != context)
rlm@0:         list = &(*list)->next;
rlm@0: 
rlm@0:     if(!*list)
rlm@0:     {
rlm@0:         alcSetError(NULL, ALC_INVALID_CONTEXT);
rlm@0:         UnlockLists();
rlm@0:         return;
rlm@0:     }
rlm@0: 
rlm@0:     *list = (*list)->next;
rlm@0:     g_ulContextCount--;
rlm@0: 
rlm@0:     if(context == tls_get(LocalContext))
rlm@0:         tls_set(LocalContext, NULL);
rlm@0:     if(context == GlobalContext)
rlm@0:         GlobalContext = NULL;
rlm@0: 
rlm@0:     Device = context->Device;
rlm@0:     LockDevice(Device);
rlm@0:     for(i = 0;i < Device->NumContexts;i++)
rlm@0:     {
rlm@0:         if(Device->Contexts[i] == context)
rlm@0:         {
rlm@0:             Device->Contexts[i] = Device->Contexts[Device->NumContexts-1];
rlm@0:             Device->NumContexts--;
rlm@0:             break;
rlm@0:         }
rlm@0:     }
rlm@0:     UnlockDevice(Device);
rlm@0: 
rlm@0:     if(Device->NumContexts == 0)
rlm@0:     {
rlm@0:         ALCdevice_StopPlayback(Device);
rlm@0:         Device->Flags &= ~DEVICE_RUNNING;
rlm@0:     }
rlm@0:     UnlockLists();
rlm@0: 
rlm@0:     if(context->SourceMap.size > 0)
rlm@0:     {
rlm@0:         ERR("alcDestroyContext(): deleting %d Source(s)\n", context->SourceMap.size);
rlm@0:         ReleaseALSources(context);
rlm@0:     }
rlm@0:     ResetUIntMap(&context->SourceMap);
rlm@0: 
rlm@0:     if(context->EffectSlotMap.size > 0)
rlm@0:     {
rlm@0:         ERR("alcDestroyContext(): deleting %d AuxiliaryEffectSlot(s)\n", context->EffectSlotMap.size);
rlm@0:         ReleaseALAuxiliaryEffectSlots(context);
rlm@0:     }
rlm@0:     ResetUIntMap(&context->EffectSlotMap);
rlm@0: 
rlm@0:     free(context->ActiveSources);
rlm@0:     context->ActiveSources = NULL;
rlm@0:     context->MaxActiveSources = 0;
rlm@0:     context->ActiveSourceCount = 0;
rlm@0: 
rlm@0:     FreeContext(context);
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: /*
rlm@0:     alcGetCurrentContext
rlm@0: 
rlm@0:     Returns the currently active Context
rlm@0: */
rlm@0: ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(ALCvoid)
rlm@0: {
rlm@0:     ALCcontext *Context;
rlm@0: 
rlm@0:     LockLists();
rlm@0:     Context = tls_get(LocalContext);
rlm@0:     if(Context && !IsContext(Context))
rlm@0:     {
rlm@0:         tls_set(LocalContext, NULL);
rlm@0:         Context = NULL;
rlm@0:     }
rlm@0:     if(!Context)
rlm@0:         Context = GlobalContext;
rlm@0:     UnlockLists();
rlm@0: 
rlm@0:     return Context;
rlm@0: }
rlm@0: 
rlm@0: /*
rlm@0:     alcGetThreadContext
rlm@0: 
rlm@0:     Returns the currently active thread-local Context
rlm@0: */
rlm@0: ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void)
rlm@0: {
rlm@0:     ALCcontext *pContext = NULL;
rlm@0: 
rlm@0:     LockLists();
rlm@0: 
rlm@0:     pContext = tls_get(LocalContext);
rlm@0:     if(pContext && !IsContext(pContext))
rlm@0:     {
rlm@0:         tls_set(LocalContext, NULL);
rlm@0:         pContext = NULL;
rlm@0:     }
rlm@0: 
rlm@0:     UnlockLists();
rlm@0: 
rlm@0:     return pContext;
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: /*
rlm@0:     alcGetContextsDevice
rlm@0: 
rlm@0:     Returns the Device that a particular Context is attached to
rlm@0: */
rlm@0: ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice(ALCcontext *pContext)
rlm@0: {
rlm@0:     ALCdevice *pDevice = NULL;
rlm@0: 
rlm@0:     LockLists();
rlm@0:     if(IsContext(pContext))
rlm@0:         pDevice = pContext->Device;
rlm@0:     else
rlm@0:         alcSetError(NULL, ALC_INVALID_CONTEXT);
rlm@0:     UnlockLists();
rlm@0: 
rlm@0:     return pDevice;
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: /*
rlm@0:     alcMakeContextCurrent
rlm@0: 
rlm@0:     Makes the given Context the active Context
rlm@0: */
rlm@0: ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context)
rlm@0: {
rlm@0:     ALboolean bReturn = AL_TRUE;
rlm@0: 
rlm@0:     LockLists();
rlm@0: 
rlm@0:     // context must be a valid Context or NULL
rlm@0:     if(context == NULL || IsContext(context))
rlm@0:     {
rlm@0:         GlobalContext = context;
rlm@0:         tls_set(LocalContext, NULL);
rlm@0:     }
rlm@0:     else
rlm@0:     {
rlm@0:         alcSetError(NULL, ALC_INVALID_CONTEXT);
rlm@0:         bReturn = AL_FALSE;
rlm@0:     }
rlm@0: 
rlm@0:     UnlockLists();
rlm@0: 
rlm@0:     return bReturn;
rlm@0: }
rlm@0: 
rlm@0: /*
rlm@0:     alcSetThreadContext
rlm@0: 
rlm@0:     Makes the given Context the active Context for the current thread
rlm@0: */
rlm@0: ALC_API ALCboolean ALC_APIENTRY alcSetThreadContext(ALCcontext *context)
rlm@0: {
rlm@0:     ALboolean bReturn = AL_TRUE;
rlm@0: 
rlm@0:     LockLists();
rlm@0: 
rlm@0:     // context must be a valid Context or NULL
rlm@0:     if(context == NULL || IsContext(context))
rlm@0:         tls_set(LocalContext, context);
rlm@0:     else
rlm@0:     {
rlm@0:         alcSetError(NULL, ALC_INVALID_CONTEXT);
rlm@0:         bReturn = AL_FALSE;
rlm@0:     }
rlm@0: 
rlm@0:     UnlockLists();
rlm@0: 
rlm@0:     return bReturn;
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: static void GetFormatFromString(const char *str, enum DevFmtChannels *chans, enum DevFmtType *type)
rlm@0: {
rlm@0:     if(strcasecmp(str, "AL_FORMAT_MONO32") == 0)
rlm@0:     {
rlm@0:         *chans = DevFmtMono;
rlm@0:         *type = DevFmtFloat;
rlm@0:         return;
rlm@0:     }
rlm@0:     if(strcasecmp(str, "AL_FORMAT_STEREO32") == 0)
rlm@0:     {
rlm@0:         *chans = DevFmtStereo;
rlm@0:         *type = DevFmtFloat;
rlm@0:         return;
rlm@0:     }
rlm@0:     if(strcasecmp(str, "AL_FORMAT_QUAD32") == 0)
rlm@0:     {
rlm@0:         *chans = DevFmtQuad;
rlm@0:         *type = DevFmtFloat;
rlm@0:         return;
rlm@0:     }
rlm@0:     if(strcasecmp(str, "AL_FORMAT_51CHN32") == 0)
rlm@0:     {
rlm@0:         *chans = DevFmtX51;
rlm@0:         *type = DevFmtFloat;
rlm@0:         return;
rlm@0:     }
rlm@0:     if(strcasecmp(str, "AL_FORMAT_61CHN32") == 0)
rlm@0:     {
rlm@0:         *chans = DevFmtX61;
rlm@0:         *type = DevFmtFloat;
rlm@0:         return;
rlm@0:     }
rlm@0:     if(strcasecmp(str, "AL_FORMAT_71CHN32") == 0)
rlm@0:     {
rlm@0:         *chans = DevFmtX71;
rlm@0:         *type = DevFmtFloat;
rlm@0:         return;
rlm@0:     }
rlm@0: 
rlm@0:     if(strcasecmp(str, "AL_FORMAT_MONO16") == 0)
rlm@0:     {
rlm@0:         *chans = DevFmtMono;
rlm@0:         *type = DevFmtShort;
rlm@0:         return;
rlm@0:     }
rlm@0:     if(strcasecmp(str, "AL_FORMAT_STEREO16") == 0)
rlm@0:     {
rlm@0:         *chans = DevFmtStereo;
rlm@0:         *type = DevFmtShort;
rlm@0:         return;
rlm@0:     }
rlm@0:     if(strcasecmp(str, "AL_FORMAT_QUAD16") == 0)
rlm@0:     {
rlm@0:         *chans = DevFmtQuad;
rlm@0:         *type = DevFmtShort;
rlm@0:         return;
rlm@0:     }
rlm@0:     if(strcasecmp(str, "AL_FORMAT_51CHN16") == 0)
rlm@0:     {
rlm@0:         *chans = DevFmtX51;
rlm@0:         *type = DevFmtShort;
rlm@0:         return;
rlm@0:     }
rlm@0:     if(strcasecmp(str, "AL_FORMAT_61CHN16") == 0)
rlm@0:     {
rlm@0:         *chans = DevFmtX61;
rlm@0:         *type = DevFmtShort;
rlm@0:         return;
rlm@0:     }
rlm@0:     if(strcasecmp(str, "AL_FORMAT_71CHN16") == 0)
rlm@0:     {
rlm@0:         *chans = DevFmtX71;
rlm@0:         *type = DevFmtShort;
rlm@0:         return;
rlm@0:     }
rlm@0: 
rlm@0:     if(strcasecmp(str, "AL_FORMAT_MONO8") == 0)
rlm@0:     {
rlm@0:         *chans = DevFmtMono;
rlm@0:         *type = DevFmtByte;
rlm@0:         return;
rlm@0:     }
rlm@0:     if(strcasecmp(str, "AL_FORMAT_STEREO8") == 0)
rlm@0:     {
rlm@0:         *chans = DevFmtStereo;
rlm@0:         *type = DevFmtByte;
rlm@0:         return;
rlm@0:     }
rlm@0:     if(strcasecmp(str, "AL_FORMAT_QUAD8") == 0)
rlm@0:     {
rlm@0:         *chans = DevFmtQuad;
rlm@0:         *type = DevFmtByte;
rlm@0:         return;
rlm@0:     }
rlm@0:     if(strcasecmp(str, "AL_FORMAT_51CHN8") == 0)
rlm@0:     {
rlm@0:         *chans = DevFmtX51;
rlm@0:         *type = DevFmtByte;
rlm@0:         return;
rlm@0:     }
rlm@0:     if(strcasecmp(str, "AL_FORMAT_61CHN8") == 0)
rlm@0:     {
rlm@0:         *chans = DevFmtX61;
rlm@0:         *type = DevFmtByte;
rlm@0:         return;
rlm@0:     }
rlm@0:     if(strcasecmp(str, "AL_FORMAT_71CHN8") == 0)
rlm@0:     {
rlm@0:         *chans = DevFmtX71;
rlm@0:         *type = DevFmtByte;
rlm@0:         return;
rlm@0:     }
rlm@0: 
rlm@0:     ERR("Unknown format: \"%s\"\n", str);
rlm@0:     *chans = DevFmtStereo;
rlm@0:     *type = DevFmtShort;
rlm@0: }
rlm@0: 
rlm@0: /*
rlm@0:     alcOpenDevice
rlm@0: 
rlm@0:     Open the Device specified.
rlm@0: */
rlm@0: ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *deviceName)
rlm@0: {
rlm@0:     const ALCchar *fmt;
rlm@0:     ALCdevice *device;
rlm@0: 
rlm@0:     DO_INITCONFIG();
rlm@0: 
rlm@0:     if(!PlaybackBackend.name)
rlm@0:     {
rlm@0:         alcSetError(NULL, ALC_INVALID_VALUE);
rlm@0:         return NULL;
rlm@0:     }
rlm@0: 
rlm@0:     if(deviceName && (!deviceName[0] || strcasecmp(deviceName, "openal soft") == 0 || strcasecmp(deviceName, "openal-soft") == 0))
rlm@0:         deviceName = NULL;
rlm@0: 
rlm@0:     device = calloc(1, sizeof(ALCdevice));
rlm@0:     if(!device)
rlm@0:     {
rlm@0:         alcSetError(NULL, ALC_OUT_OF_MEMORY);
rlm@0:         return NULL;
rlm@0:     }
rlm@0: 
rlm@0:     //Validate device
rlm@0:     device->Funcs = &PlaybackBackend.Funcs;
rlm@0:     device->Connected = ALC_TRUE;
rlm@0:     device->IsCaptureDevice = AL_FALSE;
rlm@0:     device->IsLoopbackDevice = AL_FALSE;
rlm@0:     InitializeCriticalSection(&device->Mutex);
rlm@0:     device->LastError = ALC_NO_ERROR;
rlm@0: 
rlm@0:     device->Flags = 0;
rlm@0:     device->Bs2b = NULL;
rlm@0:     device->szDeviceName = NULL;
rlm@0: 
rlm@0:     device->Contexts = NULL;
rlm@0:     device->NumContexts = 0;
rlm@0: 
rlm@0:     InitUIntMap(&device->BufferMap);
rlm@0:     InitUIntMap(&device->EffectMap);
rlm@0:     InitUIntMap(&device->FilterMap);
rlm@0: 
rlm@0:     //Set output format
rlm@0:     if(ConfigValueExists(NULL, "frequency"))
rlm@0:         device->Flags |= DEVICE_FREQUENCY_REQUEST;
rlm@0:     device->Frequency = GetConfigValueInt(NULL, "frequency", DEFAULT_OUTPUT_RATE);
rlm@0:     if(device->Frequency < 8000)
rlm@0:         device->Frequency = 8000;
rlm@0: 
rlm@0:     if(ConfigValueExists(NULL, "format"))
rlm@0:         device->Flags |= DEVICE_CHANNELS_REQUEST;
rlm@14:     //fmt = GetConfigValue(NULL, "format", "AL_FORMAT_STEREO16");
rlm@14:     //RLM: audio-send only supports 16 bit mono output for now,
rlm@14:     //pending bug fixes.
rlm@14:     fmt = "AL_FORMAT_MONO16";
rlm@0:     GetFormatFromString(fmt, &device->FmtChans, &device->FmtType);
rlm@0: 
rlm@0:     device->NumUpdates = GetConfigValueInt(NULL, "periods", 4);
rlm@0:     if(device->NumUpdates < 2)
rlm@0:         device->NumUpdates = 4;
rlm@0: 
rlm@0:     device->UpdateSize = GetConfigValueInt(NULL, "period_size", 1024);
rlm@0:     if(device->UpdateSize <= 0)
rlm@0:         device->UpdateSize = 1024;
rlm@0: 
rlm@0:     device->MaxNoOfSources = GetConfigValueInt(NULL, "sources", 256);
rlm@0:     if(device->MaxNoOfSources <= 0)
rlm@0:         device->MaxNoOfSources = 256;
rlm@0: 
rlm@0:     device->AuxiliaryEffectSlotMax = GetConfigValueInt(NULL, "slots", 4);
rlm@0:     if(device->AuxiliaryEffectSlotMax <= 0)
rlm@0:         device->AuxiliaryEffectSlotMax = 4;
rlm@0: 
rlm@0:     device->NumStereoSources = 1;
rlm@0:     device->NumMonoSources = device->MaxNoOfSources - device->NumStereoSources;
rlm@0: 
rlm@0:     device->NumAuxSends = GetConfigValueInt(NULL, "sends", MAX_SENDS);
rlm@0:     if(device->NumAuxSends > MAX_SENDS)
rlm@0:         device->NumAuxSends = MAX_SENDS;
rlm@0: 
rlm@0:     device->Bs2bLevel = GetConfigValueInt(NULL, "cf_level", 0);
rlm@0: 
rlm@0:     // Find a playback device to open
rlm@0:     LockLists();
rlm@0:     if(ALCdevice_OpenPlayback(device, deviceName))
rlm@0:     {
rlm@0:         device->next = g_pDeviceList;
rlm@0:         g_pDeviceList = device;
rlm@0:         g_ulDeviceCount++;
rlm@0:     }
rlm@0:     else
rlm@0:     {
rlm@0:         // No suitable output device found
rlm@0:         DeleteCriticalSection(&device->Mutex);
rlm@0:         free(device);
rlm@0:         device = NULL;
rlm@0:         alcSetError(NULL, ALC_INVALID_VALUE);
rlm@0:     }
rlm@0:     UnlockLists();
rlm@0: 
rlm@0:     return device;
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: /*
rlm@0:     alcCloseDevice
rlm@0: 
rlm@0:     Close the specified Device
rlm@0: */
rlm@0: ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *pDevice)
rlm@0: {
rlm@0:     ALCdevice **list;
rlm@0: 
rlm@0:     LockLists();
rlm@0:     list = &g_pDeviceList;
rlm@0:     while(*list && *list != pDevice)
rlm@0:         list = &(*list)->next;
rlm@0: 
rlm@0:     if(!*list || (*list)->IsCaptureDevice)
rlm@0:     {
rlm@0:         alcSetError(*list, ALC_INVALID_DEVICE);
rlm@0:         UnlockLists();
rlm@0:         return ALC_FALSE;
rlm@0:     }
rlm@0: 
rlm@0:     *list = (*list)->next;
rlm@0:     g_ulDeviceCount--;
rlm@0: 
rlm@0:     UnlockLists();
rlm@0: 
rlm@0:     if(pDevice->NumContexts > 0)
rlm@0:     {
rlm@0:         WARN("alcCloseDevice(): destroying %u Context(s)\n", pDevice->NumContexts);
rlm@0:         while(pDevice->NumContexts > 0)
rlm@0:             alcDestroyContext(pDevice->Contexts[0]);
rlm@0:     }
rlm@0:     ALCdevice_ClosePlayback(pDevice);
rlm@0: 
rlm@0:     if(pDevice->BufferMap.size > 0)
rlm@0:     {
rlm@0:         WARN("alcCloseDevice(): deleting %d Buffer(s)\n", pDevice->BufferMap.size);
rlm@0:         ReleaseALBuffers(pDevice);
rlm@0:     }
rlm@0:     ResetUIntMap(&pDevice->BufferMap);
rlm@0: 
rlm@0:     if(pDevice->EffectMap.size > 0)
rlm@0:     {
rlm@0:         WARN("alcCloseDevice(): deleting %d Effect(s)\n", pDevice->EffectMap.size);
rlm@0:         ReleaseALEffects(pDevice);
rlm@0:     }
rlm@0:     ResetUIntMap(&pDevice->EffectMap);
rlm@0: 
rlm@0:     if(pDevice->FilterMap.size > 0)
rlm@0:     {
rlm@0:         WARN("alcCloseDevice(): deleting %d Filter(s)\n", pDevice->FilterMap.size);
rlm@0:         ReleaseALFilters(pDevice);
rlm@0:     }
rlm@0:     ResetUIntMap(&pDevice->FilterMap);
rlm@0: 
rlm@0:     free(pDevice->Bs2b);
rlm@0:     pDevice->Bs2b = NULL;
rlm@0: 
rlm@0:     free(pDevice->szDeviceName);
rlm@0:     pDevice->szDeviceName = NULL;
rlm@0: 
rlm@0:     free(pDevice->Contexts);
rlm@0:     pDevice->Contexts = NULL;
rlm@0: 
rlm@0:     DeleteCriticalSection(&pDevice->Mutex);
rlm@0: 
rlm@0:     //Release device structure
rlm@0:     memset(pDevice, 0, sizeof(ALCdevice));
rlm@0:     free(pDevice);
rlm@0: 
rlm@0:     return ALC_TRUE;
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(void)
rlm@0: {
rlm@0:     ALCdevice *device;
rlm@0: 
rlm@0:     DO_INITCONFIG();
rlm@0: 
rlm@0:     device = calloc(1, sizeof(ALCdevice));
rlm@0:     if(!device)
rlm@0:     {
rlm@0:         alcSetError(NULL, ALC_OUT_OF_MEMORY);
rlm@0:         return NULL;
rlm@0:     }
rlm@0: 
rlm@0:     //Validate device
rlm@0:     device->Funcs = &BackendLoopback.Funcs;
rlm@0:     device->Connected = ALC_TRUE;
rlm@0:     device->IsCaptureDevice = AL_FALSE;
rlm@0:     device->IsLoopbackDevice = AL_TRUE;
rlm@0:     InitializeCriticalSection(&device->Mutex);
rlm@0:     device->LastError = ALC_NO_ERROR;
rlm@0: 
rlm@0:     device->Flags = 0;
rlm@0:     device->Bs2b = NULL;
rlm@0:     device->szDeviceName = NULL;
rlm@0: 
rlm@0:     device->Contexts = NULL;
rlm@0:     device->NumContexts = 0;
rlm@0: 
rlm@0:     InitUIntMap(&device->BufferMap);
rlm@0:     InitUIntMap(&device->EffectMap);
rlm@0:     InitUIntMap(&device->FilterMap);
rlm@0: 
rlm@0:     //Set output format
rlm@0:     device->Frequency = 44100;
rlm@0:     device->FmtChans = DevFmtStereo;
rlm@0:     device->FmtType = DevFmtShort;
rlm@0: 
rlm@0:     device->NumUpdates = 0;
rlm@0:     device->UpdateSize = 0;
rlm@0: 
rlm@0:     device->MaxNoOfSources = GetConfigValueInt(NULL, "sources", 256);
rlm@0:     if(device->MaxNoOfSources <= 0)
rlm@0:         device->MaxNoOfSources = 256;
rlm@0: 
rlm@0:     device->AuxiliaryEffectSlotMax = GetConfigValueInt(NULL, "slots", 4);
rlm@0:     if(device->AuxiliaryEffectSlotMax <= 0)
rlm@0:         device->AuxiliaryEffectSlotMax = 4;
rlm@0: 
rlm@0:     device->NumStereoSources = 1;
rlm@0:     device->NumMonoSources = device->MaxNoOfSources - device->NumStereoSources;
rlm@0: 
rlm@0:     device->NumAuxSends = GetConfigValueInt(NULL, "sends", MAX_SENDS);
rlm@0:     if(device->NumAuxSends > MAX_SENDS)
rlm@0:         device->NumAuxSends = MAX_SENDS;
rlm@0: 
rlm@0:     device->Bs2bLevel = GetConfigValueInt(NULL, "cf_level", 0);
rlm@0: 
rlm@0:     // Open the "backend"
rlm@0:     LockLists();
rlm@0:     ALCdevice_OpenPlayback(device, "Loopback");
rlm@0: 
rlm@0:     device->next = g_pDeviceList;
rlm@0:     g_pDeviceList = device;
rlm@0:     g_ulDeviceCount++;
rlm@0:     UnlockLists();
rlm@0: 
rlm@0:     return device;
rlm@0: }
rlm@0: 
rlm@0: ALC_API ALCboolean ALC_APIENTRY alcIsRenderFormatSupportedSOFT(ALCdevice *device, ALCsizei freq, ALCenum channels, ALCenum type)
rlm@0: {
rlm@0:     ALCboolean ret = ALC_FALSE;
rlm@0: 
rlm@0:     LockLists();
rlm@0:     if(!IsDevice(device) || !device->IsLoopbackDevice)
rlm@0:         alcSetError(device, ALC_INVALID_DEVICE);
rlm@0:     else if(freq <= 0)
rlm@0:         alcSetError(device, ALC_INVALID_VALUE);
rlm@0:     else if(!IsValidALCType(type) || !IsValidALCChannels(channels))
rlm@0:         alcSetError(device, ALC_INVALID_ENUM);
rlm@0:     else
rlm@0:     {
rlm@0:         if(BytesFromDevFmt(type) > 0 && ChannelsFromDevFmt(channels) > 0 &&
rlm@0:            freq >= 8000)
rlm@0:             ret = ALC_TRUE;
rlm@0:     }
rlm@0:     UnlockLists();
rlm@0: 
rlm@0:     return ret;
rlm@0: }
rlm@0: 
rlm@0: ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
rlm@0: {
rlm@0:     LockLists();
rlm@0:     if(!IsDevice(device) || !device->IsLoopbackDevice)
rlm@0:         alcSetError(device, ALC_INVALID_DEVICE);
rlm@0:     else if(samples < 0 || (samples > 0 && buffer == NULL))
rlm@0:         alcSetError(device, ALC_INVALID_VALUE);
rlm@0:     else
rlm@0:         aluMixData(device, buffer, samples);
rlm@0:     UnlockLists();
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: static void ReleaseALC(ALCboolean doclose)
rlm@0: {
rlm@0:     free(alcDeviceList); alcDeviceList = NULL;
rlm@0:     alcDeviceListSize = 0;
rlm@0:     free(alcAllDeviceList); alcAllDeviceList = NULL;
rlm@0:     alcAllDeviceListSize = 0;
rlm@0:     free(alcCaptureDeviceList); alcCaptureDeviceList = NULL;
rlm@0:     alcCaptureDeviceListSize = 0;
rlm@0: 
rlm@0:     free(alcDefaultDeviceSpecifier);
rlm@0:     alcDefaultDeviceSpecifier = NULL;
rlm@0:     free(alcDefaultAllDeviceSpecifier);
rlm@0:     alcDefaultAllDeviceSpecifier = NULL;
rlm@0:     free(alcCaptureDefaultDeviceSpecifier);
rlm@0:     alcCaptureDefaultDeviceSpecifier = NULL;
rlm@0: 
rlm@0:     if(doclose)
rlm@0:     {
rlm@0:         if(g_ulDeviceCount > 0)
rlm@0:             WARN("ReleaseALC(): closing %u Device%s\n", g_ulDeviceCount, (g_ulDeviceCount>1)?"s":"");
rlm@0: 
rlm@0:         while(g_pDeviceList)
rlm@0:         {
rlm@0:             if(g_pDeviceList->IsCaptureDevice)
rlm@0:                 alcCaptureCloseDevice(g_pDeviceList);
rlm@0:             else
rlm@0:                 alcCloseDevice(g_pDeviceList);
rlm@0:         }
rlm@0:     }
rlm@0:     else
rlm@0:     {
rlm@0:         if(g_ulDeviceCount > 0)
rlm@0:             WARN("ReleaseALC(): %u Device%s not closed\n", g_ulDeviceCount, (g_ulDeviceCount>1)?"s":"");
rlm@0:     }
rlm@0: }
rlm@0: 
rlm@0: ///////////////////////////////////////////////////////