OpenAL32/Include/alMain.h

   1 #ifndef AL_MAIN_H
   2 #define AL_MAIN_H
   3
   4 #include <string.h>
   5 #include <stdio.h>
   6 #include <stdarg.h>
   7 #include <assert.h>
   8 #include <math.h>
   9 #include <limits.h>
  10
  11 #ifdef HAVE_STRINGS_H
  12 #include <strings.h>
  13 #endif
  14
  15 #ifdef HAVE_FENV_H
  16 #include <fenv.h>
  17 #endif
  18
  19 #include "AL/al.h"
  20 #include "AL/alc.h"
  21 #include "AL/alext.h"
  22
  23
  24 #if defined(_WIN64)
  25 #define SZFMT "%I64u"
  26 #elif defined(_WIN32)
  27 #define SZFMT "%u"
  28 #else
  29 #define SZFMT "%zu"
  30 #endif
  31
  32
  33 #include "static_assert.h"
  34 #include "align.h"
  35 #include "atomic.h"
  36 #include "uintmap.h"
  37 #include "vector.h"
  38 #include "alstring.h"
  39
  40 #include "hrtf.h"
  41
  42 #ifndef ALC_SOFT_device_clock
  43 #define ALC_SOFT_device_clock 1
  44 typedef int64_t ALCint64SOFT;
  45 typedef uint64_t ALCuint64SOFT;
  46 #define ALC_DEVICE_CLOCK_SOFT                    0x1600
  47 typedef void (ALC_APIENTRY*LPALCGETINTEGER64VSOFT)(ALCdevice *device, ALCenum pname, ALsizei size, ALCint64SOFT *values);
  48 #ifdef AL_ALEXT_PROTOTYPES
  49 ALC_API void ALC_APIENTRY alcGetInteger64vSOFT(ALCdevice *device, ALCenum pname, ALsizei size, ALCint64SOFT *values);
  50 #endif
  51 #endif
  52
  53
  54 typedef ALint64SOFT ALint64;
  55 typedef ALuint64SOFT ALuint64;
  56
  57 #ifndef U64
  58 #if defined(_MSC_VER)
  59 #define U64(x) ((ALuint64)(x##ui64))
  60 #elif SIZEOF_LONG == 8
  61 #define U64(x) ((ALuint64)(x##ul))
  62 #elif SIZEOF_LONG_LONG == 8
  63 #define U64(x) ((ALuint64)(x##ull))
  64 #endif
  65 #endif
  66
  67 #ifndef UINT64_MAX
  68 #define UINT64_MAX U64(18446744073709551615)
  69 #endif
  70
  71 #ifndef UNUSED
  72 #if defined(__cplusplus)
  73 #define UNUSED(x)
  74 #elif defined(__GNUC__)
  75 #define UNUSED(x) UNUSED_##x __attribute__((unused))
  76 #elif defined(__LCLINT__)
  77 #define UNUSED(x) /*@unused@*/ x
  78 #else
  79 #define UNUSED(x) x
  80 #endif
  81 #endif
  82
  83 #ifdef __GNUC__
  84 #define DECL_CONST __attribute__((const))
  85 #define DECL_FORMAT(x, y, z) __attribute__((format(x, (y), (z))))
  86 #else
  87 #define DECL_CONST
  88 #define DECL_FORMAT(x, y, z)
  89 #endif
  90
  91 #if defined(__GNUC__) && defined(__i386__)
  92 /* force_align_arg_pointer is required for proper function arguments aligning
  93  * when SSE code is used. Some systems (Windows, QNX) do not guarantee our
  94  * thread functions will be properly aligned on the stack, even though GCC may
  95  * generate code with the assumption that it is. */
  96 #define FORCE_ALIGN __attribute__((force_align_arg_pointer))
  97 #else
  98 #define FORCE_ALIGN
  99 #endif
 100
 101 #ifdef HAVE_C99_VLA
 102 #define DECL_VLA(T, _name, _size)  T _name[(_size)]
 103 #else
 104 #define DECL_VLA(T, _name, _size)  T *_name = alloca((_size) * sizeof(T))
 105 #endif
 106
 107 #ifndef PATH_MAX
 108 #ifdef MAX_PATH
 109 #define PATH_MAX MAX_PATH
 110 #else
 111 #define PATH_MAX 4096
 112 #endif
 113 #endif
 114
 115
 116 static const union {
 117     ALuint u;
 118     ALubyte b[sizeof(ALuint)];
 119 } EndianTest = { 1 };
 120 #define IS_LITTLE_ENDIAN (EndianTest.b[0] == 1)
 121
 122 #define COUNTOF(x) (sizeof((x))/sizeof((x)[0]))
 123
 124
 125 #define DERIVE_FROM_TYPE(t)          t t##_parent
 126 #define STATIC_CAST(to, obj)         (&(obj)->to##_parent)
 127 #ifdef __GNUC__
 128 #define STATIC_UPCAST(to, from, obj) __extension__({                          \
 129     static_assert(__builtin_types_compatible_p(from, __typeof(*(obj))),       \
 130                   "Invalid upcast object from type");                         \
 131     (to*)((char*)(obj) - offsetof(to, from##_parent));                        \
 132 })
 133 #else
 134 #define STATIC_UPCAST(to, from, obj) ((to*)((char*)(obj) - offsetof(to, from##_parent)))
 135 #endif
 136
 137 #define DECLARE_FORWARD(T1, T2, rettype, func)                                \
 138 rettype T1##_##func(T1 *obj)                                                  \
 139 { return T2##_##func(STATIC_CAST(T2, obj)); }
 140
 141 #define DECLARE_FORWARD1(T1, T2, rettype, func, argtype1)                     \
 142 rettype T1##_##func(T1 *obj, argtype1 a)                                      \
 143 { return T2##_##func(STATIC_CAST(T2, obj), a); }
 144
 145 #define DECLARE_FORWARD2(T1, T2, rettype, func, argtype1, argtype2)           \
 146 rettype T1##_##func(T1 *obj, argtype1 a, argtype2 b)                          \
 147 { return T2##_##func(STATIC_CAST(T2, obj), a, b); }
 148
 149 #define DECLARE_FORWARD3(T1, T2, rettype, func, argtype1, argtype2, argtype3) \
 150 rettype T1##_##func(T1 *obj, argtype1 a, argtype2 b, argtype3 c)              \
 151 { return T2##_##func(STATIC_CAST(T2, obj), a, b, c); }
 152
 153
 154 #define GET_VTABLE1(T1)     (&(T1##_vtable))
 155 #define GET_VTABLE2(T1, T2) (&(T1##_##T2##_vtable))
 156
 157 #define SET_VTABLE1(T1, obj)     ((obj)->vtbl = GET_VTABLE1(T1))
 158 #define SET_VTABLE2(T1, T2, obj) (STATIC_CAST(T2, obj)->vtbl = GET_VTABLE2(T1, T2))
 159
 160 #define DECLARE_THUNK(T1, T2, rettype, func)                                  \
 161 static rettype T1##_##T2##_##func(T2 *obj)                                    \
 162 { return T1##_##func(STATIC_UPCAST(T1, T2, obj)); }
 163
 164 #define DECLARE_THUNK1(T1, T2, rettype, func, argtype1)                       \
 165 static rettype T1##_##T2##_##func(T2 *obj, argtype1 a)                        \
 166 { return T1##_##func(STATIC_UPCAST(T1, T2, obj), a); }
 167
 168 #define DECLARE_THUNK2(T1, T2, rettype, func, argtype1, argtype2)             \
 169 static rettype T1##_##T2##_##func(T2 *obj, argtype1 a, argtype2 b)            \
 170 { return T1##_##func(STATIC_UPCAST(T1, T2, obj), a, b); }
 171
 172 #define DECLARE_THUNK3(T1, T2, rettype, func, argtype1, argtype2, argtype3)   \
 173 static rettype T1##_##T2##_##func(T2 *obj, argtype1 a, argtype2 b, argtype3 c) \
 174 { return T1##_##func(STATIC_UPCAST(T1, T2, obj), a, b, c); }
 175
 176 #define DECLARE_THUNK4(T1, T2, rettype, func, argtype1, argtype2, argtype3, argtype4) \
 177 static rettype T1##_##T2##_##func(T2 *obj, argtype1 a, argtype2 b, argtype3 c, argtype4 d) \
 178 { return T1##_##func(STATIC_UPCAST(T1, T2, obj), a, b, c, d); }
 179
 180 #define DECLARE_DEFAULT_ALLOCATORS(T)                                         \
 181 static void* T##_New(size_t size) { return al_malloc(16, size); }             \
 182 static void T##_Delete(void *ptr) { al_free(ptr); }
 183
 184 /* Helper to extract an argument list for VCALL. Not used directly. */
 185 #define EXTRACT_VCALL_ARGS(...)  __VA_ARGS__))
 186
 187 /* Call a "virtual" method on an object, with arguments. */
 188 #define V(obj, func)  ((obj)->vtbl->func((obj), EXTRACT_VCALL_ARGS
 189 /* Call a "virtual" method on an object, with no arguments. */
 190 #define V0(obj, func) ((obj)->vtbl->func((obj) EXTRACT_VCALL_ARGS
 191
 192 #define DELETE_OBJ(obj) do {                                                  \
 193     if((obj) != NULL)                                                         \
 194     {                                                                         \
 195         V0((obj),Destruct)();                                                 \
 196         V0((obj),Delete)();                                                   \
 197     }                                                                         \
 198 } while(0)
 199
 200
 201 #define EXTRACT_NEW_ARGS(...)  __VA_ARGS__);                                  \
 202     }                                                                         \
 203 } while(0)
 204
 205 #define NEW_OBJ(_res, T) do {                                                 \
 206     _res = T##_New(sizeof(T));                                                \
 207     if(_res)                                                                  \
 208     {                                                                         \
 209         memset(_res, 0, sizeof(T));                                           \
 210         T##_Construct(_res, EXTRACT_NEW_ARGS
 211
 212
 213 #ifdef __cplusplus
 214 extern "C" {
 215 #endif
 216
 217 struct Hrtf;
 218
 219
 220 #define DEFAULT_OUTPUT_RATE  (44100)
 221 #define MIN_OUTPUT_RATE      (8000)
 222
 223
 224 /* Find the next power-of-2 for non-power-of-2 numbers. */
 225 inline ALuint NextPowerOf2(ALuint value)
 226 {
 227     if(value > 0)
 228     {
 229         value--;
 230         value |= value>>1;
 231         value |= value>>2;
 232         value |= value>>4;
 233         value |= value>>8;
 234         value |= value>>16;
 235     }
 236     return value+1;
 237 }
 238
 239 /* Fast float-to-int conversion. Assumes the FPU is already in round-to-zero
 240  * mode. */
 241 inline ALint fastf2i(ALfloat f)
 242 {
 243 #ifdef HAVE_LRINTF
 244     return lrintf(f);
 245 #elif defined(_MSC_VER) && defined(_M_IX86)
 246     ALint i;
 247     __asm fld f
 248     __asm fistp i
 249     return i;
 250 #else
 251     return (ALint)f;
 252 #endif
 253 }
 254
 255 /* Fast float-to-uint conversion. Assumes the FPU is already in round-to-zero
 256  * mode. */
 257 inline ALuint fastf2u(ALfloat f)
 258 { return fastf2i(f); }
 259
 260
 261 enum DevProbe {
 262     ALL_DEVICE_PROBE,
 263     CAPTURE_DEVICE_PROBE
 264 };
 265
 266 typedef struct {
 267     ALCenum (*OpenPlayback)(ALCdevice*, const ALCchar*);
 268     void (*ClosePlayback)(ALCdevice*);
 269     ALCboolean (*ResetPlayback)(ALCdevice*);
 270     ALCboolean (*StartPlayback)(ALCdevice*);
 271     void (*StopPlayback)(ALCdevice*);
 272
 273     ALCenum (*OpenCapture)(ALCdevice*, const ALCchar*);
 274     void (*CloseCapture)(ALCdevice*);
 275     void (*StartCapture)(ALCdevice*);
 276     void (*StopCapture)(ALCdevice*);
 277     ALCenum (*CaptureSamples)(ALCdevice*, void*, ALCuint);
 278     ALCuint (*AvailableSamples)(ALCdevice*);
 279 } BackendFuncs;
 280
 281 ALCboolean alc_sndio_init(BackendFuncs *func_list);
 282 void alc_sndio_deinit(void);
 283 void alc_sndio_probe(enum DevProbe type);
 284 ALCboolean alc_ca_init(BackendFuncs *func_list);
 285 void alc_ca_deinit(void);
 286 void alc_ca_probe(enum DevProbe type);
 287 ALCboolean alc_opensl_init(BackendFuncs *func_list);
 288 void alc_opensl_deinit(void);
 289 void alc_opensl_probe(enum DevProbe type);
 290 ALCboolean alc_qsa_init(BackendFuncs *func_list);
 291 void alc_qsa_deinit(void);
 292 void alc_qsa_probe(enum DevProbe type);
 293
 294 struct ALCbackend;
 295
 296
 297 enum DistanceModel {
 298     InverseDistanceClamped  = AL_INVERSE_DISTANCE_CLAMPED,
 299     LinearDistanceClamped   = AL_LINEAR_DISTANCE_CLAMPED,
 300     ExponentDistanceClamped = AL_EXPONENT_DISTANCE_CLAMPED,
 301     InverseDistance  = AL_INVERSE_DISTANCE,
 302     LinearDistance   = AL_LINEAR_DISTANCE,
 303     ExponentDistance = AL_EXPONENT_DISTANCE,
 304     DisableDistance  = AL_NONE,
 305
 306     DefaultDistanceModel = InverseDistanceClamped
 307 };
 308
 309 enum Channel {
 310     FrontLeft = 0,
 311     FrontRight,
 312     FrontCenter,
 313     LFE,
 314     BackLeft,
 315     BackRight,
 316     BackCenter,
 317     SideLeft,
 318     SideRight,
 319
 320     UpperFrontLeft,
 321     UpperFrontRight,
 322     UpperBackLeft,
 323     UpperBackRight,
 324     LowerFrontLeft,
 325     LowerFrontRight,
 326     LowerBackLeft,
 327     LowerBackRight,
 328
 329     BFormatW,
 330     BFormatX,
 331     BFormatY,
 332     BFormatZ,
 333
 334     InvalidChannel
 335 };
 336
 337
 338 /* Device formats */
 339 enum DevFmtType {
 340     DevFmtByte   = ALC_BYTE_SOFT,
 341     DevFmtUByte  = ALC_UNSIGNED_BYTE_SOFT,
 342     DevFmtShort  = ALC_SHORT_SOFT,
 343     DevFmtUShort = ALC_UNSIGNED_SHORT_SOFT,
 344     DevFmtInt    = ALC_INT_SOFT,
 345     DevFmtUInt   = ALC_UNSIGNED_INT_SOFT,
 346     DevFmtFloat  = ALC_FLOAT_SOFT,
 347
 348     DevFmtTypeDefault = DevFmtFloat
 349 };
 350 enum DevFmtChannels {
 351     DevFmtMono   = ALC_MONO_SOFT,
 352     DevFmtStereo = ALC_STEREO_SOFT,
 353     DevFmtQuad   = ALC_QUAD_SOFT,
 354     DevFmtX51    = ALC_5POINT1_SOFT,
 355     DevFmtX61    = ALC_6POINT1_SOFT,
 356     DevFmtX71    = ALC_7POINT1_SOFT,
 357
 358     /* Similar to 5.1, except using rear channels instead of sides */
 359     DevFmtX51Rear = 0x80000000,
 360
 361     DevFmtBFormat3D,
 362
 363     DevFmtChannelsDefault = DevFmtStereo
 364 };
 365 #define MAX_OUTPUT_CHANNELS  (8)
 366
 367 ALuint BytesFromDevFmt(enum DevFmtType type) DECL_CONST;
 368 ALuint ChannelsFromDevFmt(enum DevFmtChannels chans) DECL_CONST;
 369 inline ALuint FrameSizeFromDevFmt(enum DevFmtChannels chans, enum DevFmtType type)
 370 {
 371     return ChannelsFromDevFmt(chans) * BytesFromDevFmt(type);
 372 }
 373
 374
 375 extern const struct EffectList {
 376     const char *name;
 377     int type;
 378     const char *ename;
 379     ALenum val;
 380 } EffectList[];
 381
 382
 383 enum DeviceType {
 384     Playback,
 385     Capture,
 386     Loopback
 387 };
 388
 389
 390 enum RenderMode {
 391     NormalRender,
 392     StereoPair,
 393     HrtfRender
 394 };
 395
 396
 397 /* The maximum number of Ambisonics coefficients. For a given order (o), the
 398  * size needed will be (o+1)**2, thus zero-order has 1, first-order has 4,
 399  * second-order has 9, and third-order has 16. */
 400 #define MAX_AMBI_COEFFS 16
 401
 402 typedef ALfloat ChannelConfig[MAX_AMBI_COEFFS];
 403
 404
 405 #define HRTF_HISTORY_BITS   (6)
 406 #define HRTF_HISTORY_LENGTH (1<<HRTF_HISTORY_BITS)
 407 #define HRTF_HISTORY_MASK   (HRTF_HISTORY_LENGTH-1)
 408
 409 typedef struct HrtfState {
 410     alignas(16) ALfloat History[HRTF_HISTORY_LENGTH];
 411     alignas(16) ALfloat Values[HRIR_LENGTH][2];
 412 } HrtfState;
 413
 414 typedef struct HrtfParams {
 415     alignas(16) ALfloat Coeffs[HRIR_LENGTH][2];
 416     ALuint Delay[2];
 417 } HrtfParams;
 418
 419
 420 /* Size for temporary storage of buffer data, in ALfloats. Larger values need
 421  * more memory, while smaller values may need more iterations. The value needs
 422  * to be a sensible size, however, as it constrains the max stepping value used
 423  * for mixing, as well as the maximum number of samples per mixing iteration.
 424  */
 425 #define BUFFERSIZE (2048u)
 426
 427 struct ALCdevice_struct
 428 {
 429     RefCount ref;
 430
 431     ALCboolean Connected;
 432     enum DeviceType Type;
 433
 434     ALuint Frequency;
 435     ALuint UpdateSize;
 436     ALuint NumUpdates;
 437     enum DevFmtChannels FmtChans;
 438     enum DevFmtType     FmtType;
 439     ALboolean IsHeadphones;
 440
 441     al_string DeviceName;
 442
 443     ATOMIC(ALCenum) LastError;
 444
 445     // Maximum number of sources that can be created
 446     ALuint MaxNoOfSources;
 447     // Maximum number of slots that can be created
 448     ALuint AuxiliaryEffectSlotMax;
 449
 450     ALCuint NumMonoSources;
 451     ALCuint NumStereoSources;
 452     ALuint  NumAuxSends;
 453
 454     // Map of Buffers for this device
 455     UIntMap BufferMap;
 456
 457     // Map of Effects for this device
 458     UIntMap EffectMap;
 459
 460     // Map of Filters for this device
 461     UIntMap FilterMap;
 462
 463     /* HRTF filter tables */
 464     vector_HrtfEntry Hrtf_List;
 465     al_string Hrtf_Name;
 466     const struct Hrtf *Hrtf;
 467     ALCenum Hrtf_Status;
 468     HrtfState Hrtf_State[MAX_OUTPUT_CHANNELS];
 469     HrtfParams Hrtf_Params[MAX_OUTPUT_CHANNELS];
 470     ALuint Hrtf_Offset;
 471
 472     /* UHJ encoder state */
 473     struct Uhj2Encoder *Uhj_Encoder;
 474
 475     // Stereo-to-binaural filter
 476     struct bs2b *Bs2b;
 477
 478     /* Rendering mode. */
 479     enum RenderMode Render_Mode;
 480
 481     // Device flags
 482     ALuint Flags;
 483
 484     ALuint64 ClockBase;
 485     ALuint SamplesDone;
 486
 487     /* Temp storage used for each source when mixing. */
 488     alignas(16) ALfloat SourceData[BUFFERSIZE];
 489     alignas(16) ALfloat ResampledData[BUFFERSIZE];
 490     alignas(16) ALfloat FilteredData[BUFFERSIZE];
 491
 492     /* The "dry" path corresponds to the main output. */
 493     struct {
 494         /* Channel names for the dry buffer mix. */
 495         enum Channel ChannelName[MAX_OUTPUT_CHANNELS];
 496         /* Ambisonic coefficients for mixing to the dry buffer. */
 497         ChannelConfig AmbiCoeffs[MAX_OUTPUT_CHANNELS];
 498         /* Scale for first-order XYZ inputs using AmbiCoeffs. */
 499         ALfloat AmbiScale;
 500
 501         /* Dry buffer will be aliased by the virtual or real output. */
 502         ALfloat (*Buffer)[BUFFERSIZE];
 503         ALuint NumChannels;
 504     } Dry;
 505
 506     /* Virtual output, to be post-processed to the real output. */
 507     struct {
 508         ALfloat (*Buffer)[BUFFERSIZE];
 509         ALuint NumChannels;
 510     } VirtOut;
 511     /* "Real" output, which will be written to the device buffer. */
 512     struct {
 513         ALfloat (*Buffer)[BUFFERSIZE];
 514         ALuint NumChannels;
 515     } RealOut;
 516
 517     /* Running count of the mixer invocations, in 31.1 fixed point. This
 518      * actually increments *twice* when mixing, first at the start and then at
 519      * the end, so the bottom bit indicates if the device is currently mixing
 520      * and the upper bits indicates how many mixes have been done.
 521      */
 522     RefCount MixCount;
 523
 524     /* Default effect slot */
 525     struct ALeffectslot *DefaultSlot;
 526
 527     // Contexts created on this device
 528     ATOMIC(ALCcontext*) ContextList;
 529
 530     struct ALCbackend *Backend;
 531
 532     void *ExtraData; // For the backend's use
 533
 534     ALCdevice *volatile next;
 535
 536     /* Memory space used by the default slot (Playback devices only) */
 537     alignas(16) ALCbyte _slot_mem[];
 538 };
 539
 540 // Frequency was requested by the app or config file
 541 #define DEVICE_FREQUENCY_REQUEST                 (1<<1)
 542 // Channel configuration was requested by the config file
 543 #define DEVICE_CHANNELS_REQUEST                  (1<<2)
 544 // Sample type was requested by the config file
 545 #define DEVICE_SAMPLE_TYPE_REQUEST               (1<<3)
 546
 547 // Specifies if the DSP is paused at user request
 548 #define DEVICE_PAUSED                            (1<<30)
 549
 550 // Specifies if the device is currently running
 551 #define DEVICE_RUNNING                           (1<<31)
 552
 553
 554 /* Nanosecond resolution for the device clock time. */
 555 #define DEVICE_CLOCK_RES  U64(1000000000)
 556
 557
 558 /* Must be less than 15 characters (16 including terminating null) for
 559  * compatibility with pthread_setname_np limitations. */
 560 #define MIXER_THREAD_NAME "alsoft-mixer"
 561
 562 #define RECORD_THREAD_NAME "alsoft-record"
 563
 564
 565 struct ALCcontext_struct
 566 {
 567     RefCount ref;
 568
 569     struct ALlistener *Listener;
 570
 571     UIntMap SourceMap;
 572     UIntMap EffectSlotMap;
 573
 574     ATOMIC(ALenum) LastError;
 575
 576     ATOMIC(ALenum) UpdateSources;
 577
 578     volatile enum DistanceModel DistanceModel;
 579     volatile ALboolean SourceDistanceModel;
 580
 581     volatile ALfloat DopplerFactor;
 582     volatile ALfloat DopplerVelocity;
 583     volatile ALfloat SpeedOfSound;
 584     volatile ALenum  DeferUpdates;
 585
 586     struct ALvoice *Voices;
 587     ALsizei VoiceCount;
 588     ALsizei MaxVoices;
 589
 590     VECTOR(struct ALeffectslot*) ActiveAuxSlots;
 591
 592     ALCdevice  *Device;
 593     const ALCchar *ExtensionList;
 594
 595     ALCcontext *volatile next;
 596
 597     /* Memory space used by the listener */
 598     alignas(16) ALCbyte _listener_mem[];
 599 };
 600
 601 ALCcontext *GetContextRef(void);
 602
 603 void ALCcontext_IncRef(ALCcontext *context);
 604 void ALCcontext_DecRef(ALCcontext *context);
 605
 606 void AppendAllDevicesList(const ALCchar *name);
 607 void AppendCaptureDeviceList(const ALCchar *name);
 608
 609 void ALCdevice_Lock(ALCdevice *device);
 610 void ALCdevice_Unlock(ALCdevice *device);
 611
 612 void ALCcontext_DeferUpdates(ALCcontext *context);
 613 void ALCcontext_ProcessUpdates(ALCcontext *context);
 614
 615 inline void LockContext(ALCcontext *context)
 616 { ALCdevice_Lock(context->Device); }
 617
 618 inline void UnlockContext(ALCcontext *context)
 619 { ALCdevice_Unlock(context->Device); }
 620
 621
 622 void *al_malloc(size_t alignment, size_t size);
 623 void *al_calloc(size_t alignment, size_t size);
 624 void al_free(void *ptr);
 625
 626
 627 typedef struct {
 628 #ifdef HAVE_FENV_H
 629     DERIVE_FROM_TYPE(fenv_t);
 630 #else
 631     int state;
 632 #endif
 633 #ifdef HAVE_SSE
 634     int sse_state;
 635 #endif
 636 } FPUCtl;
 637 void SetMixerFPUMode(FPUCtl *ctl);
 638 void RestoreFPUMode(const FPUCtl *ctl);
 639
 640
 641 typedef struct RingBuffer RingBuffer;
 642 RingBuffer *CreateRingBuffer(ALsizei frame_size, ALsizei length);
 643 void DestroyRingBuffer(RingBuffer *ring);
 644 ALsizei RingBufferSize(RingBuffer *ring);
 645 void WriteRingBuffer(RingBuffer *ring, const ALubyte *data, ALsizei len);
 646 void ReadRingBuffer(RingBuffer *ring, ALubyte *data, ALsizei len);
 647
 648 typedef struct ll_ringbuffer ll_ringbuffer_t;
 649 typedef struct ll_ringbuffer_data {
 650     char *buf;
 651     size_t len;
 652 } ll_ringbuffer_data_t;
 653 ll_ringbuffer_t *ll_ringbuffer_create(size_t sz, size_t elem_sz);
 654 void ll_ringbuffer_free(ll_ringbuffer_t *rb);
 655 void ll_ringbuffer_get_read_vector(const ll_ringbuffer_t *rb, ll_ringbuffer_data_t *vec);
 656 void ll_ringbuffer_get_write_vector(const ll_ringbuffer_t *rb, ll_ringbuffer_data_t *vec);
 657 size_t ll_ringbuffer_read(ll_ringbuffer_t *rb, char *dest, size_t cnt);
 658 size_t ll_ringbuffer_peek(ll_ringbuffer_t *rb, char *dest, size_t cnt);
 659 void ll_ringbuffer_read_advance(ll_ringbuffer_t *rb, size_t cnt);
 660 size_t ll_ringbuffer_read_space(const ll_ringbuffer_t *rb);
 661 int ll_ringbuffer_mlock(ll_ringbuffer_t *rb);
 662 void ll_ringbuffer_reset(ll_ringbuffer_t *rb);
 663 size_t ll_ringbuffer_write(ll_ringbuffer_t *rb, const char *src, size_t cnt);
 664 void ll_ringbuffer_write_advance(ll_ringbuffer_t *rb, size_t cnt);
 665 size_t ll_ringbuffer_write_space(const ll_ringbuffer_t *rb);
 666
 667 void ReadALConfig(void);
 668 void FreeALConfig(void);
 669 int ConfigValueExists(const char *devName, const char *blockName, const char *keyName);
 670 const char *GetConfigValue(const char *devName, const char *blockName, const char *keyName, const char *def);
 671 int GetConfigValueBool(const char *devName, const char *blockName, const char *keyName, int def);
 672 int ConfigValueStr(const char *devName, const char *blockName, const char *keyName, const char **ret);
 673 int ConfigValueInt(const char *devName, const char *blockName, const char *keyName, int *ret);
 674 int ConfigValueUInt(const char *devName, const char *blockName, const char *keyName, unsigned int *ret);
 675 int ConfigValueFloat(const char *devName, const char *blockName, const char *keyName, float *ret);
 676 int ConfigValueBool(const char *devName, const char *blockName, const char *keyName, int *ret);
 677
 678 void SetRTPriority(void);
 679
 680 void SetDefaultChannelOrder(ALCdevice *device);
 681 void SetDefaultWFXChannelOrder(ALCdevice *device);
 682
 683 const ALCchar *DevFmtTypeString(enum DevFmtType type) DECL_CONST;
 684 const ALCchar *DevFmtChannelsString(enum DevFmtChannels chans) DECL_CONST;
 685
 686 /**
 687  * GetChannelIdxByName
 688  *
 689  * Returns the dry buffer's channel index for the given channel name (e.g.
 690  * FrontCenter), or -1 if it doesn't exist.
 691  */
 692 inline ALint GetChannelIdxByName(const ALCdevice *device, enum Channel chan)
 693 {
 694     ALint i = 0;
 695     for(i = 0;i < MAX_OUTPUT_CHANNELS;i++)
 696     {
 697         if(device->Dry.ChannelName[i] == chan)
 698             return i;
 699     }
 700     return -1;
 701 }
 702
 703
 704 extern FILE *LogFile;
 705
 706 #if defined(__GNUC__) && !defined(_WIN32) && !defined(IN_IDE_PARSER)
 707 #define AL_PRINT(T, MSG, ...) fprintf(LogFile, "AL lib: %s %s: "MSG, T, __FUNCTION__ , ## __VA_ARGS__)
 708 #else
 709 void al_print(const char *type, const char *func, const char *fmt, ...) DECL_FORMAT(printf, 3,4);
 710 #define AL_PRINT(T, ...) al_print((T), __FUNCTION__, __VA_ARGS__)
 711 #endif
 712
 713 enum LogLevel {
 714     NoLog,
 715     LogError,
 716     LogWarning,
 717     LogTrace,
 718     LogRef
 719 };
 720 extern enum LogLevel LogLevel;
 721
 722 #define TRACEREF(...) do {                                                    \
 723     if(LogLevel >= LogRef)                                                    \
 724         AL_PRINT("(--)", __VA_ARGS__);                                        \
 725 } while(0)
 726
 727 #define TRACE(...) do {                                                       \
 728     if(LogLevel >= LogTrace)                                                  \
 729         AL_PRINT("(II)", __VA_ARGS__);                                        \
 730 } while(0)
 731
 732 #define WARN(...) do {                                                        \
 733     if(LogLevel >= LogWarning)                                                \
 734         AL_PRINT("(WW)", __VA_ARGS__);                                        \
 735 } while(0)
 736
 737 #define ERR(...) do {                                                         \
 738     if(LogLevel >= LogError)                                                  \
 739         AL_PRINT("(EE)", __VA_ARGS__);                                        \
 740 } while(0)
 741
 742
 743 extern ALint RTPrioLevel;
 744
 745
 746 extern ALuint CPUCapFlags;
 747 enum {
 748     CPU_CAP_SSE    = 1<<0,
 749     CPU_CAP_SSE2   = 1<<1,
 750     CPU_CAP_SSE3   = 1<<2,
 751     CPU_CAP_SSE4_1 = 1<<3,
 752     CPU_CAP_NEON   = 1<<4,
 753 };
 754
 755 void FillCPUCaps(ALuint capfilter);
 756
 757 vector_al_string SearchDataFiles(const char *match, const char *subdir);
 758
 759 /* Small hack to use a pointer-to-array type as a normal argument type.
 760  * Shouldn't be used directly. */
 761 typedef ALfloat ALfloatBUFFERSIZE[BUFFERSIZE];
 762
 763
 764 #ifdef __cplusplus
 765 }
 766 #endif
 767
 768 #endif