diff options
Diffstat (limited to 'Router/alc.cpp')
| -rw-r--r-- | Router/alc.cpp | 2332 |
1 files changed, 0 insertions, 2332 deletions
diff --git a/Router/alc.cpp b/Router/alc.cpp deleted file mode 100644 index c4abff8c..00000000 --- a/Router/alc.cpp +++ /dev/null @@ -1,2332 +0,0 @@ -/** - * OpenAL cross platform audio library - * Copyright (C) 1999-2000 by authors. - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Library General Public License for more details. - * - * You should have received a copy of the GNU Library General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. - * Or go to http://www.gnu.org/copyleft/lgpl.html - */ - -#ifndef __MINGW32__ -#define _CRT_SECURE_NO_DEPRECATE // get rid of sprintf security warnings on VS2005 -#endif - -#include <stdlib.h> -#include <memory.h> -#define AL_BUILD_LIBRARY -#include <al/alc.h> -#include <stdio.h> -#include <tchar.h> -#include <assert.h> - -#include <stddef.h> -#include <windows.h> -#if defined(_MSC_VER) -#include <crtdbg.h> -#else -#define _malloc_dbg(s,x,f,l) malloc(s) -#define _realloc_dbg(p,s,x,f,l) realloc(p,s) -#endif -#include <objbase.h> -#ifndef __MINGW32__ -#include <atlconv.h> -#else -#define T2A(x) x -#endif -#include <mmsystem.h> - -#include "OpenAL32.h" - - -//***************************************************************************** -//***************************************************************************** -// -// Defines -// -//***************************************************************************** -//***************************************************************************** - -typedef struct ALCextension_struct -{ - - const char* ename; - -} ALCextension; - -typedef struct -{ - const char* ename; - ALenum value; - -} ALCRouterEnum; - -typedef struct ALCfunction_struct -{ - - const char* fname; - ALvoid* address; - -} ALCfunction; - - - -//***************************************************************************** -//***************************************************************************** -// -// Global Vars -// -//***************************************************************************** -//***************************************************************************** - -ALlist* alContextList = 0; -ALCcontext* alCurrentContext = 0; - -ALCdevice* g_CaptureDevice = NULL; - -//***************************************************************************** -//***************************************************************************** -// -// Local Vars -// -//***************************************************************************** -//***************************************************************************** - -// -// The values of the enums supported by OpenAL. -// -static ALCRouterEnum alcEnums[] = -{ - // Types - {"ALC_INVALID", ALC_INVALID}, - {"ALC_FALSE", ALC_FALSE}, - {"ALC_TRUE", ALC_TRUE}, - - // ALC Properties - {"ALC_MAJOR_VERSION", ALC_MAJOR_VERSION}, - {"ALC_MINOR_VERSION", ALC_MINOR_VERSION}, - {"ALC_ATTRIBUTES_SIZE", ALC_ATTRIBUTES_SIZE}, - {"ALC_ALL_ATTRIBUTES", ALC_ALL_ATTRIBUTES}, - {"ALC_DEFAULT_DEVICE_SPECIFIER", ALC_DEFAULT_DEVICE_SPECIFIER}, - {"ALC_DEVICE_SPECIFIER", ALC_DEVICE_SPECIFIER}, - {"ALC_EXTENSIONS", ALC_EXTENSIONS}, - {"ALC_FREQUENCY", ALC_FREQUENCY}, - {"ALC_REFRESH", ALC_REFRESH}, - {"ALC_SYNC", ALC_SYNC}, - {"ALC_MONO_SOURCES", ALC_MONO_SOURCES}, - {"ALC_STEREO_SOURCES", ALC_STEREO_SOURCES}, - {"ALC_CAPTURE_DEVICE_SPECIFIER", ALC_CAPTURE_DEVICE_SPECIFIER}, - {"ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER", ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER}, - {"ALC_CAPTURE_SAMPLES", ALC_CAPTURE_SAMPLES}, - - // New Enumeration extension - {"ALC_DEFAULT_ALL_DEVICES_SPECIFIER", ALC_DEFAULT_ALL_DEVICES_SPECIFIER}, - {"ALC_ALL_DEVICES_SPECIFIER", ALC_ALL_DEVICES_SPECIFIER}, - - // ALC Error Message - {"ALC_NO_ERROR", ALC_NO_ERROR}, - {"ALC_INVALID_DEVICE", ALC_INVALID_DEVICE}, - {"ALC_INVALID_CONTEXT", ALC_INVALID_CONTEXT}, - {"ALC_INVALID_ENUM", ALC_INVALID_ENUM}, - {"ALC_INVALID_VALUE", ALC_INVALID_VALUE}, - {"ALC_OUT_OF_MEMORY", ALC_OUT_OF_MEMORY}, - - // Default - {0, (ALenum)0} -}; - -// -// Our function pointers. -// -static ALCfunction alcFunctions[] = -{ - {"alcCreateContext", (ALvoid*)alcCreateContext}, - {"alcMakeContextCurrent", (ALvoid*)alcMakeContextCurrent}, - {"alcProcessContext", (ALvoid*)alcProcessContext}, - {"alcSuspendContext", (ALvoid*)alcSuspendContext}, - {"alcDestroyContext", (ALvoid*)alcDestroyContext}, - {"alcGetCurrentContext", (ALvoid*)alcGetCurrentContext}, - {"alcGetContextsDevice", (ALvoid*)alcGetContextsDevice}, - {"alcOpenDevice", (ALvoid*)alcOpenDevice}, - {"alcCloseDevice", (ALvoid*)alcCloseDevice}, - {"alcGetError", (ALvoid*)alcGetError}, - {"alcIsExtensionPresent", (ALvoid*)alcIsExtensionPresent}, - {"alcGetProcAddress", (ALvoid*)alcGetProcAddress}, - {"alcGetEnumValue", (ALvoid*)alcGetEnumValue}, - {"alcGetString", (ALvoid*)alcGetString}, - {"alcGetIntegerv", (ALvoid*)alcGetIntegerv}, - {"alcCaptureOpenDevice", (ALvoid*)alcCaptureOpenDevice}, - {"alcCaptureCloseDevice", (ALvoid*)alcCaptureCloseDevice}, - {"alcCaptureStart", (ALvoid*)alcCaptureStart}, - {"alcCaptureStop", (ALvoid*)alcCaptureStop}, - {"alcCaptureSamples", (ALvoid*)alcCaptureSamples}, - {0, (ALvoid*)0} -}; - -// -// Our extensions. -// -static ALCextension alcExtensions[] = -{ - "ALC_ENUMERATION_EXT", - "ALC_ENUMERATE_ALL_EXT", - "ALC_EXT_CAPTURE", - 0 -}; - - -// Error strings -static ALenum LastError = ALC_NO_ERROR; -static const ALCchar alcNoError[] = "No Error"; -static const ALCchar alcErrInvalidDevice[] = "Invalid Device"; -static const ALCchar alcErrInvalidContext[] = "Invalid Context"; -static const ALCchar alcErrInvalidEnum[] = "Invalid Enum"; -static const ALCchar alcErrInvalidValue[] = "Invalid Value"; - -static ALint alcMajorVersion = 1; -static ALint alcMinorVersion = 1; - -// Enumeration stuff -ALDEVICE *g_pDeviceList = NULL; // ALC_ENUMERATION_EXT Device List -ALDEVICE *g_pCaptureDeviceList = NULL; // ALC_ENUMERATION_EXT Capture Device List -ALDEVICE *g_pAllDevicesList = NULL; // ALC_ENUMERATE_ALL_EXT Device List - -ALchar *pszDefaultDeviceSpecifier = NULL; -ALchar *pszDeviceSpecifierList = NULL; -ALchar *pszDefaultCaptureDeviceSpecifier = NULL; -ALchar *pszCaptureDeviceSpecifierList = NULL; -ALchar *pszDefaultAllDevicesSpecifier = NULL; -ALchar *pszAllDevicesSpecifierList = NULL; -ALchar szEmptyString[] = ""; - -typedef BOOL (CALLBACK *LPDSENUMCALLBACKA)(LPGUID, LPCSTR, LPCSTR, LPVOID); -typedef HRESULT (WINAPI *LPDIRECTSOUNDENUMERATEA)(LPDSENUMCALLBACKA pDSEnumCallback, LPVOID pContext); -typedef HRESULT (WINAPI *LPDIRECTSOUNDCAPTUREENUMERATEA)(LPDSENUMCALLBACKA pDSEnumCallback, LPVOID pContext); - -BOOL CALLBACK DSEnumCallback(LPGUID lpGuid, LPCSTR lpcstrDescription, LPCSTR lpcstrModule, LPVOID lpContext); -bool GetDefaultPlaybackDeviceName(char **pszName); -bool GetDefaultCaptureDeviceName(char **pszName); -bool FindDevice(ALDEVICE *pDeviceList, char *szDeviceName, bool bExactMatch, char **ppszDefaultName); -bool HasDLLAlreadyBeenUsed(ALDEVICE *pDeviceList, TCHAR *szDLLName); -//bool ValidCaptureDevice(const char *szCaptureDeviceName); - -//***************************************************************************** -//***************************************************************************** -// -// Logging Options -// -//***************************************************************************** -//***************************************************************************** - -// NOTE : LOG macro below requires a compiler newer than Visual Studio 6 - -//#define _LOGCALLS - -#ifdef _LOGCALLS - void OutputMessage(const char *szTest,...); - #define LOG(x, ...) OutputMessage(x, ##__VA_ARGS__) - #define LOGFILENAME "OpenALCalls.txt" -#endif - -//***************************************************************************** -//***************************************************************************** -// -// Local Functions -// -//***************************************************************************** -//***************************************************************************** - -//***************************************************************************** -// GetLoadedModuleDirectory -//***************************************************************************** -BOOL GetLoadedModuleDirectory(LPCTSTR moduleName, - LPTSTR directoryContainingModule, - DWORD directoryContainingModuleLength) { - // Attempts to find the given module in the address space of this - // process and return the directory containing the module. A NULL - // moduleName means to look up the directory containing the - // application rather than any given loaded module. There is no - // trailing backslash ('\') on the returned path. If the named - // module was found in the address space of this process, returns - // TRUE, otherwise returns FALSE. directoryContainingModule may be - // mutated regardless. - HMODULE module = NULL; - TCHAR fileDrive[MAX_PATH + 1]; - TCHAR fileDir[MAX_PATH + 1]; - TCHAR fileName[MAX_PATH + 1]; - TCHAR fileExt[MAX_PATH + 1]; - DWORD numChars; - - if (moduleName != NULL) { - module = GetModuleHandle(moduleName); - if (module == NULL) - return FALSE; - } - - numChars = GetModuleFileName(module, - directoryContainingModule, - directoryContainingModuleLength); - if (numChars == 0) - return FALSE; - - _splitpath(directoryContainingModule, fileDrive, fileDir, fileName, fileExt); - _tcscpy(directoryContainingModule, fileDrive); - _tcscat(directoryContainingModule, fileDir); - return TRUE; -} - - - - -//***************************************************************************** -// AddDevice -//***************************************************************************** -void AddDevice(const char *pszDeviceName, TCHAR *pszHostDLLFilename, ALDEVICE **ppDeviceList) -{ - // Adds pszDeviceName nad pszHostDLLFilename to the given Device List *IF* pszDeviceName has - // not already been added. - ALDEVICE *pNewDevice, *pTempDevice; - - // Check if unique - for (pTempDevice = *ppDeviceList; pTempDevice; pTempDevice = pTempDevice->pNextDevice) - { - if (strcmp(pTempDevice->pszDeviceName, pszDeviceName) == 0) - break; - } - - if (pTempDevice) - return; - - pNewDevice = (ALDEVICE*)malloc(sizeof(ALDEVICE)); - if (pNewDevice) - { - pNewDevice->pszDeviceName = (char*)malloc((strlen(pszDeviceName)+1)*sizeof(char)); - if (pNewDevice->pszDeviceName) - strcpy(pNewDevice->pszDeviceName, pszDeviceName); - - pNewDevice->pszHostDLLFilename = (TCHAR*)malloc((_tcslen(pszHostDLLFilename)+1)*sizeof(TCHAR)); - if (pNewDevice->pszHostDLLFilename) - _tcscpy(pNewDevice->pszHostDLLFilename, pszHostDLLFilename); - - pNewDevice->pNextDevice = NULL; - - if (*ppDeviceList) - { - pTempDevice = *ppDeviceList; - while (pTempDevice->pNextDevice) - pTempDevice = pTempDevice->pNextDevice; - pTempDevice->pNextDevice = pNewDevice; - } - else - { - *ppDeviceList = pNewDevice; - } - } -} - - - - -//***************************************************************************** -// BuildDeviceList -//***************************************************************************** -ALvoid BuildDeviceList() -{ - // This function will scan several directories (details below) looking for - // OpenAL DLLs. Each OpenAL DLL found will be opened and queried for it's - // list of playback and capture devices. All the information is stored - // in various lists: - - // - // g_pDevicesList : List of Playback Devices - // g_pCaptureDeviceList : List of Capture devices - // g_pAllDevicesList : List of *all* possible Playback devices (ALC_ENUMERATE_ALL_EXT support) - // - // In addition this function allocates memory for the strings that will - // be returned to the application in response to alcGetString queries. - // - // pszDefaultDeviceSpecifier : Default Playback Device - // pszDeviceSpecifierList : List of Playback Devices - // pszDefaultCaptureDeviceSpecifier : Default Capture Device - // pszCaptureDeviceSpecifierList : List of Capture Devices - // pszDefaultAllDevicesSpecifier : Default *all* Playback Device (ALC_ENUMERATE_ALL_EXT support) - // pszAllDevicesSpecifierList : List of *all* Playback Devices (ALC_ENUMERATE_ALL_EXT support) - WIN32_FIND_DATA findData; - HANDLE searchHandle = INVALID_HANDLE_VALUE; - TCHAR searchName[MAX_PATH + 1]; - BOOL found = FALSE; - const ALCchar* specifier = 0; - ALuint specifierSize = 0; - ALCdevice *device; - void *context; - bool bUsedWrapper = false; - ALDEVICE *pDevice = NULL; - - // Only build the list once ... - if (((g_pDeviceList == NULL) && (waveOutGetNumDevs())) || - ((g_pCaptureDeviceList == NULL) && (waveInGetNumDevs()))) - { - // - // Directory[0] is the directory containing OpenAL32.dll - // Directory[1] is the current directory. - // Directory[2] is the current app directory - // Directory[3] is the system directory - // - TCHAR dir[4][MAX_PATH + 1] = { 0 }; - int numDirs = 0; - int i; - HINSTANCE dll = 0; - ALCAPI_GET_STRING alcGetStringFxn = 0; - ALCAPI_IS_EXTENSION_PRESENT alcIsExtensionPresentFxn = 0; - ALCAPI_OPEN_DEVICE alcOpenDeviceFxn = 0; - ALCAPI_CREATE_CONTEXT alcCreateContextFxn = 0; - ALCAPI_MAKE_CONTEXT_CURRENT alcMakeContextCurrentFxn = 0; - ALCAPI_DESTROY_CONTEXT alcDestroyContextFxn = 0; - ALCAPI_CLOSE_DEVICE alcCloseDeviceFxn = 0; - - // - // Construct our search paths - // - if (GetLoadedModuleDirectory("OpenAL32.dll", dir[0], MAX_PATH)) { - ++numDirs; - } - - GetCurrentDirectory(MAX_PATH, dir[1]); - _tcscat(dir[1], _T("\\")); - ++numDirs; - - GetLoadedModuleDirectory(NULL, dir[2], MAX_PATH); - ++numDirs; - - GetSystemDirectory(dir[3], MAX_PATH); - _tcscat(dir[3], _T("\\")); - ++numDirs; - - // - // Begin searching for additional OpenAL implementations. - // - for(i = 0; i < numDirs; i++) - { - if ((i == 0) && (strcmp(dir[0], dir[3]) == 0)) // if searching router dir and router dir is sys dir, skip search - continue; - - if ((i == 2) && (strcmp(dir[2], dir[1]) == 0)) // if searching app dir and app dir is current dir, skip search - continue; - - if ((i == 3) && ((strcmp(dir[3], dir[2]) == 0) || (strcmp(dir[3], dir[1]) == 0))) // if searching sys dir and sys dir is either current or app directory, skip search - continue; - - _tcscpy(searchName, dir[i]); - _tcscat(searchName, _T("*oal.dll")); - searchHandle = FindFirstFile(searchName, &findData); - if(searchHandle != INVALID_HANDLE_VALUE) - { - while(TRUE) - { - // - // if this is an OpenAL32.dll, skip it -- it's probably a router and shouldn't be enumerated regardless - // - _tcscpy(searchName, dir[i]); - _tcscat(searchName, findData.cFileName); - TCHAR cmpName[MAX_PATH]; - _tcscpy(cmpName, searchName); - _tcsupr(cmpName); - if (_tcsstr(cmpName, _T("OPENAL32.DLL")) == 0) - { - boolean skipSearch = false; - - // don't search the same DLL twice - TCHAR *szDLLName = _tcsrchr(searchName, _T('\\')); - if (szDLLName) - szDLLName++; // Skip over the '\' - else - szDLLName = searchName; - - skipSearch = HasDLLAlreadyBeenUsed(g_pDeviceList, szDLLName); - if (!skipSearch) - skipSearch = HasDLLAlreadyBeenUsed(g_pCaptureDeviceList, szDLLName); - if (!skipSearch) - skipSearch = HasDLLAlreadyBeenUsed(g_pAllDevicesList, szDLLName); - - if (skipSearch == false) { - dll = LoadLibrary(searchName); - if(dll) - { - alcOpenDeviceFxn = (ALCAPI_OPEN_DEVICE)GetProcAddress(dll, "alcOpenDevice"); - alcCreateContextFxn = (ALCAPI_CREATE_CONTEXT)GetProcAddress(dll, "alcCreateContext"); - alcMakeContextCurrentFxn = (ALCAPI_MAKE_CONTEXT_CURRENT)GetProcAddress(dll, "alcMakeContextCurrent"); - alcGetStringFxn = (ALCAPI_GET_STRING)GetProcAddress(dll, "alcGetString"); - alcDestroyContextFxn = (ALCAPI_DESTROY_CONTEXT)GetProcAddress(dll, "alcDestroyContext"); - alcCloseDeviceFxn = (ALCAPI_CLOSE_DEVICE)GetProcAddress(dll, "alcCloseDevice"); - alcIsExtensionPresentFxn = (ALCAPI_IS_EXTENSION_PRESENT)GetProcAddress(dll, "alcIsExtensionPresent"); - - if ((alcOpenDeviceFxn != 0) && - (alcCreateContextFxn != 0) && - (alcMakeContextCurrentFxn != 0) && - (alcGetStringFxn != 0) && - (alcDestroyContextFxn != 0) && - (alcCloseDeviceFxn != 0) && - (alcIsExtensionPresentFxn != 0)) { - - bool bAddToAllDevicesList = false; - - if (alcIsExtensionPresentFxn(NULL, "ALC_ENUMERATE_ALL_EXT")) { - // this DLL can enumerate *all* devices -- so add complete list of devices - specifier = alcGetStringFxn(0, ALC_ALL_DEVICES_SPECIFIER); - if ((specifier) && strlen(specifier)) - { - do { - AddDevice(specifier, searchName, &g_pAllDevicesList); - specifier += strlen((char *)specifier) + 1; - } while (strlen((char *)specifier) > 0); - } - } else { - bAddToAllDevicesList = true; - } - - if (alcIsExtensionPresentFxn(NULL, "ALC_ENUMERATION_EXT")) { - // this DLL can enumerate devices -- so add complete list of devices - specifier = alcGetStringFxn(0, ALC_DEVICE_SPECIFIER); - if ((specifier) && strlen(specifier)) - { - do { - AddDevice(specifier, searchName, &g_pDeviceList); - if (bAddToAllDevicesList) - AddDevice(specifier, searchName, &g_pAllDevicesList); - specifier += strlen((char *)specifier) + 1; - } while (strlen((char *)specifier) > 0); - } - } else { - // no enumeration ability, -- so just add default device to the list - device = alcOpenDeviceFxn(NULL); - if (device != NULL) { - context = alcCreateContextFxn(device, NULL); - alcMakeContextCurrentFxn((ALCcontext *)context); - if (context != NULL) { - specifier = alcGetStringFxn(device, ALC_DEVICE_SPECIFIER); - if ((specifier) && strlen(specifier)) - { - AddDevice(specifier, searchName, &g_pDeviceList); - if (bAddToAllDevicesList) - AddDevice(specifier, searchName, &g_pAllDevicesList); - } - alcMakeContextCurrentFxn((ALCcontext *)NULL); - alcDestroyContextFxn((ALCcontext *)context); - alcCloseDeviceFxn(device); - } - } - } - - // add to capture device list - if (_tcsstr(cmpName, _T("CT_OAL.DLL")) == 0) { - // Skip native AL component (will contain same Capture List as the wrap_oal component) - if (alcIsExtensionPresentFxn(NULL, "ALC_EXT_CAPTURE")) { - // this DLL supports capture -- so add complete list of capture devices - specifier = alcGetStringFxn(0, ALC_CAPTURE_DEVICE_SPECIFIER); - if ((specifier) && strlen(specifier)) - { - do { - AddDevice(specifier, searchName, &g_pCaptureDeviceList); - specifier += strlen((char *)specifier) + 1; - } while (strlen((char *)specifier) > 0); - } - } - } - } - - FreeLibrary(dll); - dll = 0; - } - } - } - - if(!FindNextFile(searchHandle, &findData)) - { - if(GetLastError() == ERROR_NO_MORE_FILES) - { - break; - } - } - } - - FindClose(searchHandle); - searchHandle = INVALID_HANDLE_VALUE; - } - } - - // We now have a list of all the Device Names and their associated DLLs. - // Put the names in the appropriate strings - ALuint uiLength; - ALchar *pszTemp; - char *pszDefaultName = NULL; - bool bFound = false; - - if (g_pDeviceList) - { - uiLength = 0; - for (pDevice = g_pDeviceList; pDevice; pDevice = pDevice->pNextDevice) - uiLength += (strlen(pDevice->pszDeviceName) + 1); - - pszDeviceSpecifierList = (ALchar*)malloc((uiLength + 1) * sizeof(ALchar)); - if (pszTemp = pszDeviceSpecifierList) - { - memset(pszDeviceSpecifierList, 0, (uiLength + 1) * sizeof(ALchar)); - for (pDevice = g_pDeviceList; pDevice; pDevice = pDevice->pNextDevice) - { - strcpy(pszTemp, pDevice->pszDeviceName); - pszTemp += (strlen(pDevice->pszDeviceName) + 1); - } - } - - // Determine what the Default Device should be - if (GetDefaultPlaybackDeviceName(&pszDefaultName)) - { - bFound = false; - - // Search for an exact match first - bFound = FindDevice(g_pDeviceList, pszDefaultName, true, &pszDefaultDeviceSpecifier); - - // If we haven't found a match ... search for a partial match if name contains 'X-Fi' - if ((!bFound) && (strstr(pszDefaultName, "X-Fi"))) - bFound = FindDevice(g_pDeviceList, "X-Fi", false, &pszDefaultDeviceSpecifier); - - // If we haven't found a match ... search for a partial match if name contains 'Audigy' - if ((!bFound) && (strstr(pszDefaultName, "Audigy"))) - bFound = FindDevice(g_pDeviceList, "Audigy", false, &pszDefaultDeviceSpecifier); - - // If we haven't found a match ... search for a partial match with 'Generic Hardware' - if (!bFound) - bFound = FindDevice(g_pDeviceList, "Generic Hardware", false, &pszDefaultDeviceSpecifier); - - // If we haven't found a match ... search for a partial match with 'Generic Software' - if (!bFound) - bFound = FindDevice(g_pDeviceList, "Generic Software", false, &pszDefaultDeviceSpecifier); - - // If we STILL haven't found a match ... pick the 1st device! - if (!bFound) - { - pszDefaultDeviceSpecifier = (char*)malloc((strlen(g_pDeviceList->pszDeviceName) + 1) * sizeof(char)); - if (pszDefaultDeviceSpecifier) - strcpy(pszDefaultDeviceSpecifier, g_pDeviceList->pszDeviceName); - } - - free(pszDefaultName); - pszDefaultName = NULL; - } - } - - if (g_pCaptureDeviceList) - { - uiLength = 0; - for (pDevice = g_pCaptureDeviceList; pDevice; pDevice = pDevice->pNextDevice) - uiLength += (strlen(pDevice->pszDeviceName) + 1); - - pszCaptureDeviceSpecifierList = (ALchar*)malloc((uiLength + 1) * sizeof(ALchar)); - if (pszTemp = pszCaptureDeviceSpecifierList) - { - memset(pszCaptureDeviceSpecifierList, 0, (uiLength + 1) * sizeof(ALchar)); - for (pDevice = g_pCaptureDeviceList; pDevice; pDevice = pDevice->pNextDevice) - { - strcpy(pszTemp, pDevice->pszDeviceName); - pszTemp += (strlen(pDevice->pszDeviceName) + 1); - } - } - - if (GetDefaultCaptureDeviceName(&pszDefaultName)) - { - bFound = false; - - // Search for an exact match first - bFound = FindDevice(g_pCaptureDeviceList, pszDefaultName, true, &pszDefaultCaptureDeviceSpecifier); - - // If we haven't found a match, truncate the default name to 32 characters (MMSYSTEM limitation) - if ((!bFound) && (strlen(pszDefaultName) > 31)) - { - pszDefaultName[31] = '\0'; - bFound = FindDevice(g_pCaptureDeviceList, pszDefaultName, true, &pszDefaultCaptureDeviceSpecifier); - } - - // If we haven't found a match ... pick the 1st device! - if (!bFound) - { - pszDefaultCaptureDeviceSpecifier = (char*)malloc((strlen(g_pCaptureDeviceList->pszDeviceName) + 1) * sizeof(char)); - if (pszDefaultCaptureDeviceSpecifier) - strcpy(pszDefaultCaptureDeviceSpecifier, g_pCaptureDeviceList->pszDeviceName); - } - - free(pszDefaultName); - pszDefaultName = NULL; - } - } - - if (g_pAllDevicesList) - { - uiLength = 0; - for (pDevice = g_pAllDevicesList; pDevice; pDevice = pDevice->pNextDevice) - uiLength += (strlen(pDevice->pszDeviceName) + 1); - - pszAllDevicesSpecifierList = (ALchar*)malloc((uiLength + 1) * sizeof(ALchar)); - if (pszTemp = pszAllDevicesSpecifierList) - { - memset(pszAllDevicesSpecifierList, 0, (uiLength + 1) * sizeof(ALchar)); - for (pDevice = g_pAllDevicesList; pDevice; pDevice = pDevice->pNextDevice) - { - strcpy(pszTemp, pDevice->pszDeviceName); - pszTemp += (strlen(pDevice->pszDeviceName) + 1); - } - } - - // Determine what the Default Device should be - if (GetDefaultPlaybackDeviceName(&pszDefaultName)) - { - bFound = false; - - // If the (regular) default Playback device exists in this list ... use that - bFound = FindDevice(g_pAllDevicesList, pszDefaultDeviceSpecifier, true, &pszDefaultAllDevicesSpecifier); - - // If we haven't found a match ... pick a partial match with the Default Device Name - if (!bFound) - bFound = FindDevice(g_pAllDevicesList, pszDefaultName, false, &pszDefaultAllDevicesSpecifier); - - // If we STILL haven't found a match ... pick the 1st device! - if (!bFound) - { - pszDefaultAllDevicesSpecifier = (char*)malloc((strlen(g_pAllDevicesList->pszDeviceName) + 1) * sizeof(char)); - if (pszDefaultAllDevicesSpecifier) - strcpy(pszDefaultAllDevicesSpecifier, g_pAllDevicesList->pszDeviceName); - } - - free(pszDefaultName); - pszDefaultName = NULL; - } - } - } - - return; -} - - - - -//***************************************************************************** -// HasDLLAlreadyBeenUsed -//***************************************************************************** -bool HasDLLAlreadyBeenUsed(ALDEVICE *pDeviceList, TCHAR *szDLLName) -{ - // Checks if an OpenAL DLL has already been enumerated - ALDEVICE *pDevice = NULL; - TCHAR *szHostDLLName; - bool bReturn = false; - - for (pDevice = pDeviceList; pDevice; pDevice = pDevice->pNextDevice) - { - szHostDLLName = _tcsrchr(pDevice->pszHostDLLFilename, _T('\\')); - if (szHostDLLName) - szHostDLLName++; // Skip over the '\' - else - szHostDLLName = pDevice->pszHostDLLFilename; - - if (_tcscmp(szHostDLLName, szDLLName) == 0) - { - bReturn = true; - break; - } - } - - return bReturn; -} - - - - -//***************************************************************************** -// ValidCaptureDevice -//***************************************************************************** -/* -bool ValidCaptureDevice(const char *szCaptureDeviceName) -{ - // Microsoft changed the behaviour of Input devices on Windows Vista such that *each* input - // on each soundcard is reported as a separate device. Unfortunately, even though you can - // enumerate each input there are restrictions on what devices can be opened (e.g. you can only - // open the soundcard's default input). There is no API call to change the default input, so - // there is little point enumerating input devices that cannot be used, so we filter them out here. - WAVEFORMATEX wfex = { WAVE_FORMAT_PCM, 1, 22050, 44100, 2, 16, 0 }; // 16bit Mono 22050Hz - WAVEINCAPS WaveInCaps; - HWAVEIN hWaveIn; - bool bValid = false; - - // Find the device ID from the device name - long lNumCaptureDevs = waveInGetNumDevs(); - long lDeviceID = -1; - for (long lLoop = 0; lLoop < lNumCaptureDevs; lLoop++) - { - if (waveInGetDevCaps(lLoop, &WaveInCaps, sizeof(WAVEINCAPS)) == MMSYSERR_NOERROR) - { - if (!strcmp(szCaptureDeviceName, WaveInCaps.szPname)) - { - lDeviceID = lLoop; - break; - } - } - } - - if (lDeviceID != -1) - { - if (waveInOpen(&hWaveIn, lDeviceID, &wfex, NULL, NULL, WAVE_MAPPED) == MMSYSERR_NOERROR) - { - waveInClose(hWaveIn); - bValid = true; - } - } - - return bValid; -} -*/ - - - -//***************************************************************************** -// GetDefaultPlaybackDeviceName -//***************************************************************************** -bool GetDefaultPlaybackDeviceName(char **pszName) -{ - // Try to use DirectSound to get the name of the 'Preferred Audio Device / Endpoint" - // If that fails use MMSYSTEM (name will be limited to 32 characters in length) - TCHAR szPath[_MAX_PATH]; - HINSTANCE hDSoundDLL; - - if (!pszName) - return false; - - *pszName = NULL; - - // Load dsound.dll from the System Directory and use the DirectSoundEnumerateA function to - // get the list of playback devices - if (GetSystemDirectory(szPath, _MAX_PATH)) - { - _tcscat(szPath, "\\dsound.dll"); - hDSoundDLL = LoadLibrary(szPath); - if (hDSoundDLL) - { - LPDIRECTSOUNDENUMERATEA pfnDirectSoundEnumerateA = (LPDIRECTSOUNDENUMERATEA)GetProcAddress(hDSoundDLL, "DirectSoundEnumerateA"); - if (pfnDirectSoundEnumerateA) - pfnDirectSoundEnumerateA(&DSEnumCallback, pszName); - FreeLibrary(hDSoundDLL); - } - } - - // Falling back to MMSYSTEM - if (*pszName == NULL) - { - UINT uDeviceID=0; - DWORD dwFlags=1; - WAVEOUTCAPS outputInfo; - - #if !defined(_WIN64) - #ifdef __GNUC__ - __asm__ ("pusha;"); - #else - __asm pusha; // workaround for register destruction caused by these wavOutMessage calls (weird but true) - #endif - #endif // !defined(_WIN64) - waveOutMessage((HWAVEOUT)(UINT_PTR)WAVE_MAPPER,0x2000+0x0015,(LPARAM)&uDeviceID,(WPARAM)&dwFlags); - waveOutGetDevCaps(uDeviceID,&outputInfo,sizeof(outputInfo)); - #if !defined(_WIN64) - #ifdef __GNUC__ - __asm__ ("popa;"); - #else - __asm popa; - #endif - #endif // !defined(_WIN64) - - *pszName = (char*)malloc((strlen(outputInfo.szPname) + 1) * sizeof(char)); - if (*pszName) - strcpy(*pszName, outputInfo.szPname); - } - - return (*pszName) ? true : false; -} - - - - -//***************************************************************************** -// GetDefaultCaptureDeviceName -//***************************************************************************** -bool GetDefaultCaptureDeviceName(char **pszName) -{ - // Try to use DirectSound to get the name of the 'Preferred Audio Device / Endpoint" for recording. - // If that fails use MMSYSTEM (name will be limited to 32 characters in length) - TCHAR szPath[_MAX_PATH]; - HINSTANCE hDSoundDLL; - - if (!pszName) - return false; - - *pszName = NULL; - - // Load dsound.dll from the System Directory and use the DirectSoundCaptureEnumerateA function to - // get the list of capture devices - if (GetSystemDirectory(szPath, _MAX_PATH)) - { - _tcscat(szPath, "\\dsound.dll"); - hDSoundDLL = LoadLibrary(szPath); - if (hDSoundDLL) - { - LPDIRECTSOUNDCAPTUREENUMERATEA pfnDirectSoundCaptureEnumerateA = (LPDIRECTSOUNDCAPTUREENUMERATEA)GetProcAddress(hDSoundDLL, "DirectSoundCaptureEnumerateA"); - if (pfnDirectSoundCaptureEnumerateA) - pfnDirectSoundCaptureEnumerateA(&DSEnumCallback, pszName); - FreeLibrary(hDSoundDLL); - } - } - - // Falling back to MMSYSTEM - if (*pszName == NULL) - { - UINT uDeviceID=0; - DWORD dwFlags=1; - WAVEINCAPS inputInfo; - - #if !defined(_WIN64) - #ifdef __GNUC__ - __asm__ ("pusha;"); - #else - __asm pusha; // workaround for register destruction caused by these wavOutMessage calls (weird but true) - #endif - #endif // !defined(_WIN64) - waveInMessage((HWAVEIN)(UINT_PTR)WAVE_MAPPER,0x2000+0x0015,(LPARAM)&uDeviceID,(WPARAM)&dwFlags); - waveInGetDevCaps(uDeviceID, &inputInfo, sizeof(inputInfo)); - #if !defined(_WIN64) - #ifdef __GNUC__ - __asm__ ("popa;"); - #else - __asm popa; - #endif - #endif // !defined(_WIN64) - - *pszName = (char*)malloc((strlen(inputInfo.szPname) + 1) * sizeof(char)); - if (*pszName) - strcpy(*pszName, inputInfo.szPname); - } - - return (*pszName) ? true : false; -} - - - - -//***************************************************************************** -// DSEnumCallback -//***************************************************************************** -BOOL CALLBACK DSEnumCallback(LPGUID lpGuid, LPCSTR lpcstrDescription, LPCSTR lpcstrModule, LPVOID lpContext) -{ - // DirectSound Enumeration callback will be called for each device found. - // The first device returned with a non-NULL GUID is the 'preferred device' - - // Skip over the device without a GUID - if (lpGuid) - { - char **pszName = (char**)lpContext; - *pszName = (char*)malloc((strlen(lpcstrDescription)+1) * sizeof(char)); - if (*pszName) - { - strcpy(*pszName, lpcstrDescription); - return FALSE; - } - } - - return TRUE; -} - - - -//***************************************************************************** -// FindDevice -//***************************************************************************** -bool FindDevice(ALDEVICE *pDeviceList, char *szDeviceName, bool bExactMatch, char **ppszDefaultName) -{ - // Search through pDeviceList for szDeviceName using an exact match if bExactMatch is true, or using - // a sub-string search otherwise. - // If found, allocate memory for *ppszDefaultName and copy the device name over - ALDEVICE *pDevice = NULL; - bool bFound = false; - - if (!pDeviceList || !szDeviceName || !ppszDefaultName) - return false; - - for (pDevice = pDeviceList; pDevice; pDevice = pDevice->pNextDevice) - { - if (bExactMatch) - bFound = (strcmp(pDevice->pszDeviceName, szDeviceName) == 0) ? true : false; - else - bFound = (strstr(pDevice->pszDeviceName, szDeviceName)) ? true : false; - - if (bFound) - { - *ppszDefaultName = (char*)malloc((strlen(pDevice->pszDeviceName) + 1) * sizeof(char)); - if (*ppszDefaultName) - { - strcpy(*ppszDefaultName, pDevice->pszDeviceName); - break; - } - } - } - - return *ppszDefaultName ? true : false; -} - - - - -//***************************************************************************** -// LoadDevicesDLL -//***************************************************************************** -HINSTANCE LoadDevicesDLL(ALDEVICE *pDeviceList, const ALchar *szDeviceName) -{ - // Search pDeviceList for szDeviceName, and when found load the OpenAL DLL - // that contains that Device name. - HINSTANCE hDLL = NULL; - ALDEVICE *pDevice; - - for (pDevice = pDeviceList; pDevice; pDevice = pDevice->pNextDevice) - { - if (strcmp(pDevice->pszDeviceName, szDeviceName) == 0) - { - hDLL = LoadLibrary(pDevice->pszHostDLLFilename); - break; - } - } - - return hDLL; -} - - - - -//***************************************************************************** -// FillOutAlcFunctions -//***************************************************************************** -ALboolean FillOutAlcFunctions(ALCdevice* device) -{ - ALboolean alcFxns = FALSE; - ALCAPI_FXN_TABLE* alcApi = &device->AlcApi; - - memset(alcApi, 0, sizeof(ALCAPI_FXN_TABLE)); - - // - // Get the OpenAL 1.0 Entry points. - // - alcApi->alcCreateContext = (ALCAPI_CREATE_CONTEXT)GetProcAddress(device->Dll, "alcCreateContext"); - alcApi->alcMakeContextCurrent = (ALCAPI_MAKE_CONTEXT_CURRENT)GetProcAddress(device->Dll, "alcMakeContextCurrent"); - alcApi->alcProcessContext = (ALCAPI_PROCESS_CONTEXT)GetProcAddress(device->Dll, "alcProcessContext"); - alcApi->alcSuspendContext = (ALCAPI_SUSPEND_CONTEXT)GetProcAddress(device->Dll, "alcSuspendContext"); - alcApi->alcDestroyContext = (ALCAPI_DESTROY_CONTEXT)GetProcAddress(device->Dll, "alcDestroyContext"); - alcApi->alcGetCurrentContext = (ALCAPI_GET_CURRENT_CONTEXT)GetProcAddress(device->Dll, "alcGetCurrentContext"); - alcApi->alcGetContextsDevice = (ALCAPI_GET_CONTEXTS_DEVICE)GetProcAddress(device->Dll, "alcGetContextsDevice"); - - alcApi->alcOpenDevice = (ALCAPI_OPEN_DEVICE)GetProcAddress(device->Dll, "alcOpenDevice"); - alcApi->alcCloseDevice = (ALCAPI_CLOSE_DEVICE)GetProcAddress(device->Dll, "alcCloseDevice"); - - alcApi->alcGetError = (ALCAPI_GET_ERROR)GetProcAddress(device->Dll, "alcGetError"); - - alcApi->alcIsExtensionPresent = (ALCAPI_IS_EXTENSION_PRESENT)GetProcAddress(device->Dll, "alcIsExtensionPresent"); - alcApi->alcGetProcAddress = (ALCAPI_GET_PROC_ADDRESS)GetProcAddress(device->Dll, "alcGetProcAddress"); - alcApi->alcGetEnumValue = (ALCAPI_GET_ENUM_VALUE)GetProcAddress(device->Dll, "alcGetEnumValue"); - - alcApi->alcGetString = (ALCAPI_GET_STRING)GetProcAddress(device->Dll, "alcGetString"); - alcApi->alcGetIntegerv = (ALCAPI_GET_INTEGERV)GetProcAddress(device->Dll, "alcGetIntegerv"); - - // - // Get the OpenAL 1.1 Entry points. - // - alcApi->alcCaptureOpenDevice = (ALCAPI_CAPTURE_OPEN_DEVICE)GetProcAddress(device->Dll, "alcCaptureOpenDevice"); - alcApi->alcCaptureCloseDevice = (ALCAPI_CAPTURE_CLOSE_DEVICE)GetProcAddress(device->Dll, "alcCaptureCloseDevice"); - alcApi->alcCaptureStart = (ALCAPI_CAPTURE_START)GetProcAddress(device->Dll, "alcCaptureStart"); - alcApi->alcCaptureStop = (ALCAPI_CAPTURE_STOP)GetProcAddress(device->Dll, "alcCaptureStop"); - alcApi->alcCaptureSamples = (ALCAPI_CAPTURE_SAMPLES)GetProcAddress(device->Dll, "alcCaptureSamples"); - - // handle legacy issue with old Creative DLLs which may not have alcGetProcAddress, alcIsExtensionPresent, alcGetEnumValue - if (alcApi->alcGetProcAddress == NULL) { - alcApi->alcGetProcAddress = (ALCAPI_GET_PROC_ADDRESS)alcGetProcAddress; - } - if (alcApi->alcIsExtensionPresent == NULL) { - alcApi->alcIsExtensionPresent = (ALCAPI_IS_EXTENSION_PRESENT)alcIsExtensionPresent; - } - if (alcApi->alcGetEnumValue == NULL) { - alcApi->alcGetEnumValue = (ALCAPI_GET_ENUM_VALUE)alcGetEnumValue; - } - - - alcFxns = (alcApi->alcCreateContext && - alcApi->alcMakeContextCurrent && - alcApi->alcProcessContext && - alcApi->alcSuspendContext && - alcApi->alcDestroyContext && - alcApi->alcGetCurrentContext && - alcApi->alcGetContextsDevice && - alcApi->alcOpenDevice && - alcApi->alcCloseDevice && - alcApi->alcGetError && - alcApi->alcIsExtensionPresent && - alcApi->alcGetProcAddress && - alcApi->alcGetEnumValue && - alcApi->alcGetString && - alcApi->alcGetIntegerv); - - return alcFxns; -} - - - - -//***************************************************************************** -// FillOutAlFunctions -//***************************************************************************** -ALboolean FillOutAlFunctions(ALCcontext* context) -{ - ALboolean alFxns = FALSE; - ALAPI_FXN_TABLE* alApi = &context->AlApi; - - memset(alApi, 0, sizeof(ALAPI_FXN_TABLE)); - - // - // Get the OpenAL 1.0 & 1.1 Entry points. - // - alApi->alEnable = (ALAPI_ENABLE)GetProcAddress(context->Device->Dll, "alEnable"); - alApi->alDisable = (ALAPI_DISABLE)GetProcAddress(context->Device->Dll, "alDisable"); - alApi->alIsEnabled = (ALAPI_IS_ENABLED)GetProcAddress(context->Device->Dll, "alIsEnabled"); - - alApi->alGetString = (ALAPI_GET_STRING)GetProcAddress(context->Device->Dll, "alGetString"); - alApi->alGetBooleanv = (ALAPI_GET_BOOLEANV)GetProcAddress(context->Device->Dll, "alGetBooleanv"); - alApi->alGetIntegerv = (ALAPI_GET_INTEGERV)GetProcAddress(context->Device->Dll, "alGetIntegerv"); - alApi->alGetFloatv = (ALAPI_GET_FLOATV)GetProcAddress(context->Device->Dll, "alGetFloatv"); - alApi->alGetDoublev = (ALAPI_GET_DOUBLEV)GetProcAddress(context->Device->Dll, "alGetDoublev"); - alApi->alGetBoolean = (ALAPI_GET_BOOLEAN)GetProcAddress(context->Device->Dll, "alGetBoolean"); - alApi->alGetInteger = (ALAPI_GET_INTEGER)GetProcAddress(context->Device->Dll, "alGetInteger"); - alApi->alGetFloat = (ALAPI_GET_FLOAT)GetProcAddress(context->Device->Dll, "alGetFloat"); - alApi->alGetDouble = (ALAPI_GET_DOUBLE)GetProcAddress(context->Device->Dll, "alGetDouble"); - alApi->alGetError = (ALAPI_GET_ERROR)GetProcAddress(context->Device->Dll, "alGetError"); - alApi->alIsExtensionPresent = (ALAPI_IS_EXTENSION_PRESENT)GetProcAddress(context->Device->Dll, "alIsExtensionPresent"); - alApi->alGetProcAddress = (ALAPI_GET_PROC_ADDRESS)GetProcAddress(context->Device->Dll, "alGetProcAddress"); - alApi->alGetEnumValue = (ALAPI_GET_ENUM_VALUE)GetProcAddress(context->Device->Dll, "alGetEnumValue"); - - alApi->alListenerf = (ALAPI_LISTENERF)GetProcAddress(context->Device->Dll, "alListenerf"); - alApi->alListener3f = (ALAPI_LISTENER3F)GetProcAddress(context->Device->Dll, "alListener3f"); - alApi->alListenerfv = (ALAPI_LISTENERFV)GetProcAddress(context->Device->Dll, "alListenerfv"); - alApi->alListeneri = (ALAPI_LISTENERI)GetProcAddress(context->Device->Dll, "alListeneri"); - alApi->alListener3i = (ALAPI_LISTENER3I)GetProcAddress(context->Device->Dll, "alListener3i"); - alApi->alListeneriv = (ALAPI_LISTENERIV)GetProcAddress(context->Device->Dll, "alListeneriv"); - alApi->alGetListenerf = (ALAPI_GET_LISTENERF)GetProcAddress(context->Device->Dll, "alGetListenerf"); - alApi->alGetListener3f = (ALAPI_GET_LISTENER3F)GetProcAddress(context->Device->Dll, "alGetListener3f"); - alApi->alGetListenerfv = (ALAPI_GET_LISTENERFV)GetProcAddress(context->Device->Dll, "alGetListenerfv"); - alApi->alGetListeneri = (ALAPI_GET_LISTENERI)GetProcAddress(context->Device->Dll, "alGetListeneri"); - alApi->alGetListener3i = (ALAPI_GET_LISTENER3I)GetProcAddress(context->Device->Dll, "alGetListener3i"); - alApi->alGetListeneriv = (ALAPI_GET_LISTENERIV)GetProcAddress(context->Device->Dll, "alGetListeneriv"); - - alApi->alGenSources = (ALAPI_GEN_SOURCES)GetProcAddress(context->Device->Dll, "alGenSources"); - alApi->alDeleteSources = (ALAPI_DELETE_SOURCES)GetProcAddress(context->Device->Dll, "alDeleteSources"); - alApi->alIsSource = (ALAPI_IS_SOURCE)GetProcAddress(context->Device->Dll, "alIsSource"); - alApi->alSourcef = (ALAPI_SOURCEF)GetProcAddress(context->Device->Dll, "alSourcef"); - alApi->alSource3f = (ALAPI_SOURCE3F)GetProcAddress(context->Device->Dll, "alSource3f"); - alApi->alSourcefv = (ALAPI_SOURCEFV)GetProcAddress(context->Device->Dll, "alSourcefv"); - alApi->alSourcei = (ALAPI_SOURCEI)GetProcAddress(context->Device->Dll, "alSourcei"); - alApi->alSource3i = (ALAPI_SOURCE3I)GetProcAddress(context->Device->Dll, "alSource3i"); - alApi->alSourceiv = (ALAPI_SOURCEIV)GetProcAddress(context->Device->Dll, "alSourceiv"); - alApi->alGetSourcef = (ALAPI_GET_SOURCEF)GetProcAddress(context->Device->Dll, "alGetSourcef"); - alApi->alGetSource3f = (ALAPI_GET_SOURCE3F)GetProcAddress(context->Device->Dll, "alGetSource3f"); - alApi->alGetSourcefv = (ALAPI_GET_SOURCEFV)GetProcAddress(context->Device->Dll, "alGetSourcefv"); - alApi->alGetSourcei = (ALAPI_GET_SOURCEI)GetProcAddress(context->Device->Dll, "alGetSourcei"); - alApi->alGetSource3i = (ALAPI_GET_SOURCE3I)GetProcAddress(context->Device->Dll, "alGetSource3i"); - alApi->alGetSourceiv = (ALAPI_GET_SOURCEIV)GetProcAddress(context->Device->Dll, "alGetSourceiv"); - alApi->alSourcePlayv = (ALAPI_SOURCE_PLAYV)GetProcAddress(context->Device->Dll, "alSourcePlayv"); - alApi->alSourceStopv = (ALAPI_SOURCE_STOPV)GetProcAddress(context->Device->Dll, "alSourceStopv"); - alApi->alSourceRewindv = (ALAPI_SOURCE_REWINDV)GetProcAddress(context->Device->Dll, "alSourceRewindv"); - alApi->alSourcePausev = (ALAPI_SOURCE_PAUSEV)GetProcAddress(context->Device->Dll, "alSourcePausev"); - alApi->alSourcePlay = (ALAPI_SOURCE_PLAY)GetProcAddress(context->Device->Dll, "alSourcePlay"); - alApi->alSourceStop = (ALAPI_SOURCE_STOP)GetProcAddress(context->Device->Dll, "alSourceStop"); - alApi->alSourceRewind = (ALAPI_SOURCE_STOP)GetProcAddress(context->Device->Dll, "alSourceRewind"); - alApi->alSourcePause = (ALAPI_SOURCE_PAUSE)GetProcAddress(context->Device->Dll, "alSourcePause"); - - alApi->alSourceQueueBuffers = (ALAPI_SOURCE_QUEUE_BUFFERS)GetProcAddress(context->Device->Dll, "alSourceQueueBuffers"); - alApi->alSourceUnqueueBuffers = (ALAPI_SOURCE_UNQUEUE_BUFFERS)GetProcAddress(context->Device->Dll, "alSourceUnqueueBuffers"); - - alApi->alGenBuffers = (ALAPI_GEN_BUFFERS)GetProcAddress(context->Device->Dll, "alGenBuffers"); - alApi->alDeleteBuffers = (ALAPI_DELETE_BUFFERS)GetProcAddress(context->Device->Dll, "alDeleteBuffers"); - alApi->alIsBuffer = (ALAPI_IS_BUFFER)GetProcAddress(context->Device->Dll, "alIsBuffer"); - alApi->alBufferData = (ALAPI_BUFFER_DATA)GetProcAddress(context->Device->Dll, "alBufferData"); - alApi->alBufferf = (ALAPI_BUFFERF)GetProcAddress(context->Device->Dll, "alBufferf"); - alApi->alBuffer3f = (ALAPI_BUFFER3F)GetProcAddress(context->Device->Dll, "alBuffer3f"); - alApi->alBufferfv = (ALAPI_BUFFERFV)GetProcAddress(context->Device->Dll, "alBufferfv"); - alApi->alBufferi = (ALAPI_BUFFERI)GetProcAddress(context->Device->Dll, "alBufferi"); - alApi->alBuffer3i = (ALAPI_BUFFER3I)GetProcAddress(context->Device->Dll, "alBuffer3i"); - alApi->alBufferiv = (ALAPI_BUFFERIV)GetProcAddress(context->Device->Dll, "alBufferiv"); - alApi->alGetBufferf = (ALAPI_GET_BUFFERF)GetProcAddress(context->Device->Dll, "alGetBufferf"); - alApi->alGetBuffer3f = (ALAPI_GET_BUFFER3F)GetProcAddress(context->Device->Dll, "alGetBuffer3f"); - alApi->alGetBufferfv = (ALAPI_GET_BUFFERFV)GetProcAddress(context->Device->Dll, "alGetBufferfv"); - alApi->alGetBufferi = (ALAPI_GET_BUFFERI)GetProcAddress(context->Device->Dll, "alGetBufferi"); - alApi->alGetBuffer3i = (ALAPI_GET_BUFFER3I)GetProcAddress(context->Device->Dll, "alGetBuffer3i"); - alApi->alGetBufferiv = (ALAPI_GET_BUFFERIV)GetProcAddress(context->Device->Dll, "alGetBufferiv"); - - alApi->alDopplerFactor = (ALAPI_DOPPLER_FACTOR)GetProcAddress(context->Device->Dll, "alDopplerFactor"); - alApi->alDopplerVelocity = (ALAPI_DOPPLER_VELOCITY)GetProcAddress(context->Device->Dll, "alDopplerVelocity"); - alApi->alSpeedOfSound = (ALAPI_SPEED_OF_SOUND)GetProcAddress(context->Device->Dll, "alSpeedOfSound"); - alApi->alDistanceModel = (ALAPI_DISTANCE_MODEL)GetProcAddress(context->Device->Dll, "alDistanceModel"); - - alFxns = (alApi->alEnable && - alApi->alDisable && - alApi->alIsEnabled && - - alApi->alGetString && - alApi->alGetBooleanv && - alApi->alGetIntegerv && - alApi->alGetFloatv && - alApi->alGetDoublev && - alApi->alGetBoolean && - alApi->alGetInteger && - alApi->alGetFloat && - alApi->alGetDouble && - - alApi->alGetError && - - alApi->alIsExtensionPresent && - alApi->alGetProcAddress && - alApi->alGetEnumValue && - - alApi->alListenerf && - alApi->alListener3f && - alApi->alListenerfv && - alApi->alListeneri && - alApi->alGetListenerf && - alApi->alGetListener3f && - alApi->alGetListenerfv && - alApi->alGetListeneri && - - alApi->alGenSources && - alApi->alDeleteSources && - alApi->alIsSource && - alApi->alSourcef && - alApi->alSource3f && - alApi->alSourcefv && - alApi->alSourcei && - alApi->alGetSourcef && - alApi->alGetSource3f && - alApi->alGetSourcefv && - alApi->alGetSourcei && - alApi->alSourcePlayv && - alApi->alSourceStopv && - alApi->alSourceRewindv && - alApi->alSourcePausev && - alApi->alSourcePlay && - alApi->alSourceStop && - alApi->alSourceRewind && - alApi->alSourcePause && - - alApi->alSourceQueueBuffers && - alApi->alSourceUnqueueBuffers && - - alApi->alGenBuffers && - alApi->alDeleteBuffers && - alApi->alIsBuffer && - alApi->alBufferData && - alApi->alGetBufferf && - alApi->alGetBufferi && - - alApi->alDopplerFactor && - alApi->alDopplerVelocity && - alApi->alDistanceModel); - - return alFxns; -} - - - - -//***************************************************************************** -//***************************************************************************** -// -// ALC API Entry Points -// -//*****************************************************************************ALC_ -//***************************************************************************** - -//***************************************************************************** -// alcCloseDevice -//***************************************************************************** -// -ALCAPI ALCboolean ALCAPIENTRY alcCloseDevice(ALCdevice* device) -{ -#ifdef _LOGCALLS - LOG("alcCloseDevice device %p\n", device); -#endif - if(!device) - { - return ALC_FALSE; - } - - if (device == g_CaptureDevice) - return g_CaptureDevice->AlcApi.alcCloseDevice(g_CaptureDevice->CaptureDevice); - - // - // Check if its linked to a context. - // - if(device->InUse) - { - ALCcontext* context = 0; - ALlistEntry* entry = 0; - - // - // Not all of the contexts using the device have been destroyed. - // - assert(0); - - // - // Loop through the context list and free and contexts linked to the device. - // Go back to the beginning each time in case some one changed the context - // list iterator. - // - alListAcquireLock(alContextList); - entry = alListIteratorReset(alContextList); - while(entry) - { - context = (ALCcontext*)alListGetData(entry); - if(context->Device == device) - { - alListReleaseLock(alContextList); - alcDestroyContext((ALCcontext *)context); - alListAcquireLock(alContextList); - entry = alListIteratorReset(alContextList); - } - - else - { - entry = alListIteratorNext(alContextList); - } - } - - alListReleaseLock(alContextList); - assert(!device->InUse); - } - - device->AlcApi.alcCloseDevice(device->DllDevice); - FreeLibrary(device->Dll); - free(device); - - return ALC_TRUE; -} - - - - -//***************************************************************************** -// alcCreateContext -//***************************************************************************** -ALCAPI ALCcontext* ALCAPIENTRY alcCreateContext(ALCdevice* device, const ALint* attrList) -{ -#ifdef _LOGCALLS - LOG("alcCreateContext device %p ", device); - if (attrList) - { - unsigned long ulIndex = 0; - while ((ulIndex < 16) && (attrList[ulIndex])) - { - switch(attrList[ulIndex]) - { - case ALC_FREQUENCY: - LOG("ALC_FREQUENCY %d ", attrList[ulIndex + 1]); - break; - - case ALC_REFRESH: - LOG("ALC_REFRESH %d ", attrList[ulIndex + 1]); - break; - - case ALC_SYNC: - LOG("ALC_SYNC %d ", attrList[ulIndex + 1]); - break; - - case ALC_MONO_SOURCES: - LOG("ALC_MONO_SOURCES %d ", attrList[ulIndex + 1]); - break; - - case ALC_STEREO_SOURCES: - LOG("ALC_STEREO_SOURCES %d ", attrList[ulIndex + 1]); - break; - - case 0x20003/*ALC_MAX_AUXILIARY_SENDS*/: - LOG("ALC_MAX_AUXILIARY_SENDS %d", attrList[ulIndex + 1]); - break; - } - ulIndex += 2; - } - } - LOG("\n"); -#endif - - ALCcontext* context = 0; - - if(!device) - { - LastError = ALC_INVALID_DEVICE; - return 0; - } - - if (device == g_CaptureDevice) - return g_CaptureDevice->AlcApi.alcCreateContext(g_CaptureDevice->CaptureDevice, attrList); - - // - // Allocate the context. - // - context = (ALCcontext*)malloc(sizeof(ALCcontext)); - if(!context) - { - return 0; - } - - memset(context, 0, sizeof(ALCcontext)); - context->Device = device; - context->Suspended = FALSE; - context->LastError = ALC_NO_ERROR; - InitializeCriticalSection(&context->Lock); - - // - // We don't fill out the AL functions in case they are context specific. - // - - context->DllContext = device->AlcApi.alcCreateContext(device->DllDevice, attrList); - if(!context->DllContext) - { - DeleteCriticalSection(&context->Lock); - free(context); - context = 0; - return 0; - } - - device->InUse++; - - // - // Add it to the context list. - // - alListInitializeEntry(&context->ListEntry, context); - alListAcquireLock(alContextList); - alListAddEntry(alContextList, &context->ListEntry); - alListReleaseLock(alContextList); - return context; -} - - - - -//***************************************************************************** -// alcDestroyContext -//***************************************************************************** -ALCAPI ALvoid ALCAPIENTRY alcDestroyContext(ALCcontext* context) -{ -#ifdef _LOGCALLS - LOG("alcDestroyContext context %p\n", context); -#endif - ALCcontext* listData = 0; - - if(!context) - { - return; - } - - // - // Remove the entry from the context list. - // - alListAcquireLock(alContextList); - listData = (ALCcontext*)alListRemoveEntry(alContextList, &context->ListEntry); - if(!listData) - { - alListReleaseLock(alContextList); - return; - } - - if(context == alCurrentContext) - { - alCurrentContext = 0; - } - - EnterCriticalSection(&context->Lock); - alListReleaseLock(alContextList); - - context->Device->InUse--; - - // Clean up the context. - if(context->DllContext) - { - context->Device->AlcApi.alcDestroyContext(context->DllContext); - } - - LeaveCriticalSection(&context->Lock); - DeleteCriticalSection(&context->Lock); - free(context); -} - - - - -//***************************************************************************** -// alcGetContextsDevice -//***************************************************************************** -ALCAPI ALCdevice* ALCAPIENTRY alcGetContextsDevice(ALCcontext* context) -{ -#ifdef _LOGCALLS - LOG("alcGetContextsDevice context %p\n", context); -#endif - ALCdevice* ALCdevice = 0; - - alListAcquireLock(alContextList); - if(alListMatchData(alContextList, context)) - { - ALCdevice = context->Device; - } - - alListReleaseLock(alContextList); - - return ALCdevice; -} - - - - -//***************************************************************************** -// alcGetCurrentContext -//***************************************************************************** -ALCAPI ALCcontext* ALCAPIENTRY alcGetCurrentContext(ALvoid) -{ -#ifdef _LOGCALLS - LOG("alcGetCurrentContext\n"); -#endif - return (ALCcontext *)alCurrentContext; -} - - - - -//***************************************************************************** -// alcGetEnumValue -//***************************************************************************** -ALCAPI ALenum ALCAPIENTRY alcGetEnumValue(ALCdevice* device, const ALCchar* ename) -{ -#ifdef _LOGCALLS - LOG("alcGetEnumValue device %p enum name '%s'\n", device, ename ? ename : "<NULL>"); -#endif - // - // Always return the router version of the ALC enum if it exists. - // - ALsizei i = 0; - while(alcEnums[i].ename && strcmp((char*)alcEnums[i].ename, (char*)ename)) - { - i++; - } - - if(alcEnums[i].ename) - { - return alcEnums[i].value; - } - - if(device) - { - if (device == g_CaptureDevice) - return g_CaptureDevice->AlcApi.alcGetEnumValue(g_CaptureDevice->CaptureDevice, ename); - - return device->AlcApi.alcGetEnumValue(device->DllDevice, ename); - } - - LastError = ALC_INVALID_ENUM; - return 0; -} - - - - -//***************************************************************************** -// alcGetError -//***************************************************************************** -ALCAPI ALenum ALCAPIENTRY alcGetError(ALCdevice* device) -{ -#ifdef _LOGCALLS - LOG("alcGetError device %p\n", device); -#endif - ALenum errorCode = ALC_NO_ERROR; - - // Try to get a valid device. - if(!device) - { - if (g_CaptureDevice == device) - return - errorCode = LastError; - LastError = ALC_NO_ERROR; - return errorCode; - } - - // - // Check if its a 3rd party device. - // - if (device == g_CaptureDevice) - errorCode = g_CaptureDevice->AlcApi.alcGetError(g_CaptureDevice->CaptureDevice); - else - errorCode = device->AlcApi.alcGetError(device->DllDevice); - - return errorCode; -} - - - - -//***************************************************************************** -// alcGetIntegerv -//***************************************************************************** -ALCAPI ALvoid ALCAPIENTRY alcGetIntegerv(ALCdevice* device, ALenum param, ALsizei size, ALint* data) -{ -#ifdef _LOGCALLS - LOG("alcGetIntegerv device %p enum ", device); - switch (param) - { - case ALC_ATTRIBUTES_SIZE: - LOG("ALC_ATTRIBUTES_SIZE\n"); - break; - case ALC_ALL_ATTRIBUTES: - LOG("ALC_ALL_ATTRIBUTES\n"); - break; - case ALC_MAJOR_VERSION: - LOG("ALC_MAJOR_VERSION\n"); - break; - case ALC_MINOR_VERSION: - LOG("ALC_MINOR_VERSION\n"); - break; - case ALC_CAPTURE_SAMPLES: - LOG("ALC_CAPTURE_SAMPLES\n"); - break; - case ALC_FREQUENCY: - LOG("ALC_FREQUENCY\n"); - break; - case ALC_REFRESH: - LOG("ALC_REFRESH\n"); - break; - case ALC_SYNC: - LOG("ALC_SYNC\n"); - break; - case ALC_MONO_SOURCES: - LOG("ALC_MONO_SOURCES\n"); - break; - case ALC_STEREO_SOURCES: - LOG("ALC_STEREO_SOURCES\n"); - break; - case 0x20003: // ALC_MAX_AUXILIARY_SENDS - LOG("ALC_MAX_AUXILIARY_SENDS\n"); - break; - case 0x20001: // ALC_EFX_MAJOR_VERSION - LOG("ALC_EFX_MAJOR_VERSION\n"); - break; - case 0x20002: // ALC_EFX_MINOR_VERSION - LOG("ALC_EFX_MINOR_VERSION\n"); - break; - default: - LOG("<Unknown>\n"); - break; - } -#endif - - if(device) - { - if (device == g_CaptureDevice) - { - g_CaptureDevice->AlcApi.alcGetIntegerv(g_CaptureDevice->CaptureDevice, param, size, data); - return; - } - - device->AlcApi.alcGetIntegerv(device->DllDevice, param, size, data); - return; - } - - switch(param) - { - case ALC_MAJOR_VERSION: - { - if((size < sizeof(ALint)) || (data == 0)) - { - LastError = ALC_INVALID; - return; - } - - *data = alcMajorVersion; - } - break; - - case ALC_MINOR_VERSION: - { - if((size < sizeof(ALint)) || (data == 0)) - { - LastError = ALC_INVALID; - return; - } - - *data = alcMinorVersion; - } - break; - - default: - { - device->LastError = ALC_INVALID_ENUM; - } - break; - } -} - - - - -//***************************************************************************** -// alcGetProcAddress -//***************************************************************************** -ALCAPI ALvoid* ALCAPIENTRY alcGetProcAddress(ALCdevice* device, const ALCchar* fname) -{ -#ifdef _LOGCALLS - LOG("alcGetProcAddress device %p function name '%s'\n", device, fname ? fname : "<NULL>"); -#endif - - // - // Always return the router version of the ALC function if it exists. - // - ALsizei i = 0; - while(alcFunctions[i].fname && strcmp((char*)alcFunctions[i].fname, (char*)fname)) - { - i++; - } - - if(alcFunctions[i].fname) - { - return alcFunctions[i].address; - } - - if(device) - { - if (device == g_CaptureDevice) - return g_CaptureDevice->AlcApi.alcGetProcAddress(g_CaptureDevice->CaptureDevice, fname); - - return device->AlcApi.alcGetProcAddress(device->DllDevice, fname); - } - - LastError = ALC_INVALID_ENUM; - return 0; -} - - - - -//***************************************************************************** -// alcIsExtensionPresent -//***************************************************************************** -ALCAPI ALboolean ALCAPIENTRY alcIsExtensionPresent(ALCdevice* device, const ALCchar* ename) -{ -#ifdef _LOGCALLS - LOG("alcIsExtensionPresent device %p extension name '%s'\n", device, ename ? ename : "<NULL>"); -#endif - // - // Check if its a router supported extension first as its a good idea to have - // ALC calls go through the router if possible. - // - ALsizei i = 0; - while(alcExtensions[i].ename && _stricmp((char*)alcExtensions[i].ename, (char*)ename)) - { - i++; - } - - if(alcExtensions[i].ename) - { - return ALC_TRUE; - } - - // - // Check the device passed in to see if the extension is supported. - // - if(device) - { - if (device == g_CaptureDevice) - return g_CaptureDevice->AlcApi.alcIsExtensionPresent(g_CaptureDevice->CaptureDevice, ename); - - return device->AlcApi.alcIsExtensionPresent(device->DllDevice, ename); - } - - LastError = ALC_INVALID_ENUM; - return ALC_FALSE; -} - - - - -//***************************************************************************** -// alcMakeContextCurrent -//***************************************************************************** -ALCAPI ALboolean ALCAPIENTRY alcMakeContextCurrent(ALCcontext* context) -{ -#ifdef _LOGCALLS - LOG("alcMakeContextCurrent context %p\n", context); -#endif - ALboolean contextSwitched = AL_TRUE; - - // - // Context must be a valid context or 0 - // - alListAcquireLock(alContextList); - if(!alListMatchData(alContextList, context) && context != 0) - { - alListReleaseLock(alContextList); - return ALC_FALSE; - } - - // - // Try the new context. - // - if(context) - { - contextSwitched = context->Device->AlcApi.alcMakeContextCurrent(context->DllContext); - - // - // If this is the first time the context has been made the current context, fill in the context - // function pointers. - // - if(contextSwitched && !context->AlApi.alGetProcAddress) - { - // - // Don't fill out the functions here in case they are context specific pointers in the device. - // - if(!FillOutAlFunctions(context)) - { - LastError = ALC_INVALID_CONTEXT; - contextSwitched = AL_FALSE; - - // - // Something went wrong, restore the old context. - // - if(alCurrentContext) - { - alCurrentContext->Device->AlcApi.alcMakeContextCurrent(alCurrentContext->DllContext); - } - - else - { - alCurrentContext->Device->AlcApi.alcMakeContextCurrent(0); - } - } - } - } else { - if ((alCurrentContext) && (alCurrentContext->Device) && (alCurrentContext->Device->AlcApi.alcMakeContextCurrent)) { - contextSwitched = alCurrentContext->Device->AlcApi.alcMakeContextCurrent(0); - } - } - - // - // Set the context states if the switch was successful. - // - if(contextSwitched) - { - alCurrentContext = context; - } - - alListReleaseLock(alContextList); - return contextSwitched; -} - - - - -//***************************************************************************** -// alcOpenDevice -//***************************************************************************** -ALCAPI ALCdevice* ALCAPIENTRY alcOpenDevice(const ALCchar* deviceName) -{ -#ifdef _LOGCALLS - LOG("alcOpenDevice device name '%s'\n", deviceName ? deviceName : "<NULL>"); -#endif - HINSTANCE dll = 0; - ALCdevice* device = 0; - const ALchar *pszDeviceName = NULL; - - BuildDeviceList(); - - if (g_pDeviceList) - { - if ((!deviceName) || (strlen(deviceName)==0) || (strcmp(deviceName, "DirectSound3D")==0)) - pszDeviceName = pszDefaultDeviceSpecifier; - else - pszDeviceName = deviceName; - - // Search for device in Playback Device List - dll = LoadDevicesDLL(g_pDeviceList, pszDeviceName); - - if (!dll) - { - // If NOT found, and the requested name is one of these ... - // "Generic Hardware" (no longer available on Windows Vista) - // "DirectSound" (legacy name for OpenAL Software mixer device) - // "MMSYSTEM" (legacy name for OpenAL Software mixer using MMSYSTEM instead of DirectSound) - // try to open the "Generic Software" device instead - if ((strcmp(pszDeviceName, "Generic Hardware") == 0) || - (strcmp(pszDeviceName, "DirectSound") == 0) || - (strcmp(pszDeviceName, "MMSYSTEM") == 0)) - { - dll = LoadDevicesDLL(g_pDeviceList, "Generic Software"); - } - } - - if (!dll) - dll = LoadDevicesDLL(g_pAllDevicesList, pszDeviceName); - - if (dll) - { - device = (ALCdevice*)malloc(sizeof(ALCdevice)); - if (device) - { - memset(device, 0, sizeof(ALCdevice)); - device->LastError = ALC_NO_ERROR; - device->InUse = 0; - device->Dll = dll; - if (FillOutAlcFunctions(device)) - device->DllDevice = device->AlcApi.alcOpenDevice(pszDeviceName); - - if (!device->DllDevice) - { - FreeLibrary(dll); - free(device); - device = 0; - } - } - } - } - - if (!device) - LastError = ALC_INVALID_DEVICE; - - return device; -} - - - - -//***************************************************************************** -// alcProcessContext -//***************************************************************************** -ALCAPI ALvoid ALCAPIENTRY alcProcessContext(ALCcontext* context) -{ -#ifdef _LOGCALLS - LOG("alcProcessContext context %p\n", context); -#endif - alListAcquireLock(alContextList); - if(!context && !alCurrentContext) - { - alListReleaseLock(alContextList); - return; - } - - if(!context) - { - context = alCurrentContext; - } - - EnterCriticalSection(&context->Lock); - alListReleaseLock(alContextList); - - if(context->DllContext) - { - context->Device->AlcApi.alcProcessContext(context->DllContext); - } - - context->Suspended = FALSE; - - LeaveCriticalSection(&context->Lock); - return; -} - - - - -//***************************************************************************** -// alcSuspendContext -//***************************************************************************** -ALCAPI ALCvoid ALCAPIENTRY alcSuspendContext(ALCcontext* context) -{ -#ifdef _LOGCALLS - LOG("alcSuspendContext context %p\n", context); -#endif - alListAcquireLock(alContextList); - if(!context && !alCurrentContext) - { - alListReleaseLock(alContextList); - return; - } - - if(!context) - { - context = (ALCcontext *)alCurrentContext; - } - - EnterCriticalSection(&context->Lock); - alListReleaseLock(alContextList); - - context->Suspended = TRUE; - - if(context->DllContext) - { - context->Device->AlcApi.alcSuspendContext(context->DllContext); - } - - LeaveCriticalSection(&context->Lock); - return; -} - - - - -//***************************************************************************** -// alcGetString -//***************************************************************************** -ALCAPI const ALCchar* ALCAPIENTRY alcGetString(ALCdevice* device, ALenum param) -{ -#ifdef _LOGCALLS - LOG("alcGetString device %p enum ", device); - switch (param) - { - case ALC_NO_ERROR: - LOG("ALC_NO_ERROR\n"); - break; - case ALC_INVALID_ENUM: - LOG("ALC_INVALID_ENUM\n"); - break; - case ALC_INVALID_VALUE: - LOG("ALC_INVALID_VALUE\n"); - break; - case ALC_INVALID_DEVICE: - LOG("ALC_INVALID_DEVICE\n"); - break; - case ALC_INVALID_CONTEXT: - LOG("ALC_INVALID_CONTEXT\n"); - break; - case ALC_DEFAULT_DEVICE_SPECIFIER: - LOG("ALC_DEFAULT_DEVICE_SPECIFIER\n"); - break; - case ALC_DEVICE_SPECIFIER: - LOG("ALC_DEVICE_SPECIFIER\n"); - break; - case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER: - LOG("ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER\n"); - break; - case ALC_CAPTURE_DEVICE_SPECIFIER: - LOG("ALC_CAPTURE_DEVICE_SPECIFIER\n"); - break; - case ALC_ALL_DEVICES_SPECIFIER: - LOG("ALC_ALL_DEVICES_SPECIFIER\n"); - break; - case ALC_DEFAULT_ALL_DEVICES_SPECIFIER: - LOG("ALC_DEFAULT_ALL_DEVICES_SPECIFIER\n"); - break; - case ALC_EXTENSIONS: - LOG("ALC_EXTENSIONS\n"); - break; - default: - LOG("<Unknown>\n"); - break; - } -#endif - - const ALCchar* value = 0; - - if ((param != ALC_DEFAULT_DEVICE_SPECIFIER) && (param != ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER)) { - if(device) - { - if (device == g_CaptureDevice) - return g_CaptureDevice->AlcApi.alcGetString(g_CaptureDevice->CaptureDevice, param); - - return device->AlcApi.alcGetString(device->DllDevice, param); - } - } - - switch(param) - { - case ALC_NO_ERROR: - { - value = alcNoError; - } - break; - - case ALC_INVALID_ENUM: - { - value = alcErrInvalidEnum; - } - break; - - case ALC_INVALID_VALUE: - { - value = alcErrInvalidValue; - } - break; - - case ALC_INVALID_DEVICE: - { - value = alcErrInvalidDevice; - } - break; - - case ALC_INVALID_CONTEXT: - { - value = alcErrInvalidContext; - } - break; - - case ALC_DEFAULT_DEVICE_SPECIFIER: - BuildDeviceList(); - if (pszDefaultDeviceSpecifier) - value = pszDefaultDeviceSpecifier; - else - value = szEmptyString; - break; - - case ALC_DEVICE_SPECIFIER: - BuildDeviceList(); - if (pszDeviceSpecifierList) - value = pszDeviceSpecifierList; - else - value = szEmptyString; - break; - - case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER: - BuildDeviceList(); - if (pszDefaultCaptureDeviceSpecifier) - value = pszDefaultCaptureDeviceSpecifier; - else - value = szEmptyString; - break; - - case ALC_CAPTURE_DEVICE_SPECIFIER: - BuildDeviceList(); - if (pszCaptureDeviceSpecifierList) - value = pszCaptureDeviceSpecifierList; - else - value = szEmptyString; - break; - - case ALC_ALL_DEVICES_SPECIFIER: - BuildDeviceList(); - if (pszAllDevicesSpecifierList) - value = pszAllDevicesSpecifierList; - else - value = szEmptyString; - break; - - case ALC_DEFAULT_ALL_DEVICES_SPECIFIER: - BuildDeviceList(); - if (pszDefaultAllDevicesSpecifier) - value = pszDefaultAllDevicesSpecifier; - else - value = szEmptyString; - break; - - default: - LastError = ALC_INVALID_ENUM; - break; - } - - return value; -} - - - - -//***************************************************************************** -// alcCaptureOpenDevice -//***************************************************************************** -ALCAPI ALCdevice * ALCAPIENTRY alcCaptureOpenDevice(const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei buffersize) -{ -#ifdef _LOGCALLS - LOG("alcCaptureOpenDevice device name '%s' frequency %d format %d buffersize %d\n", deviceName ? deviceName : "<NULL>", frequency, format, buffersize); -#endif - const ALchar *pszDeviceName = NULL; - - BuildDeviceList(); - - if (!g_pCaptureDeviceList) - return NULL; - - if (!g_CaptureDevice) { - g_CaptureDevice = (ALCdevice*)malloc(sizeof(ALCdevice)); - - if (g_CaptureDevice) - { - // clear - memset(g_CaptureDevice, 0, sizeof(ALCdevice)); - - // make sure we have a device name - if ((!deviceName) || (strlen(deviceName) == 0)) - pszDeviceName = pszDefaultCaptureDeviceSpecifier; - else - pszDeviceName = deviceName; - - g_CaptureDevice->Dll = LoadDevicesDLL(g_pCaptureDeviceList, pszDeviceName); - - if (g_CaptureDevice->Dll) { - if(FillOutAlcFunctions(g_CaptureDevice)) { - if (g_CaptureDevice->AlcApi.alcCaptureOpenDevice) { - g_CaptureDevice->CaptureDevice = g_CaptureDevice->AlcApi.alcCaptureOpenDevice(pszDeviceName, frequency, format, buffersize); - g_CaptureDevice->LastError = ALC_NO_ERROR; - g_CaptureDevice->InUse = 0; - } else { - g_CaptureDevice->LastError = ALC_INVALID_DEVICE; - } - } - } - } - } else { - // already open - g_CaptureDevice->LastError = ALC_INVALID_VALUE; - } - - if (g_CaptureDevice != NULL) { - if (g_CaptureDevice->CaptureDevice) { - return g_CaptureDevice; - } else { - free(g_CaptureDevice); - g_CaptureDevice = NULL; - return NULL; - } - } else { - return NULL; - } -} - - - - -//***************************************************************************** -// alcCaptureCloseDevice -//***************************************************************************** -ALCAPI ALCboolean ALCAPIENTRY alcCaptureCloseDevice(ALCdevice *device) -{ -#ifdef _LOGCALLS - LOG("alcCaptureCloseDevice device %p\n", device); -#endif - ALCboolean bReturn = ALC_FALSE; - - if (device == g_CaptureDevice) - { - if (g_CaptureDevice != NULL) { - if (g_CaptureDevice->AlcApi.alcCaptureCloseDevice) { - bReturn = g_CaptureDevice->AlcApi.alcCaptureCloseDevice(g_CaptureDevice->CaptureDevice); - delete g_CaptureDevice; - g_CaptureDevice = NULL; - } else { - g_CaptureDevice->LastError = ALC_INVALID_DEVICE; - } - } - } - - return bReturn; -} - - - - -//***************************************************************************** -// alcCaptureStart -//***************************************************************************** -ALCAPI ALCvoid ALCAPIENTRY alcCaptureStart(ALCdevice *device) -{ -#ifdef _LOGCALLS - LOG("alcCaptureStart device %p\n", device); -#endif - if (device == g_CaptureDevice) - { - if (g_CaptureDevice != NULL) { - if (g_CaptureDevice->AlcApi.alcCaptureStart) { - g_CaptureDevice->AlcApi.alcCaptureStart(g_CaptureDevice->CaptureDevice); - } else { - g_CaptureDevice->LastError = ALC_INVALID_DEVICE; - } - } - } - - return; -} - - - - -//***************************************************************************** -// alcCaptureStop -//***************************************************************************** -ALCAPI ALCvoid ALCAPIENTRY alcCaptureStop(ALCdevice *device) -{ -#ifdef _LOGCALLS - LOG("alcCaptureStop device %p\n", device); -#endif - if (device == g_CaptureDevice) - { - if (g_CaptureDevice != NULL) { - if (g_CaptureDevice->AlcApi.alcCaptureStop) { - g_CaptureDevice->AlcApi.alcCaptureStop(g_CaptureDevice->CaptureDevice); - } else { - g_CaptureDevice->LastError = ALC_INVALID_DEVICE; - } - } - } - - return; -} - - - - -//***************************************************************************** -// alcCaptureSamples -//***************************************************************************** -ALCAPI ALCvoid ALCAPIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples) -{ -#ifdef _LOGCALLS - LOG("alcCaptureSamples device %p buffer %p samples %d\n", device, buffer, samples); -#endif - if (device == g_CaptureDevice) - { - if (g_CaptureDevice != NULL) { - if (g_CaptureDevice->AlcApi.alcCaptureSamples) { - g_CaptureDevice->AlcApi.alcCaptureSamples(g_CaptureDevice->CaptureDevice, buffer, samples); - } else { - g_CaptureDevice->LastError = ALC_INVALID_DEVICE; - } - } - } - - return; -} - -#ifdef _LOGCALLS -void OutputMessage(const char *szDebug,...) -{ - static FILE *pFile = NULL; - SYSTEMTIME sysTime; - va_list args; - - va_start(args, szDebug); - - if (!pFile) - { - pFile = fopen(LOGFILENAME, "w"); - GetLocalTime(&sysTime); - fprintf(pFile, "OpenAL Router\n\nLog Time : %d/%d/%d at %d:%s%d:%s%d\n\n", sysTime.wDay, sysTime.wMonth, sysTime.wYear, - sysTime.wHour, (sysTime.wMinute < 10) ? "0" : "", sysTime.wMinute, (sysTime.wSecond < 10) ? "0" : "", sysTime.wSecond); - } - - vfprintf(pFile, szDebug, args); - fflush(pFile); - - va_end(args); -} -#endif
\ No newline at end of file |