Alc/helpers.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 2011 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  *  Boston, MA  02111-1307, USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include <malloc.h>
  24 #include <stdlib.h>
  25 #include <time.h>
  26 #include <errno.h>
  27 #include <stdarg.h>
  28
  29 #if defined(HAVE_GUIDDEF_H) || defined(HAVE_INITGUID_H)
  30 #define INITGUID
  31 #include <windows.h>
  32 #ifdef HAVE_GUIDDEF_H
  33 #include <guiddef.h>
  34 #else
  35 #include <initguid.h>
  36 #endif
  37
  38 DEFINE_GUID(KSDATAFORMAT_SUBTYPE_PCM,        0x00000001, 0x0000, 0x0010, 0x80,0x00, 0x00,0xaa,0x00,0x38,0x9b,0x71);
  39 DEFINE_GUID(KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, 0x00000003, 0x0000, 0x0010, 0x80,0x00, 0x00,0xaa,0x00,0x38,0x9b,0x71);
  40
  41 DEFINE_GUID(IID_IDirectSoundNotify,   0xb0210783, 0x89cd, 0x11d0, 0xaf,0x08, 0x00,0xa0,0xc9,0x25,0xcd,0x16);
  42
  43 DEFINE_GUID(CLSID_MMDeviceEnumerator, 0xbcde0395, 0xe52f, 0x467c, 0x8e,0x3d, 0xc4,0x57,0x92,0x91,0x69,0x2e);
  44 DEFINE_GUID(IID_IMMDeviceEnumerator,  0xa95664d2, 0x9614, 0x4f35, 0xa7,0x46, 0xde,0x8d,0xb6,0x36,0x17,0xe6);
  45 DEFINE_GUID(IID_IAudioClient,         0x1cb9ad4c, 0xdbfa, 0x4c32, 0xb1,0x78, 0xc2,0xf5,0x68,0xa7,0x03,0xb2);
  46 DEFINE_GUID(IID_IAudioRenderClient,   0xf294acfc, 0x3146, 0x4483, 0xa7,0xbf, 0xad,0xdc,0xa7,0xc2,0x60,0xe2);
  47
  48 #ifdef HAVE_MMDEVAPI
  49 #include <devpropdef.h>
  50 DEFINE_DEVPROPKEY(DEVPKEY_Device_FriendlyName, 0xa45c254e, 0xdf1c, 0x4efd, 0x80,0x20, 0x67,0xd1,0x46,0xa8,0x50,0xe0, 14);
  51 #endif
  52 #endif
  53 #ifdef HAVE_DLFCN_H
  54 #include <dlfcn.h>
  55 #endif
  56 #ifdef HAVE_CPUID_H
  57 #include <cpuid.h>
  58 #endif
  59 #ifdef HAVE_FLOAT_H
  60 #include <float.h>
  61 #endif
  62 #ifdef HAVE_IEEEFP_H
  63 #include <ieeefp.h>
  64 #endif
  65
  66 #include "alMain.h"
  67
  68 ALuint CPUCapFlags = 0;
  69
  70
  71 void FillCPUCaps(ALuint capfilter)
  72 {
  73     ALuint caps = 0;
  74
  75 /* FIXME: We really should get this for all available CPUs in case different
  76  * CPUs have different caps (is that possible on one machine?). */
  77 #if defined(HAVE_CPUID_H) && (defined(__i386__) || defined(__x86_64__) || \
  78                               defined(_M_IX86) || defined(_M_X64))
  79     union {
  80         unsigned int regs[4];
  81         char str[sizeof(unsigned int[4])];
  82     } cpuinf[3];
  83
  84     if(!__get_cpuid(0, &cpuinf[0].regs[0], &cpuinf[0].regs[1], &cpuinf[0].regs[2], &cpuinf[0].regs[3]))
  85         ERR("Failed to get CPUID\n");
  86     else
  87     {
  88         unsigned int maxfunc = cpuinf[0].regs[0];
  89         unsigned int maxextfunc = 0;
  90
  91         if(__get_cpuid(0x80000000, &cpuinf[0].regs[0], &cpuinf[0].regs[1], &cpuinf[0].regs[2], &cpuinf[0].regs[3]))
  92             maxextfunc = cpuinf[0].regs[0];
  93         TRACE("Detected max CPUID function: 0x%x (ext. 0x%x)\n", maxfunc, maxextfunc);
  94
  95         TRACE("Vendor ID: \"%.4s%.4s%.4s\"\n", cpuinf[0].str+4, cpuinf[0].str+12, cpuinf[0].str+8);
  96         if(maxextfunc >= 0x80000004 &&
  97            __get_cpuid(0x80000002, &cpuinf[0].regs[0], &cpuinf[0].regs[1], &cpuinf[0].regs[2], &cpuinf[0].regs[3]) &&
  98            __get_cpuid(0x80000003, &cpuinf[1].regs[0], &cpuinf[1].regs[1], &cpuinf[1].regs[2], &cpuinf[1].regs[3]) &&
  99            __get_cpuid(0x80000004, &cpuinf[2].regs[0], &cpuinf[2].regs[1], &cpuinf[2].regs[2], &cpuinf[2].regs[3]))
 100             TRACE("Name: \"%.16s%.16s%.16s\"\n", cpuinf[0].str, cpuinf[1].str, cpuinf[2].str);
 101
 102         if(maxfunc >= 1 &&
 103            __get_cpuid(1, &cpuinf[0].regs[0], &cpuinf[0].regs[1], &cpuinf[0].regs[2], &cpuinf[0].regs[3]))
 104         {
 105 #ifdef bit_SSE
 106             if((cpuinf[0].regs[3]&bit_SSE))
 107                 caps |= CPU_CAP_SSE;
 108 #endif
 109         }
 110     }
 111 #elif defined(HAVE_WINDOWS_H)
 112     HMODULE k32 = GetModuleHandleA("kernel32.dll");
 113     BOOL (WINAPI*IsProcessorFeaturePresent)(DWORD ProcessorFeature);
 114     IsProcessorFeaturePresent = (BOOL(WINAPI*)(DWORD))GetProcAddress(k32, "IsProcessorFeaturePresent");
 115     if(!IsProcessorFeaturePresent)
 116         ERR("IsProcessorFeaturePresent not available; CPU caps not detected\n");
 117     else
 118     {
 119         if(IsProcessorFeaturePresent(PF_XMMI_INSTRUCTIONS_AVAILABLE))
 120             caps |= CPU_CAP_SSE;
 121     }
 122 #endif
 123 #ifdef HAVE_NEON
 124     /* Assume Neon support if compiled with it */
 125     caps |= CPU_CAP_NEON;
 126 #endif
 127
 128     TRACE("Got caps:%s%s%s\n", ((caps&CPU_CAP_SSE)?((capfilter&CPU_CAP_SSE)?" SSE":" (SSE)"):""),
 129                                ((caps&CPU_CAP_NEON)?((capfilter&CPU_CAP_NEON)?" Neon":" (Neon)"):""),
 130                                ((!caps)?" -none-":""));
 131     CPUCapFlags = caps & capfilter;
 132 }
 133
 134
 135 void *al_malloc(size_t alignment, size_t size)
 136 {
 137 #if defined(HAVE_ALIGNED_ALLOC)
 138     size = (size+(alignment-1))&~(alignment-1);
 139     return aligned_alloc(alignment, size);
 140 #elif defined(HAVE_POSIX_MEMALIGN)
 141     void *ret;
 142     if(posix_memalign(&ret, alignment, size) == 0)
 143         return ret;
 144     return NULL;
 145 #elif defined(HAVE__ALIGNED_MALLOC)
 146     return _aligned_malloc(size, alignment);
 147 #else
 148     char *ret = malloc(size+alignment);
 149     if(ret != NULL)
 150     {
 151         *(ret++) = 0x00;
 152         while(((ALintptrEXT)ret&(alignment-1)) != 0)
 153             *(ret++) = 0x55;
 154     }
 155     return ret;
 156 #endif
 157 }
 158
 159 void *al_calloc(size_t alignment, size_t size)
 160 {
 161     void *ret = al_malloc(alignment, size);
 162     if(ret) memset(ret, 0, size);
 163     return ret;
 164 }
 165
 166 void al_free(void *ptr)
 167 {
 168 #if defined(HAVE_ALIGNED_ALLOC) || defined(HAVE_POSIX_MEMALIGN)
 169     free(ptr);
 170 #elif defined(HAVE__ALIGNED_MALLOC)
 171     _aligned_free(ptr);
 172 #else
 173     if(ptr != NULL)
 174     {
 175         char *finder = ptr;
 176         do {
 177             --finder;
 178         } while(*finder == 0x55);
 179         free(finder);
 180     }
 181 #endif
 182 }
 183
 184
 185 #if (defined(HAVE___CONTROL87_2) || defined(HAVE__CONTROLFP)) && (defined(__x86_64__) || defined(_M_X64))
 186 /* Win64 doesn't allow us to set the precision control. */
 187 #undef _MCW_PC
 188 #define _MCW_PC 0
 189 #endif
 190
 191 void SetMixerFPUMode(FPUCtl *ctl)
 192 {
 193 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
 194     unsigned short fpuState;
 195     __asm__ __volatile__("fnstcw %0" : "=m" (*&fpuState));
 196     ctl->state = fpuState;
 197     fpuState &= ~0x300; /* clear precision to single */
 198     fpuState |=  0xC00; /* set round-to-zero */
 199     __asm__ __volatile__("fldcw %0" : : "m" (*&fpuState));
 200 #ifdef HAVE_SSE
 201     if((CPUCapFlags&CPU_CAP_SSE))
 202     {
 203         int sseState;
 204         __asm__ __volatile__("stmxcsr %0" : "=m" (*&sseState));
 205         ctl->sse_state = sseState;
 206         sseState |= 0x0C00; /* set round-to-zero */
 207         sseState |= 0x8000; /* set flush-to-zero */
 208         __asm__ __volatile__("ldmxcsr %0" : : "m" (*&sseState));
 209     }
 210 #endif
 211 #elif defined(HAVE___CONTROL87_2)
 212     int mode;
 213     __control87_2(0, 0, &ctl->state, NULL);
 214     __control87_2(_RC_CHOP|_PC_24, _MCW_RC|_MCW_PC, &mode, NULL);
 215 #ifdef HAVE_SSE
 216     if((CPUCapFlags&CPU_CAP_SSE))
 217     {
 218         __control87_2(0, 0, NULL, &ctl->sse_state);
 219         __control87_2(_RC_CHOP|_DN_FLUSH, _MCW_RC|_MCW_DN, NULL, &mode);
 220     }
 221 #endif
 222 #elif defined(HAVE__CONTROLFP)
 223     ctl->state = _controlfp(0, 0);
 224     (void)_controlfp(_RC_CHOP|_PC_24, _MCW_RC|_MCW_PC);
 225 #elif defined(HAVE_FESETROUND)
 226     ctl->state = fegetround();
 227 #ifdef FE_TOWARDZERO
 228     fesetround(FE_TOWARDZERO);
 229 #endif
 230 #endif
 231 }
 232
 233 void RestoreFPUMode(const FPUCtl *ctl)
 234 {
 235 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
 236     unsigned short fpuState = ctl->state;
 237     __asm__ __volatile__("fldcw %0" : : "m" (*&fpuState));
 238 #ifdef HAVE_SSE
 239     if((CPUCapFlags&CPU_CAP_SSE))
 240         __asm__ __volatile__("ldmxcsr %0" : : "m" (*&ctl->sse_state));
 241 #endif
 242 #elif defined(HAVE___CONTROL87_2)
 243     int mode;
 244     __control87_2(ctl->state, _MCW_RC|_MCW_PC, &mode, NULL);
 245 #ifdef HAVE_SSE
 246     if((CPUCapFlags&CPU_CAP_SSE))
 247         __control87_2(ctl->sse_state, _MCW_RC|_MCW_DN, NULL, &mode);
 248 #endif
 249 #elif defined(HAVE__CONTROLFP)
 250     _controlfp(ctl->state, _MCW_RC|_MCW_PC);
 251 #elif defined(HAVE_FESETROUND)
 252     fesetround(ctl->state);
 253 #endif
 254 }
 255
 256
 257 #ifdef _WIN32
 258 void pthread_once(pthread_once_t *once, void (*callback)(void))
 259 {
 260     LONG ret;
 261     while((ret=InterlockedExchange(once, 1)) == 1)
 262         sched_yield();
 263     if(ret == 0)
 264         callback();
 265     InterlockedExchange(once, 2);
 266 }
 267
 268
 269 int pthread_key_create(pthread_key_t *key, void (*callback)(void*))
 270 {
 271     *key = TlsAlloc();
 272     if(callback)
 273         InsertUIntMapEntry(&TlsDestructor, *key, callback);
 274     return 0;
 275 }
 276
 277 int pthread_key_delete(pthread_key_t key)
 278 {
 279     InsertUIntMapEntry(&TlsDestructor, key, NULL);
 280     TlsFree(key);
 281     return 0;
 282 }
 283
 284 void *pthread_getspecific(pthread_key_t key)
 285 { return TlsGetValue(key); }
 286
 287 int pthread_setspecific(pthread_key_t key, void *val)
 288 {
 289     TlsSetValue(key, val);
 290     return 0;
 291 }
 292
 293
 294 void *LoadLib(const char *name)
 295 { return LoadLibraryA(name); }
 296 void CloseLib(void *handle)
 297 { FreeLibrary((HANDLE)handle); }
 298 void *GetSymbol(void *handle, const char *name)
 299 {
 300     void *ret;
 301
 302     ret = (void*)GetProcAddress((HANDLE)handle, name);
 303     if(ret == NULL)
 304         ERR("Failed to load %s\n", name);
 305     return ret;
 306 }
 307
 308 WCHAR *strdupW(const WCHAR *str)
 309 {
 310     const WCHAR *n;
 311     WCHAR *ret;
 312     size_t len;
 313
 314     n = str;
 315     while(*n) n++;
 316     len = n - str;
 317
 318     ret = calloc(sizeof(WCHAR), len+1);
 319     if(ret != NULL)
 320         memcpy(ret, str, sizeof(WCHAR)*len);
 321     return ret;
 322 }
 323
 324 #else
 325
 326 #include <pthread.h>
 327 #ifdef HAVE_PTHREAD_NP_H
 328 #include <pthread_np.h>
 329 #endif
 330 #include <sched.h>
 331
 332 void InitializeCriticalSection(CRITICAL_SECTION *cs)
 333 {
 334     pthread_mutexattr_t attrib;
 335     int ret;
 336
 337     ret = pthread_mutexattr_init(&attrib);
 338     assert(ret == 0);
 339
 340     ret = pthread_mutexattr_settype(&attrib, PTHREAD_MUTEX_RECURSIVE);
 341 #ifdef HAVE_PTHREAD_NP_H
 342     if(ret != 0)
 343         ret = pthread_mutexattr_setkind_np(&attrib, PTHREAD_MUTEX_RECURSIVE);
 344 #endif
 345     assert(ret == 0);
 346     ret = pthread_mutex_init(cs, &attrib);
 347     assert(ret == 0);
 348
 349     pthread_mutexattr_destroy(&attrib);
 350 }
 351 void DeleteCriticalSection(CRITICAL_SECTION *cs)
 352 {
 353     int ret;
 354     ret = pthread_mutex_destroy(cs);
 355     assert(ret == 0);
 356 }
 357 void EnterCriticalSection(CRITICAL_SECTION *cs)
 358 {
 359     int ret;
 360     ret = pthread_mutex_lock(cs);
 361     assert(ret == 0);
 362 }
 363 void LeaveCriticalSection(CRITICAL_SECTION *cs)
 364 {
 365     int ret;
 366     ret = pthread_mutex_unlock(cs);
 367     assert(ret == 0);
 368 }
 369
 370 /* NOTE: This wrapper isn't quite accurate as it returns an ALuint, as opposed
 371  * to the expected DWORD. Both are defined as unsigned 32-bit types, however.
 372  * Additionally, Win32 is supposed to measure the time since Windows started,
 373  * as opposed to the actual time. */
 374 ALuint timeGetTime(void)
 375 {
 376 #if _POSIX_TIMERS > 0
 377     struct timespec ts;
 378     int ret = -1;
 379
 380 #if defined(_POSIX_MONOTONIC_CLOCK) && (_POSIX_MONOTONIC_CLOCK >= 0)
 381 #if _POSIX_MONOTONIC_CLOCK == 0
 382     static int hasmono = 0;
 383     if(hasmono > 0 || (hasmono == 0 &&
 384                        (hasmono=sysconf(_SC_MONOTONIC_CLOCK)) > 0))
 385 #endif
 386         ret = clock_gettime(CLOCK_MONOTONIC, &ts);
 387 #endif
 388     if(ret != 0)
 389         ret = clock_gettime(CLOCK_REALTIME, &ts);
 390     assert(ret == 0);
 391
 392     return ts.tv_nsec/1000000 + ts.tv_sec*1000;
 393 #else
 394     struct timeval tv;
 395     int ret;
 396
 397     ret = gettimeofday(&tv, NULL);
 398     assert(ret == 0);
 399
 400     return tv.tv_usec/1000 + tv.tv_sec*1000;
 401 #endif
 402 }
 403
 404 void Sleep(ALuint t)
 405 {
 406     struct timespec tv, rem;
 407     tv.tv_nsec = (t*1000000)%1000000000;
 408     tv.tv_sec = t/1000;
 409
 410     while(nanosleep(&tv, &rem) == -1 && errno == EINTR)
 411         tv = rem;
 412 }
 413
 414 #ifdef HAVE_DLFCN_H
 415
 416 void *LoadLib(const char *name)
 417 {
 418     const char *err;
 419     void *handle;
 420
 421     dlerror();
 422     handle = dlopen(name, RTLD_NOW);
 423     if((err=dlerror()) != NULL)
 424         handle = NULL;
 425     return handle;
 426 }
 427 void CloseLib(void *handle)
 428 { dlclose(handle); }
 429 void *GetSymbol(void *handle, const char *name)
 430 {
 431     const char *err;
 432     void *sym;
 433
 434     dlerror();
 435     sym = dlsym(handle, name);
 436     if((err=dlerror()) != NULL)
 437     {
 438         WARN("Failed to load %s: %s\n", name, err);
 439         sym = NULL;
 440     }
 441     return sym;
 442 }
 443
 444 #endif
 445 #endif
 446
 447
 448 void al_print(const char *type, const char *func, const char *fmt, ...)
 449 {
 450     char str[256];
 451     int i;
 452
 453     i = snprintf(str, sizeof(str), "AL lib: %s %s: ", type, func);
 454     if(i > 0 && (unsigned int)i < sizeof(str))
 455     {
 456         va_list ap;
 457         va_start(ap, fmt);
 458         vsnprintf(str+i, sizeof(str)-i, fmt, ap);
 459         va_end(ap);
 460     }
 461     str[sizeof(str)-1] = 0;
 462
 463     fprintf(LogFile, "%s", str);
 464     fflush(LogFile);
 465 }
 466
 467
 468 void SetRTPriority(void)
 469 {
 470     ALboolean failed = AL_FALSE;
 471
 472 #ifdef _WIN32
 473     if(RTPrioLevel > 0)
 474         failed = !SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
 475 #elif defined(HAVE_PTHREAD_SETSCHEDPARAM) && !defined(__OpenBSD__)
 476     if(RTPrioLevel > 0)
 477     {
 478         struct sched_param param;
 479         /* Use the minimum real-time priority possible for now (on Linux this
 480          * should be 1 for SCHED_RR) */
 481         param.sched_priority = sched_get_priority_min(SCHED_RR);
 482         failed = !!pthread_setschedparam(pthread_self(), SCHED_RR, &param);
 483     }
 484 #else
 485     /* Real-time priority not available */
 486     failed = (RTPrioLevel>0);
 487 #endif
 488     if(failed)
 489         ERR("Failed to set priority level for thread\n");
 490 }
 491
 492
 493 static void Lock(volatile ALenum *l)
 494 {
 495     while(ExchangeInt(l, AL_TRUE) == AL_TRUE)
 496         sched_yield();
 497 }
 498
 499 static void Unlock(volatile ALenum *l)
 500 {
 501     ExchangeInt(l, AL_FALSE);
 502 }
 503
 504 void RWLockInit(RWLock *lock)
 505 {
 506     lock->read_count = 0;
 507     lock->write_count = 0;
 508     lock->read_lock = AL_FALSE;
 509     lock->read_entry_lock = AL_FALSE;
 510     lock->write_lock = AL_FALSE;
 511 }
 512
 513 void ReadLock(RWLock *lock)
 514 {
 515     Lock(&lock->read_entry_lock);
 516     Lock(&lock->read_lock);
 517     if(IncrementRef(&lock->read_count) == 1)
 518         Lock(&lock->write_lock);
 519     Unlock(&lock->read_lock);
 520     Unlock(&lock->read_entry_lock);
 521 }
 522
 523 void ReadUnlock(RWLock *lock)
 524 {
 525     if(DecrementRef(&lock->read_count) == 0)
 526         Unlock(&lock->write_lock);
 527 }
 528
 529 void WriteLock(RWLock *lock)
 530 {
 531     if(IncrementRef(&lock->write_count) == 1)
 532         Lock(&lock->read_lock);
 533     Lock(&lock->write_lock);
 534 }
 535
 536 void WriteUnlock(RWLock *lock)
 537 {
 538     Unlock(&lock->write_lock);
 539     if(DecrementRef(&lock->write_count) == 0)
 540         Unlock(&lock->read_lock);
 541 }
 542
 543
 544 void InitUIntMap(UIntMap *map, ALsizei limit)
 545 {
 546     map->array = NULL;
 547     map->size = 0;
 548     map->maxsize = 0;
 549     map->limit = limit;
 550     RWLockInit(&map->lock);
 551 }
 552
 553 void ResetUIntMap(UIntMap *map)
 554 {
 555     WriteLock(&map->lock);
 556     free(map->array);
 557     map->array = NULL;
 558     map->size = 0;
 559     map->maxsize = 0;
 560     WriteUnlock(&map->lock);
 561 }
 562
 563 ALenum InsertUIntMapEntry(UIntMap *map, ALuint key, ALvoid *value)
 564 {
 565     ALsizei pos = 0;
 566
 567     WriteLock(&map->lock);
 568     if(map->size > 0)
 569     {
 570         ALsizei low = 0;
 571         ALsizei high = map->size - 1;
 572         while(low < high)
 573         {
 574             ALsizei mid = low + (high-low)/2;
 575             if(map->array[mid].key < key)
 576                 low = mid + 1;
 577             else
 578                 high = mid;
 579         }
 580         if(map->array[low].key < key)
 581             low++;
 582         pos = low;
 583     }
 584
 585     if(pos == map->size || map->array[pos].key != key)
 586     {
 587         if(map->size == map->limit)
 588         {
 589             WriteUnlock(&map->lock);
 590             return AL_OUT_OF_MEMORY;
 591         }
 592
 593         if(map->size == map->maxsize)
 594         {
 595             ALvoid *temp = NULL;
 596             ALsizei newsize;
 597
 598             newsize = (map->maxsize ? (map->maxsize<<1) : 4);
 599             if(newsize >= map->maxsize)
 600                 temp = realloc(map->array, newsize*sizeof(map->array[0]));
 601             if(!temp)
 602             {
 603                 WriteUnlock(&map->lock);
 604                 return AL_OUT_OF_MEMORY;
 605             }
 606             map->array = temp;
 607             map->maxsize = newsize;
 608         }
 609
 610         if(pos < map->size)
 611             memmove(&map->array[pos+1], &map->array[pos],
 612                     (map->size-pos)*sizeof(map->array[0]));
 613         map->size++;
 614     }
 615     map->array[pos].key = key;
 616     map->array[pos].value = value;
 617     WriteUnlock(&map->lock);
 618
 619     return AL_NO_ERROR;
 620 }
 621
 622 ALvoid *RemoveUIntMapKey(UIntMap *map, ALuint key)
 623 {
 624     ALvoid *ptr = NULL;
 625     WriteLock(&map->lock);
 626     if(map->size > 0)
 627     {
 628         ALsizei low = 0;
 629         ALsizei high = map->size - 1;
 630         while(low < high)
 631         {
 632             ALsizei mid = low + (high-low)/2;
 633             if(map->array[mid].key < key)
 634                 low = mid + 1;
 635             else
 636                 high = mid;
 637         }
 638         if(map->array[low].key == key)
 639         {
 640             ptr = map->array[low].value;
 641             if(low < map->size-1)
 642                 memmove(&map->array[low], &map->array[low+1],
 643                         (map->size-1-low)*sizeof(map->array[0]));
 644             map->size--;
 645         }
 646     }
 647     WriteUnlock(&map->lock);
 648     return ptr;
 649 }
 650
 651 ALvoid *LookupUIntMapKey(UIntMap *map, ALuint key)
 652 {
 653     ALvoid *ptr = NULL;
 654     ReadLock(&map->lock);
 655     if(map->size > 0)
 656     {
 657         ALsizei low = 0;
 658         ALsizei high = map->size - 1;
 659         while(low < high)
 660         {
 661             ALsizei mid = low + (high-low)/2;
 662             if(map->array[mid].key < key)
 663                 low = mid + 1;
 664             else
 665                 high = mid;
 666         }
 667         if(map->array[low].key == key)
 668             ptr = map->array[low].value;
 669     }
 670     ReadUnlock(&map->lock);
 671     return ptr;
 672 }