rlm@0: /**
rlm@0:  * OpenAL cross platform audio library
rlm@0:  * Copyright (C) 2011 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 <stdlib.h>
rlm@0: #ifdef HAVE_DLFCN_H
rlm@0: #include <dlfcn.h>
rlm@0: #endif
rlm@0: 
rlm@0: #if defined(HAVE_GUIDDEF_H) || defined(HAVE_INITGUID_H)
rlm@0: #define INITGUID
rlm@0: #include <windows.h>
rlm@0: #ifdef HAVE_GUIDDEF_H
rlm@0: #include <guiddef.h>
rlm@0: #else
rlm@0: #include <initguid.h>
rlm@0: #endif
rlm@0: 
rlm@0: DEFINE_GUID(KSDATAFORMAT_SUBTYPE_PCM,        0x00000001, 0x0000, 0x0010, 0x80,0x00, 0x00,0xaa,0x00,0x38,0x9b,0x71);
rlm@0: DEFINE_GUID(KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, 0x00000003, 0x0000, 0x0010, 0x80,0x00, 0x00,0xaa,0x00,0x38,0x9b,0x71);
rlm@0: 
rlm@0: DEFINE_GUID(IID_IDirectSoundNotify,   0xb0210783, 0x89cd, 0x11d0, 0xaf,0x08, 0x00,0xa0,0xc9,0x25,0xcd,0x16);
rlm@0: 
rlm@0: DEFINE_GUID(CLSID_MMDeviceEnumerator, 0xbcde0395, 0xe52f, 0x467c, 0x8e,0x3d, 0xc4,0x57,0x92,0x91,0x69,0x2e);
rlm@0: DEFINE_GUID(IID_IMMDeviceEnumerator,  0xa95664d2, 0x9614, 0x4f35, 0xa7,0x46, 0xde,0x8d,0xb6,0x36,0x17,0xe6);
rlm@0: DEFINE_GUID(IID_IAudioClient,         0x1cb9ad4c, 0xdbfa, 0x4c32, 0xb1,0x78, 0xc2,0xf5,0x68,0xa7,0x03,0xb2);
rlm@0: DEFINE_GUID(IID_IAudioRenderClient,   0xf294acfc, 0x3146, 0x4483, 0xa7,0xbf, 0xad,0xdc,0xa7,0xc2,0x60,0xe2);
rlm@0: 
rlm@0: #endif
rlm@0: 
rlm@0: #include "alMain.h"
rlm@0: 
rlm@0: #ifdef _WIN32
rlm@0: void pthread_once(pthread_once_t *once, void (*callback)(void))
rlm@0: {
rlm@0:     LONG ret;
rlm@0:     while((ret=InterlockedExchange(once, 1)) == 1)
rlm@0:         Sleep(0);
rlm@0:     if(ret == 0)
rlm@0:         callback();
rlm@0:     InterlockedExchange(once, 2);
rlm@0: }
rlm@0: 
rlm@0: void *LoadLib(const char *name)
rlm@0: { return LoadLibraryA(name); }
rlm@0: void CloseLib(void *handle)
rlm@0: { FreeLibrary((HANDLE)handle); }
rlm@0: void *GetSymbol(void *handle, const char *name)
rlm@0: {
rlm@0:     void *ret;
rlm@0: 
rlm@0:     ret = (void*)GetProcAddress((HANDLE)handle, name);
rlm@0:     if(ret == NULL)
rlm@0:         ERR("Failed to load %s\n", name);
rlm@0:     return ret;
rlm@0: }
rlm@0: 
rlm@0: #else
rlm@0: 
rlm@0: void InitializeCriticalSection(CRITICAL_SECTION *cs)
rlm@0: {
rlm@0:     pthread_mutexattr_t attrib;
rlm@0:     int ret;
rlm@0: 
rlm@0:     ret = pthread_mutexattr_init(&attrib);
rlm@0:     assert(ret == 0);
rlm@0: 
rlm@0:     ret = pthread_mutexattr_settype(&attrib, PTHREAD_MUTEX_RECURSIVE);
rlm@0: #ifdef HAVE_PTHREAD_NP_H
rlm@0:     if(ret != 0)
rlm@0:         ret = pthread_mutexattr_setkind_np(&attrib, PTHREAD_MUTEX_RECURSIVE);
rlm@0: #endif
rlm@0:     assert(ret == 0);
rlm@0:     ret = pthread_mutex_init(cs, &attrib);
rlm@0:     assert(ret == 0);
rlm@0: 
rlm@0:     pthread_mutexattr_destroy(&attrib);
rlm@0: }
rlm@0: void DeleteCriticalSection(CRITICAL_SECTION *cs)
rlm@0: {
rlm@0:     int ret;
rlm@0:     ret = pthread_mutex_destroy(cs);
rlm@0:     assert(ret == 0);
rlm@0: }
rlm@0: void EnterCriticalSection(CRITICAL_SECTION *cs)
rlm@0: {
rlm@0:     int ret;
rlm@0:     ret = pthread_mutex_lock(cs);
rlm@0:     assert(ret == 0);
rlm@0: }
rlm@0: void LeaveCriticalSection(CRITICAL_SECTION *cs)
rlm@0: {
rlm@0:     int ret;
rlm@0:     ret = pthread_mutex_unlock(cs);
rlm@0:     assert(ret == 0);
rlm@0: }
rlm@0: 
rlm@0: /* NOTE: This wrapper isn't quite accurate as it returns an ALuint, as opposed
rlm@0:  * to the expected DWORD. Both are defined as unsigned 32-bit types, however.
rlm@0:  * Additionally, Win32 is supposed to measure the time since Windows started,
rlm@0:  * as opposed to the actual time. */
rlm@0: ALuint timeGetTime(void)
rlm@0: {
rlm@0: #if _POSIX_TIMERS > 0
rlm@0:     struct timespec ts;
rlm@0:     int ret = -1;
rlm@0: 
rlm@0: #if defined(_POSIX_MONOTONIC_CLOCK) && (_POSIX_MONOTONIC_CLOCK >= 0)
rlm@0: #if _POSIX_MONOTONIC_CLOCK == 0
rlm@0:     static int hasmono = 0;
rlm@0:     if(hasmono > 0 || (hasmono == 0 &&
rlm@0:                        (hasmono=sysconf(_SC_MONOTONIC_CLOCK)) > 0))
rlm@0: #endif
rlm@0:         ret = clock_gettime(CLOCK_MONOTONIC, &ts);
rlm@0: #endif
rlm@0:     if(ret != 0)
rlm@0:         ret = clock_gettime(CLOCK_REALTIME, &ts);
rlm@0:     assert(ret == 0);
rlm@0: 
rlm@0:     return ts.tv_nsec/1000000 + ts.tv_sec*1000;
rlm@0: #else
rlm@0:     struct timeval tv;
rlm@0:     int ret;
rlm@0: 
rlm@0:     ret = gettimeofday(&tv, NULL);
rlm@0:     assert(ret == 0);
rlm@0: 
rlm@0:     return tv.tv_usec/1000 + tv.tv_sec*1000;
rlm@0: #endif
rlm@0: }
rlm@0: 
rlm@0: #ifdef HAVE_DLFCN_H
rlm@0: 
rlm@0: void *LoadLib(const char *name)
rlm@0: {
rlm@0:     const char *err;
rlm@0:     void *handle;
rlm@0: 
rlm@0:     dlerror();
rlm@0:     handle = dlopen(name, RTLD_NOW);
rlm@0:     if((err=dlerror()) != NULL)
rlm@0:         handle = NULL;
rlm@0:     return handle;
rlm@0: }
rlm@0: void CloseLib(void *handle)
rlm@0: { dlclose(handle); }
rlm@0: void *GetSymbol(void *handle, const char *name)
rlm@0: {
rlm@0:     const char *err;
rlm@0:     void *sym;
rlm@0: 
rlm@0:     dlerror();
rlm@0:     sym = dlsym(handle, name);
rlm@0:     if((err=dlerror()) != NULL)
rlm@0:     {
rlm@0:         ERR("Failed to load %s: %s\n", name, err);
rlm@0:         sym = NULL;
rlm@0:     }
rlm@0:     return sym;
rlm@0: }
rlm@0: 
rlm@0: #endif
rlm@0: #endif
rlm@0: 
rlm@0: 
rlm@0: void al_print(const char *fname, unsigned int line, const char *fmt, ...)
rlm@0: {
rlm@0:     const char *fn;
rlm@0:     char str[256];
rlm@0:     int i;
rlm@0: 
rlm@0:     fn = strrchr(fname, '/');
rlm@0:     if(!fn) fn = strrchr(fname, '\\');
rlm@0:     if(!fn) fn = fname;
rlm@0:     else fn += 1;
rlm@0: 
rlm@0:     i = snprintf(str, sizeof(str), "AL lib: %s:%d: ", fn, line);
rlm@0:     if(i < (int)sizeof(str) && i > 0)
rlm@0:     {
rlm@0:         va_list ap;
rlm@0:         va_start(ap, fmt);
rlm@0:         vsnprintf(str+i, sizeof(str)-i, fmt, ap);
rlm@0:         va_end(ap);
rlm@0:     }
rlm@0:     str[sizeof(str)-1] = 0;
rlm@0: 
rlm@0:     fprintf(LogFile, "%s", str);
rlm@0:     fflush(LogFile);
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: void SetRTPriority(void)
rlm@0: {
rlm@0:     ALboolean failed;
rlm@0: 
rlm@0: #ifdef _WIN32
rlm@0:     if(RTPrioLevel > 0)
rlm@0:         failed = !SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
rlm@0:     else
rlm@0:         failed = !SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
rlm@0: #elif defined(HAVE_PTHREAD_SETSCHEDPARAM) && !defined(__OpenBSD__)
rlm@0:     struct sched_param param;
rlm@0: 
rlm@0:     if(RTPrioLevel > 0)
rlm@0:     {
rlm@0:         /* Use the minimum real-time priority possible for now (on Linux this
rlm@0:          * should be 1 for SCHED_RR) */
rlm@0:         param.sched_priority = sched_get_priority_min(SCHED_RR);
rlm@0:         failed = !!pthread_setschedparam(pthread_self(), SCHED_RR, &param);
rlm@0:     }
rlm@0:     else
rlm@0:     {
rlm@0:         param.sched_priority = 0;
rlm@0:         failed = !!pthread_setschedparam(pthread_self(), SCHED_OTHER, &param);
rlm@0:     }
rlm@0: #else
rlm@0:     /* Real-time priority not available */
rlm@0:     failed = (RTPrioLevel>0);
rlm@0: #endif
rlm@0:     if(failed)
rlm@0:         ERR("Failed to set priority level for thread\n");
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: void InitUIntMap(UIntMap *map)
rlm@0: {
rlm@0:     map->array = NULL;
rlm@0:     map->size = 0;
rlm@0:     map->maxsize = 0;
rlm@0: }
rlm@0: 
rlm@0: void ResetUIntMap(UIntMap *map)
rlm@0: {
rlm@0:     free(map->array);
rlm@0:     map->array = NULL;
rlm@0:     map->size = 0;
rlm@0:     map->maxsize = 0;
rlm@0: }
rlm@0: 
rlm@0: ALenum InsertUIntMapEntry(UIntMap *map, ALuint key, ALvoid *value)
rlm@0: {
rlm@0:     ALsizei pos = 0;
rlm@0: 
rlm@0:     if(map->size > 0)
rlm@0:     {
rlm@0:         ALsizei low = 0;
rlm@0:         ALsizei high = map->size - 1;
rlm@0:         while(low < high)
rlm@0:         {
rlm@0:             ALsizei mid = low + (high-low)/2;
rlm@0:             if(map->array[mid].key < key)
rlm@0:                 low = mid + 1;
rlm@0:             else
rlm@0:                 high = mid;
rlm@0:         }
rlm@0:         if(map->array[low].key < key)
rlm@0:             low++;
rlm@0:         pos = low;
rlm@0:     }
rlm@0: 
rlm@0:     if(pos == map->size || map->array[pos].key != key)
rlm@0:     {
rlm@0:         if(map->size == map->maxsize)
rlm@0:         {
rlm@0:             ALvoid *temp;
rlm@0:             ALsizei newsize;
rlm@0: 
rlm@0:             newsize = (map->maxsize ? (map->maxsize<<1) : 4);
rlm@0:             if(newsize < map->maxsize)
rlm@0:                 return AL_OUT_OF_MEMORY;
rlm@0: 
rlm@0:             temp = realloc(map->array, newsize*sizeof(map->array[0]));
rlm@0:             if(!temp) return AL_OUT_OF_MEMORY;
rlm@0:             map->array = temp;
rlm@0:             map->maxsize = newsize;
rlm@0:         }
rlm@0: 
rlm@0:         map->size++;
rlm@0:         if(pos < map->size-1)
rlm@0:             memmove(&map->array[pos+1], &map->array[pos],
rlm@0:                     (map->size-1-pos)*sizeof(map->array[0]));
rlm@0:     }
rlm@0:     map->array[pos].key = key;
rlm@0:     map->array[pos].value = value;
rlm@0: 
rlm@0:     return AL_NO_ERROR;
rlm@0: }
rlm@0: 
rlm@0: void RemoveUIntMapKey(UIntMap *map, ALuint key)
rlm@0: {
rlm@0:     if(map->size > 0)
rlm@0:     {
rlm@0:         ALsizei low = 0;
rlm@0:         ALsizei high = map->size - 1;
rlm@0:         while(low < high)
rlm@0:         {
rlm@0:             ALsizei mid = low + (high-low)/2;
rlm@0:             if(map->array[mid].key < key)
rlm@0:                 low = mid + 1;
rlm@0:             else
rlm@0:                 high = mid;
rlm@0:         }
rlm@0:         if(map->array[low].key == key)
rlm@0:         {
rlm@0:             if(low < map->size-1)
rlm@0:                 memmove(&map->array[low], &map->array[low+1],
rlm@0:                         (map->size-1-low)*sizeof(map->array[0]));
rlm@0:             map->size--;
rlm@0:         }
rlm@0:     }
rlm@0: }
rlm@0: 
rlm@0: ALvoid *LookupUIntMapKey(UIntMap *map, ALuint key)
rlm@0: {
rlm@0:     if(map->size > 0)
rlm@0:     {
rlm@0:         ALsizei low = 0;
rlm@0:         ALsizei high = map->size - 1;
rlm@0:         while(low < high)
rlm@0:         {
rlm@0:             ALsizei mid = low + (high-low)/2;
rlm@0:             if(map->array[mid].key < key)
rlm@0:                 low = mid + 1;
rlm@0:             else
rlm@0:                 high = mid;
rlm@0:         }
rlm@0:         if(map->array[low].key == key)
rlm@0:             return map->array[low].value;
rlm@0:     }
rlm@0:     return NULL;
rlm@0: }