al/filter.cpp

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2007 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.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include "filter.h"
  24
  25 #include <algorithm>
  26 #include <cstdarg>
  27 #include <cstdint>
  28 #include <cstdio>
  29 #include <iterator>
  30 #include <memory>
  31 #include <mutex>
  32 #include <new>
  33 #include <numeric>
  34
  35 #include "AL/al.h"
  36 #include "AL/alc.h"
  37 #include "AL/efx.h"
  38
  39 #include "alcmain.h"
  40 #include "alcontext.h"
  41 #include "alexcpt.h"
  42 #include "almalloc.h"
  43 #include "alnumeric.h"
  44 #include "opthelpers.h"
  45 #include "vector.h"
  46
  47
  48 namespace {
  49
  50 class filter_exception final : public al::base_exception {
  51 public:
  52     [[gnu::format(printf, 3, 4)]]
  53     filter_exception(ALenum code, const char *msg, ...) : base_exception{code}
  54     {
  55         std::va_list args;
  56         va_start(args, msg);
  57         setMessage(msg, args);
  58         va_end(args);
  59     }
  60 };
  61
  62 #define FILTER_MIN_GAIN 0.0f
  63 #define FILTER_MAX_GAIN 4.0f /* +12dB */
  64
  65 #define DEFINE_ALFILTER_VTABLE(T)                                  \
  66 const ALfilter::Vtable T##_vtable = {                              \
  67     T##_setParami, T##_setParamiv, T##_setParamf, T##_setParamfv,  \
  68     T##_getParami, T##_getParamiv, T##_getParamf, T##_getParamfv,  \
  69 }
  70
  71 void ALlowpass_setParami(ALfilter*, ALenum param, int)
  72 { throw filter_exception{AL_INVALID_ENUM, "Invalid low-pass integer property 0x%04x", param}; }
  73 void ALlowpass_setParamiv(ALfilter*, ALenum param, const int*)
  74 {
  75     throw filter_exception{AL_INVALID_ENUM, "Invalid low-pass integer-vector property 0x%04x",
  76         param};
  77 }
  78 void ALlowpass_setParamf(ALfilter *filter, ALenum param, float val)
  79 {
  80     switch(param)
  81     {
  82     case AL_LOWPASS_GAIN:
  83         if(!(val >= FILTER_MIN_GAIN && val <= FILTER_MAX_GAIN))
  84             throw filter_exception{AL_INVALID_VALUE, "Low-pass gain %f out of range", val};
  85         filter->Gain = val;
  86         break;
  87
  88     case AL_LOWPASS_GAINHF:
  89         if(!(val >= AL_LOWPASS_MIN_GAINHF && val <= AL_LOWPASS_MAX_GAINHF))
  90             throw filter_exception{AL_INVALID_VALUE, "Low-pass gainhf %f out of range", val};
  91         filter->GainHF = val;
  92         break;
  93
  94     default:
  95         throw filter_exception{AL_INVALID_ENUM, "Invalid low-pass float property 0x%04x", param};
  96     }
  97 }
  98 void ALlowpass_setParamfv(ALfilter *filter, ALenum param, const float *vals)
  99 { ALlowpass_setParamf(filter, param, vals[0]); }
 100
 101 void ALlowpass_getParami(const ALfilter*, ALenum param, int*)
 102 { throw filter_exception{AL_INVALID_ENUM, "Invalid low-pass integer property 0x%04x", param}; }
 103 void ALlowpass_getParamiv(const ALfilter*, ALenum param, int*)
 104 {
 105     throw filter_exception{AL_INVALID_ENUM, "Invalid low-pass integer-vector property 0x%04x",
 106         param};
 107 }
 108 void ALlowpass_getParamf(const ALfilter *filter, ALenum param, float *val)
 109 {
 110     switch(param)
 111     {
 112     case AL_LOWPASS_GAIN:
 113         *val = filter->Gain;
 114         break;
 115
 116     case AL_LOWPASS_GAINHF:
 117         *val = filter->GainHF;
 118         break;
 119
 120     default:
 121         throw filter_exception{AL_INVALID_ENUM, "Invalid low-pass float property 0x%04x", param};
 122     }
 123 }
 124 void ALlowpass_getParamfv(const ALfilter *filter, ALenum param, float *vals)
 125 { ALlowpass_getParamf(filter, param, vals); }
 126
 127 DEFINE_ALFILTER_VTABLE(ALlowpass);
 128
 129
 130 void ALhighpass_setParami(ALfilter*, ALenum param, int)
 131 { throw filter_exception{AL_INVALID_ENUM, "Invalid high-pass integer property 0x%04x", param}; }
 132 void ALhighpass_setParamiv(ALfilter*, ALenum param, const int*)
 133 {
 134     throw filter_exception{AL_INVALID_ENUM, "Invalid high-pass integer-vector property 0x%04x",
 135         param};
 136 }
 137 void ALhighpass_setParamf(ALfilter *filter, ALenum param, float val)
 138 {
 139     switch(param)
 140     {
 141     case AL_HIGHPASS_GAIN:
 142         if(!(val >= FILTER_MIN_GAIN && val <= FILTER_MAX_GAIN))
 143             throw filter_exception{AL_INVALID_VALUE, "High-pass gain %f out of range", val};
 144         filter->Gain = val;
 145         break;
 146
 147     case AL_HIGHPASS_GAINLF:
 148         if(!(val >= AL_HIGHPASS_MIN_GAINLF && val <= AL_HIGHPASS_MAX_GAINLF))
 149             throw filter_exception{AL_INVALID_VALUE, "High-pass gainlf %f out of range", val};
 150         filter->GainLF = val;
 151         break;
 152
 153     default:
 154         throw filter_exception{AL_INVALID_ENUM, "Invalid high-pass float property 0x%04x", param};
 155     }
 156 }
 157 void ALhighpass_setParamfv(ALfilter *filter, ALenum param, const float *vals)
 158 { ALhighpass_setParamf(filter, param, vals[0]); }
 159
 160 void ALhighpass_getParami(const ALfilter*, ALenum param, int*)
 161 { throw filter_exception{AL_INVALID_ENUM, "Invalid high-pass integer property 0x%04x", param}; }
 162 void ALhighpass_getParamiv(const ALfilter*, ALenum param, int*)
 163 {
 164     throw filter_exception{AL_INVALID_ENUM, "Invalid high-pass integer-vector property 0x%04x",
 165         param};
 166 }
 167 void ALhighpass_getParamf(const ALfilter *filter, ALenum param, float *val)
 168 {
 169     switch(param)
 170     {
 171     case AL_HIGHPASS_GAIN:
 172         *val = filter->Gain;
 173         break;
 174
 175     case AL_HIGHPASS_GAINLF:
 176         *val = filter->GainLF;
 177         break;
 178
 179     default:
 180         throw filter_exception{AL_INVALID_ENUM, "Invalid high-pass float property 0x%04x", param};
 181     }
 182 }
 183 void ALhighpass_getParamfv(const ALfilter *filter, ALenum param, float *vals)
 184 { ALhighpass_getParamf(filter, param, vals); }
 185
 186 DEFINE_ALFILTER_VTABLE(ALhighpass);
 187
 188
 189 void ALbandpass_setParami(ALfilter*, ALenum param, int)
 190 { throw filter_exception{AL_INVALID_ENUM, "Invalid band-pass integer property 0x%04x", param}; }
 191 void ALbandpass_setParamiv(ALfilter*, ALenum param, const int*)
 192 {
 193     throw filter_exception{AL_INVALID_ENUM, "Invalid band-pass integer-vector property 0x%04x",
 194         param};
 195 }
 196 void ALbandpass_setParamf(ALfilter *filter, ALenum param, float val)
 197 {
 198     switch(param)
 199     {
 200     case AL_BANDPASS_GAIN:
 201         if(!(val >= FILTER_MIN_GAIN && val <= FILTER_MAX_GAIN))
 202             throw filter_exception{AL_INVALID_VALUE, "Band-pass gain %f out of range", val};
 203         filter->Gain = val;
 204         break;
 205
 206     case AL_BANDPASS_GAINHF:
 207         if(!(val >= AL_BANDPASS_MIN_GAINHF && val <= AL_BANDPASS_MAX_GAINHF))
 208             throw filter_exception{AL_INVALID_VALUE, "Band-pass gainhf %f out of range", val};
 209         filter->GainHF = val;
 210         break;
 211
 212     case AL_BANDPASS_GAINLF:
 213         if(!(val >= AL_BANDPASS_MIN_GAINLF && val <= AL_BANDPASS_MAX_GAINLF))
 214             throw filter_exception{AL_INVALID_VALUE, "Band-pass gainlf %f out of range", val};
 215         filter->GainLF = val;
 216         break;
 217
 218     default:
 219         throw filter_exception{AL_INVALID_ENUM, "Invalid band-pass float property 0x%04x", param};
 220     }
 221 }
 222 void ALbandpass_setParamfv(ALfilter *filter, ALenum param, const float *vals)
 223 { ALbandpass_setParamf(filter, param, vals[0]); }
 224
 225 void ALbandpass_getParami(const ALfilter*, ALenum param, int*)
 226 { throw filter_exception{AL_INVALID_ENUM, "Invalid band-pass integer property 0x%04x", param}; }
 227 void ALbandpass_getParamiv(const ALfilter*, ALenum param, int*)
 228 {
 229     throw filter_exception{AL_INVALID_ENUM, "Invalid band-pass integer-vector property 0x%04x",
 230         param};
 231 }
 232 void ALbandpass_getParamf(const ALfilter *filter, ALenum param, float *val)
 233 {
 234     switch(param)
 235     {
 236     case AL_BANDPASS_GAIN:
 237         *val = filter->Gain;
 238         break;
 239
 240     case AL_BANDPASS_GAINHF:
 241         *val = filter->GainHF;
 242         break;
 243
 244     case AL_BANDPASS_GAINLF:
 245         *val = filter->GainLF;
 246         break;
 247
 248     default:
 249         throw filter_exception{AL_INVALID_ENUM, "Invalid band-pass float property 0x%04x", param};
 250     }
 251 }
 252 void ALbandpass_getParamfv(const ALfilter *filter, ALenum param, float *vals)
 253 { ALbandpass_getParamf(filter, param, vals); }
 254
 255 DEFINE_ALFILTER_VTABLE(ALbandpass);
 256
 257
 258 void ALnullfilter_setParami(ALfilter*, ALenum param, int)
 259 { throw filter_exception{AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param}; }
 260 void ALnullfilter_setParamiv(ALfilter*, ALenum param, const int*)
 261 { throw filter_exception{AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param}; }
 262 void ALnullfilter_setParamf(ALfilter*, ALenum param, float)
 263 { throw filter_exception{AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param}; }
 264 void ALnullfilter_setParamfv(ALfilter*, ALenum param, const float*)
 265 { throw filter_exception{AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param}; }
 266
 267 void ALnullfilter_getParami(const ALfilter*, ALenum param, int*)
 268 { throw filter_exception{AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param}; }
 269 void ALnullfilter_getParamiv(const ALfilter*, ALenum param, int*)
 270 { throw filter_exception{AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param}; }
 271 void ALnullfilter_getParamf(const ALfilter*, ALenum param, float*)
 272 { throw filter_exception{AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param}; }
 273 void ALnullfilter_getParamfv(const ALfilter*, ALenum param, float*)
 274 { throw filter_exception{AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param}; }
 275
 276 DEFINE_ALFILTER_VTABLE(ALnullfilter);
 277
 278
 279 void InitFilterParams(ALfilter *filter, ALenum type)
 280 {
 281     if(type == AL_FILTER_LOWPASS)
 282     {
 283         filter->Gain = AL_LOWPASS_DEFAULT_GAIN;
 284         filter->GainHF = AL_LOWPASS_DEFAULT_GAINHF;
 285         filter->HFReference = LOWPASSFREQREF;
 286         filter->GainLF = 1.0f;
 287         filter->LFReference = HIGHPASSFREQREF;
 288         filter->vtab = &ALlowpass_vtable;
 289     }
 290     else if(type == AL_FILTER_HIGHPASS)
 291     {
 292         filter->Gain = AL_HIGHPASS_DEFAULT_GAIN;
 293         filter->GainHF = 1.0f;
 294         filter->HFReference = LOWPASSFREQREF;
 295         filter->GainLF = AL_HIGHPASS_DEFAULT_GAINLF;
 296         filter->LFReference = HIGHPASSFREQREF;
 297         filter->vtab = &ALhighpass_vtable;
 298     }
 299     else if(type == AL_FILTER_BANDPASS)
 300     {
 301         filter->Gain = AL_BANDPASS_DEFAULT_GAIN;
 302         filter->GainHF = AL_BANDPASS_DEFAULT_GAINHF;
 303         filter->HFReference = LOWPASSFREQREF;
 304         filter->GainLF = AL_BANDPASS_DEFAULT_GAINLF;
 305         filter->LFReference = HIGHPASSFREQREF;
 306         filter->vtab = &ALbandpass_vtable;
 307     }
 308     else
 309     {
 310         filter->Gain = 1.0f;
 311         filter->GainHF = 1.0f;
 312         filter->HFReference = LOWPASSFREQREF;
 313         filter->GainLF = 1.0f;
 314         filter->LFReference = HIGHPASSFREQREF;
 315         filter->vtab = &ALnullfilter_vtable;
 316     }
 317     filter->type = type;
 318 }
 319
 320 bool EnsureFilters(ALCdevice *device, size_t needed)
 321 {
 322     size_t count{std::accumulate(device->FilterList.cbegin(), device->FilterList.cend(), size_t{0},
 323         [](size_t cur, const FilterSubList &sublist) noexcept -> size_t
 324         { return cur + static_cast<ALuint>(PopCount(sublist.FreeMask)); })};
 325
 326     while(needed > count)
 327     {
 328         if UNLIKELY(device->FilterList.size() >= 1<<25)
 329             return false;
 330
 331         device->FilterList.emplace_back();
 332         auto sublist = device->FilterList.end() - 1;
 333         sublist->FreeMask = ~0_u64;
 334         sublist->Filters = static_cast<ALfilter*>(al_calloc(alignof(ALfilter), sizeof(ALfilter)*64));
 335         if UNLIKELY(!sublist->Filters)
 336         {
 337             device->FilterList.pop_back();
 338             return false;
 339         }
 340         count += 64;
 341     }
 342     return true;
 343 }
 344
 345
 346 ALfilter *AllocFilter(ALCdevice *device)
 347 {
 348     auto sublist = std::find_if(device->FilterList.begin(), device->FilterList.end(),
 349         [](const FilterSubList &entry) noexcept -> bool
 350         { return entry.FreeMask != 0; }
 351     );
 352     auto lidx = static_cast<ALuint>(std::distance(device->FilterList.begin(), sublist));
 353     auto slidx = static_cast<ALuint>(CountTrailingZeros(sublist->FreeMask));
 354
 355     ALfilter *filter{::new(sublist->Filters + slidx) ALfilter{}};
 356     InitFilterParams(filter, AL_FILTER_NULL);
 357
 358     /* Add 1 to avoid filter ID 0. */
 359     filter->id = ((lidx<<6) | slidx) + 1;
 360
 361     sublist->FreeMask &= ~(1_u64 << slidx);
 362
 363     return filter;
 364 }
 365
 366 void FreeFilter(ALCdevice *device, ALfilter *filter)
 367 {
 368     const ALuint id{filter->id - 1};
 369     const size_t lidx{id >> 6};
 370     const ALuint slidx{id & 0x3f};
 371
 372     al::destroy_at(filter);
 373
 374     device->FilterList[lidx].FreeMask |= 1_u64 << slidx;
 375 }
 376
 377
 378 inline ALfilter *LookupFilter(ALCdevice *device, ALuint id)
 379 {
 380     const size_t lidx{(id-1) >> 6};
 381     const ALuint slidx{(id-1) & 0x3f};
 382
 383     if UNLIKELY(lidx >= device->FilterList.size())
 384         return nullptr;
 385     FilterSubList &sublist = device->FilterList[lidx];
 386     if UNLIKELY(sublist.FreeMask & (1_u64 << slidx))
 387         return nullptr;
 388     return sublist.Filters + slidx;
 389 }
 390
 391 } // namespace
 392
 393 AL_API void AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters)
 394 START_API_FUNC
 395 {
 396     ContextRef context{GetContextRef()};
 397     if UNLIKELY(!context) return;
 398
 399     if UNLIKELY(n < 0)
 400         context->setError(AL_INVALID_VALUE, "Generating %d filters", n);
 401     if UNLIKELY(n <= 0) return;
 402
 403     ALCdevice *device{context->mDevice.get()};
 404     std::lock_guard<std::mutex> _{device->EffectLock};
 405     if(!EnsureFilters(device, static_cast<ALuint>(n)))
 406     {
 407         context->setError(AL_OUT_OF_MEMORY, "Failed to allocate %d filter%s", n, (n==1)?"":"s");
 408         return;
 409     }
 410
 411     if LIKELY(n == 1)
 412     {
 413         /* Special handling for the easy and normal case. */
 414         ALfilter *filter{AllocFilter(device)};
 415         if(filter) filters[0] = filter->id;
 416     }
 417     else
 418     {
 419         /* Store the allocated buffer IDs in a separate local list, to avoid
 420          * modifying the user storage in case of failure.
 421          */
 422         al::vector<ALuint> ids;
 423         ids.reserve(static_cast<ALuint>(n));
 424         do {
 425             ALfilter *filter{AllocFilter(device)};
 426             ids.emplace_back(filter->id);
 427         } while(--n);
 428         std::copy(ids.begin(), ids.end(), filters);
 429     }
 430 }
 431 END_API_FUNC
 432
 433 AL_API void AL_APIENTRY alDeleteFilters(ALsizei n, const ALuint *filters)
 434 START_API_FUNC
 435 {
 436     ContextRef context{GetContextRef()};
 437     if UNLIKELY(!context) return;
 438
 439     if UNLIKELY(n < 0)
 440         context->setError(AL_INVALID_VALUE, "Deleting %d filters", n);
 441     if UNLIKELY(n <= 0) return;
 442
 443     ALCdevice *device{context->mDevice.get()};
 444     std::lock_guard<std::mutex> _{device->FilterLock};
 445
 446     /* First try to find any filters that are invalid. */
 447     auto validate_filter = [device](const ALuint fid) -> bool
 448     { return !fid || LookupFilter(device, fid) != nullptr; };
 449
 450     const ALuint *filters_end = filters + n;
 451     auto invflt = std::find_if_not(filters, filters_end, validate_filter);
 452     if UNLIKELY(invflt != filters_end)
 453     {
 454         context->setError(AL_INVALID_NAME, "Invalid filter ID %u", *invflt);
 455         return;
 456     }
 457
 458     /* All good. Delete non-0 filter IDs. */
 459     auto delete_filter = [device](const ALuint fid) -> void
 460     {
 461         ALfilter *filter{fid ? LookupFilter(device, fid) : nullptr};
 462         if(filter) FreeFilter(device, filter);
 463     };
 464     std::for_each(filters, filters_end, delete_filter);
 465 }
 466 END_API_FUNC
 467
 468 AL_API ALboolean AL_APIENTRY alIsFilter(ALuint filter)
 469 START_API_FUNC
 470 {
 471     ContextRef context{GetContextRef()};
 472     if LIKELY(context)
 473     {
 474         ALCdevice *device{context->mDevice.get()};
 475         std::lock_guard<std::mutex> _{device->FilterLock};
 476         if(!filter || LookupFilter(device, filter))
 477             return AL_TRUE;
 478     }
 479     return AL_FALSE;
 480 }
 481 END_API_FUNC
 482
 483
 484 AL_API void AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint value)
 485 START_API_FUNC
 486 {
 487     ContextRef context{GetContextRef()};
 488     if UNLIKELY(!context) return;
 489
 490     ALCdevice *device{context->mDevice.get()};
 491     std::lock_guard<std::mutex> _{device->FilterLock};
 492
 493     ALfilter *alfilt{LookupFilter(device, filter)};
 494     if UNLIKELY(!alfilt)
 495         context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
 496     else
 497     {
 498         if(param == AL_FILTER_TYPE)
 499         {
 500             if(value == AL_FILTER_NULL || value == AL_FILTER_LOWPASS
 501                 || value == AL_FILTER_HIGHPASS || value == AL_FILTER_BANDPASS)
 502                 InitFilterParams(alfilt, value);
 503             else
 504                 context->setError(AL_INVALID_VALUE, "Invalid filter type 0x%04x", value);
 505         }
 506         else try
 507         {
 508             /* Call the appropriate handler */
 509             alfilt->setParami(param, value);
 510         }
 511         catch(filter_exception &e) {
 512             context->setError(e.errorCode(), "%s", e.what());
 513         }
 514     }
 515 }
 516 END_API_FUNC
 517
 518 AL_API void AL_APIENTRY alFilteriv(ALuint filter, ALenum param, const ALint *values)
 519 START_API_FUNC
 520 {
 521     switch(param)
 522     {
 523     case AL_FILTER_TYPE:
 524         alFilteri(filter, param, values[0]);
 525         return;
 526     }
 527
 528     ContextRef context{GetContextRef()};
 529     if UNLIKELY(!context) return;
 530
 531     ALCdevice *device{context->mDevice.get()};
 532     std::lock_guard<std::mutex> _{device->FilterLock};
 533
 534     ALfilter *alfilt{LookupFilter(device, filter)};
 535     if UNLIKELY(!alfilt)
 536         context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
 537     else try
 538     {
 539         /* Call the appropriate handler */
 540         alfilt->setParamiv(param, values);
 541     }
 542     catch(filter_exception &e) {
 543         context->setError(e.errorCode(), "%s", e.what());
 544     }
 545 }
 546 END_API_FUNC
 547
 548 AL_API void AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat value)
 549 START_API_FUNC
 550 {
 551     ContextRef context{GetContextRef()};
 552     if UNLIKELY(!context) return;
 553
 554     ALCdevice *device{context->mDevice.get()};
 555     std::lock_guard<std::mutex> _{device->FilterLock};
 556
 557     ALfilter *alfilt{LookupFilter(device, filter)};
 558     if UNLIKELY(!alfilt)
 559         context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
 560     else try
 561     {
 562         /* Call the appropriate handler */
 563         alfilt->setParamf(param, value);
 564     }
 565     catch(filter_exception &e) {
 566         context->setError(e.errorCode(), "%s", e.what());
 567     }
 568 }
 569 END_API_FUNC
 570
 571 AL_API void AL_APIENTRY alFilterfv(ALuint filter, ALenum param, const ALfloat *values)
 572 START_API_FUNC
 573 {
 574     ContextRef context{GetContextRef()};
 575     if UNLIKELY(!context) return;
 576
 577     ALCdevice *device{context->mDevice.get()};
 578     std::lock_guard<std::mutex> _{device->FilterLock};
 579
 580     ALfilter *alfilt{LookupFilter(device, filter)};
 581     if UNLIKELY(!alfilt)
 582         context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
 583     else try
 584     {
 585         /* Call the appropriate handler */
 586         alfilt->setParamfv(param, values);
 587     }
 588     catch(filter_exception &e) {
 589         context->setError(e.errorCode(), "%s", e.what());
 590     }
 591 }
 592 END_API_FUNC
 593
 594 AL_API void AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *value)
 595 START_API_FUNC
 596 {
 597     ContextRef context{GetContextRef()};
 598     if UNLIKELY(!context) return;
 599
 600     ALCdevice *device{context->mDevice.get()};
 601     std::lock_guard<std::mutex> _{device->FilterLock};
 602
 603     const ALfilter *alfilt{LookupFilter(device, filter)};
 604     if UNLIKELY(!alfilt)
 605         context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
 606     else
 607     {
 608         if(param == AL_FILTER_TYPE)
 609             *value = alfilt->type;
 610         else try
 611         {
 612             /* Call the appropriate handler */
 613             alfilt->getParami(param, value);
 614         }
 615         catch(filter_exception &e) {
 616             context->setError(e.errorCode(), "%s", e.what());
 617         }
 618     }
 619 }
 620 END_API_FUNC
 621
 622 AL_API void AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *values)
 623 START_API_FUNC
 624 {
 625     switch(param)
 626     {
 627     case AL_FILTER_TYPE:
 628         alGetFilteri(filter, param, values);
 629         return;
 630     }
 631
 632     ContextRef context{GetContextRef()};
 633     if UNLIKELY(!context) return;
 634
 635     ALCdevice *device{context->mDevice.get()};
 636     std::lock_guard<std::mutex> _{device->FilterLock};
 637
 638     const ALfilter *alfilt{LookupFilter(device, filter)};
 639     if UNLIKELY(!alfilt)
 640         context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
 641     else try
 642     {
 643         /* Call the appropriate handler */
 644         alfilt->getParamiv(param, values);
 645     }
 646     catch(filter_exception &e) {
 647         context->setError(e.errorCode(), "%s", e.what());
 648     }
 649 }
 650 END_API_FUNC
 651
 652 AL_API void AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *value)
 653 START_API_FUNC
 654 {
 655     ContextRef context{GetContextRef()};
 656     if UNLIKELY(!context) return;
 657
 658     ALCdevice *device{context->mDevice.get()};
 659     std::lock_guard<std::mutex> _{device->FilterLock};
 660
 661     const ALfilter *alfilt{LookupFilter(device, filter)};
 662     if UNLIKELY(!alfilt)
 663         context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
 664     else try
 665     {
 666         /* Call the appropriate handler */
 667         alfilt->getParamf(param, value);
 668     }
 669     catch(filter_exception &e) {
 670         context->setError(e.errorCode(), "%s", e.what());
 671     }
 672 }
 673 END_API_FUNC
 674
 675 AL_API void AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *values)
 676 START_API_FUNC
 677 {
 678     ContextRef context{GetContextRef()};
 679     if UNLIKELY(!context) return;
 680
 681     ALCdevice *device{context->mDevice.get()};
 682     std::lock_guard<std::mutex> _{device->FilterLock};
 683
 684     const ALfilter *alfilt{LookupFilter(device, filter)};
 685     if UNLIKELY(!alfilt)
 686         context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
 687     else try
 688     {
 689         /* Call the appropriate handler */
 690         alfilt->getParamfv(param, values);
 691     }
 692     catch(filter_exception &e) {
 693         context->setError(e.errorCode(), "%s", e.what());
 694     }
 695 }
 696 END_API_FUNC
 697
 698
 699 FilterSubList::~FilterSubList()
 700 {
 701     uint64_t usemask{~FreeMask};
 702     while(usemask)
 703     {
 704         const ALsizei idx{CountTrailingZeros(usemask)};
 705         al::destroy_at(Filters+idx);
 706         usemask &= ~(1_u64 << idx);
 707     }
 708     FreeMask = ~usemask;
 709     al_free(Filters);
 710     Filters = nullptr;
 711 }