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