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         enum Channel ChannelName[MAX_OUTPUT_CHANNELS];
 514
 515         ALfloat (*Buffer)[BUFFERSIZE];
 516         ALuint NumChannels;
 517     } RealOut;
 518
 519     /* Running count of the mixer invocations, in 31.1 fixed point. This
 520      * actually increments *twice* when mixing, first at the start and then at
 521      * the end, so the bottom bit indicates if the device is currently mixing
 522      * and the upper bits indicates how many mixes have been done.
 523      */
 524     RefCount MixCount;
 525
 526     /* Default effect slot */
 527     struct ALeffectslot *DefaultSlot;
 528
 529     // Contexts created on this device
 530     ATOMIC(ALCcontext*) ContextList;
 531
 532     struct ALCbackend *Backend;
 533
 534     void *ExtraData; // For the backend's use
 535
 536     ALCdevice *volatile next;
 537
 538     /* Memory space used by the default slot (Playback devices only) */
 539     alignas(16) ALCbyte _slot_mem[];
 540 };
 541
 542 // Frequency was requested by the app or config file
 543 #define DEVICE_FREQUENCY_REQUEST                 (1<<1)
 544 // Channel configuration was requested by the config file
 545 #define DEVICE_CHANNELS_REQUEST                  (1<<2)
 546 // Sample type was requested by the config file
 547 #define DEVICE_SAMPLE_TYPE_REQUEST               (1<<3)
 548
 549 // Specifies if the DSP is paused at user request
 550 #define DEVICE_PAUSED                            (1<<30)
 551
 552 // Specifies if the device is currently running
 553 #define DEVICE_RUNNING                           (1<<31)
 554
 555
 556 /* Nanosecond resolution for the device clock time. */
 557 #define DEVICE_CLOCK_RES  U64(1000000000)
 558
 559
 560 /* Must be less than 15 characters (16 including terminating null) for
 561  * compatibility with pthread_setname_np limitations. */
 562 #define MIXER_THREAD_NAME "alsoft-mixer"
 563
 564 #define RECORD_THREAD_NAME "alsoft-record"
 565
 566
 567 struct ALCcontext_struct
 568 {
 569     RefCount ref;
 570
 571     struct ALlistener *Listener;
 572
 573     UIntMap SourceMap;
 574     UIntMap EffectSlotMap;
 575
 576     ATOMIC(ALenum) LastError;
 577
 578     ATOMIC(ALenum) UpdateSources;
 579
 580     volatile enum DistanceModel DistanceModel;
 581     volatile ALboolean SourceDistanceModel;
 582
 583     volatile ALfloat DopplerFactor;
 584     volatile ALfloat DopplerVelocity;
 585     volatile ALfloat SpeedOfSound;
 586     volatile ALenum  DeferUpdates;
 587
 588     struct ALvoice *Voices;
 589     ALsizei VoiceCount;
 590     ALsizei MaxVoices;
 591
 592     VECTOR(struct ALeffectslot*) ActiveAuxSlots;
 593
 594     ALCdevice  *Device;
 595     const ALCchar *ExtensionList;
 596
 597     ALCcontext *volatile next;
 598
 599     /* Memory space used by the listener */
 600     alignas(16) ALCbyte _listener_mem[];
 601 };
 602
 603 ALCcontext *GetContextRef(void);
 604
 605 void ALCcontext_IncRef(ALCcontext *context);
 606 void ALCcontext_DecRef(ALCcontext *context);
 607
 608 void AppendAllDevicesList(const ALCchar *name);
 609 void AppendCaptureDeviceList(const ALCchar *name);
 610
 611 void ALCdevice_Lock(ALCdevice *device);
 612 void ALCdevice_Unlock(ALCdevice *device);
 613
 614 void ALCcontext_DeferUpdates(ALCcontext *context);
 615 void ALCcontext_ProcessUpdates(ALCcontext *context);
 616
 617 inline void LockContext(ALCcontext *context)
 618 { ALCdevice_Lock(context->Device); }
 619
 620 inline void UnlockContext(ALCcontext *context)
 621 { ALCdevice_Unlock(context->Device); }
 622
 623
 624 void *al_malloc(size_t alignment, size_t size);
 625 void *al_calloc(size_t alignment, size_t size);
 626 void al_free(void *ptr);
 627
 628
 629 typedef struct {
 630 #ifdef HAVE_FENV_H
 631     DERIVE_FROM_TYPE(fenv_t);
 632 #else
 633     int state;
 634 #endif
 635 #ifdef HAVE_SSE
 636     int sse_state;
 637 #endif
 638 } FPUCtl;
 639 void SetMixerFPUMode(FPUCtl *ctl);
 640 void RestoreFPUMode(const FPUCtl *ctl);
 641
 642
 643 typedef struct RingBuffer RingBuffer;
 644 RingBuffer *CreateRingBuffer(ALsizei frame_size, ALsizei length);
 645 void DestroyRingBuffer(RingBuffer *ring);
 646 ALsizei RingBufferSize(RingBuffer *ring);
 647 void WriteRingBuffer(RingBuffer *ring, const ALubyte *data, ALsizei len);
 648 void ReadRingBuffer(RingBuffer *ring, ALubyte *data, ALsizei len);
 649
 650 typedef struct ll_ringbuffer ll_ringbuffer_t;
 651 typedef struct ll_ringbuffer_data {
 652     char *buf;
 653     size_t len;
 654 } ll_ringbuffer_data_t;
 655 ll_ringbuffer_t *ll_ringbuffer_create(size_t sz, size_t elem_sz);
 656 void ll_ringbuffer_free(ll_ringbuffer_t *rb);
 657 void ll_ringbuffer_get_read_vector(const ll_ringbuffer_t *rb, ll_ringbuffer_data_t *vec);
 658 void ll_ringbuffer_get_write_vector(const ll_ringbuffer_t *rb, ll_ringbuffer_data_t *vec);
 659 size_t ll_ringbuffer_read(ll_ringbuffer_t *rb, char *dest, size_t cnt);
 660 size_t ll_ringbuffer_peek(ll_ringbuffer_t *rb, char *dest, size_t cnt);
 661 void ll_ringbuffer_read_advance(ll_ringbuffer_t *rb, size_t cnt);
 662 size_t ll_ringbuffer_read_space(const ll_ringbuffer_t *rb);
 663 int ll_ringbuffer_mlock(ll_ringbuffer_t *rb);
 664 void ll_ringbuffer_reset(ll_ringbuffer_t *rb);
 665 size_t ll_ringbuffer_write(ll_ringbuffer_t *rb, const char *src, size_t cnt);
 666 void ll_ringbuffer_write_advance(ll_ringbuffer_t *rb, size_t cnt);
 667 size_t ll_ringbuffer_write_space(const ll_ringbuffer_t *rb);
 668
 669 void ReadALConfig(void);
 670 void FreeALConfig(void);
 671 int ConfigValueExists(const char *devName, const char *blockName, const char *keyName);
 672 const char *GetConfigValue(const char *devName, const char *blockName, const char *keyName, const char *def);
 673 int GetConfigValueBool(const char *devName, const char *blockName, const char *keyName, int def);
 674 int ConfigValueStr(const char *devName, const char *blockName, const char *keyName, const char **ret);
 675 int ConfigValueInt(const char *devName, const char *blockName, const char *keyName, int *ret);
 676 int ConfigValueUInt(const char *devName, const char *blockName, const char *keyName, unsigned int *ret);
 677 int ConfigValueFloat(const char *devName, const char *blockName, const char *keyName, float *ret);
 678 int ConfigValueBool(const char *devName, const char *blockName, const char *keyName, int *ret);
 679
 680 void SetRTPriority(void);
 681
 682 void SetDefaultChannelOrder(ALCdevice *device);
 683 void SetDefaultWFXChannelOrder(ALCdevice *device);
 684
 685 const ALCchar *DevFmtTypeString(enum DevFmtType type) DECL_CONST;
 686 const ALCchar *DevFmtChannelsString(enum DevFmtChannels chans) DECL_CONST;
 687
 688 /**
 689  * GetChannelIdxByName
 690  *
 691  * Returns the dry buffer's channel index for the given channel name (e.g.
 692  * FrontCenter), or -1 if it doesn't exist.
 693  */
 694 inline ALint GetChannelIdxByName(const ALCdevice *device, enum Channel chan)
 695 {
 696     ALint i = 0;
 697     for(i = 0;i < MAX_OUTPUT_CHANNELS;i++)
 698     {
 699         if(device->Dry.ChannelName[i] == chan)
 700             return i;
 701     }
 702     return -1;
 703 }
 704
 705
 706 extern FILE *LogFile;
 707
 708 #if defined(__GNUC__) && !defined(_WIN32) && !defined(IN_IDE_PARSER)
 709 #define AL_PRINT(T, MSG, ...) fprintf(LogFile, "AL lib: %s %s: "MSG, T, __FUNCTION__ , ## __VA_ARGS__)
 710 #else
 711 void al_print(const char *type, const char *func, const char *fmt, ...) DECL_FORMAT(printf, 3,4);
 712 #define AL_PRINT(T, ...) al_print((T), __FUNCTION__, __VA_ARGS__)
 713 #endif
 714
 715 enum LogLevel {
 716     NoLog,
 717     LogError,
 718     LogWarning,
 719     LogTrace,
 720     LogRef
 721 };
 722 extern enum LogLevel LogLevel;
 723
 724 #define TRACEREF(...) do {                                                    \
 725     if(LogLevel >= LogRef)                                                    \
 726         AL_PRINT("(--)", __VA_ARGS__);                                        \
 727 } while(0)
 728
 729 #define TRACE(...) do {                                                       \
 730     if(LogLevel >= LogTrace)                                                  \
 731         AL_PRINT("(II)", __VA_ARGS__);                                        \
 732 } while(0)
 733
 734 #define WARN(...) do {                                                        \
 735     if(LogLevel >= LogWarning)                                                \
 736         AL_PRINT("(WW)", __VA_ARGS__);                                        \
 737 } while(0)
 738
 739 #define ERR(...) do {                                                         \
 740     if(LogLevel >= LogError)                                                  \
 741         AL_PRINT("(EE)", __VA_ARGS__);                                        \
 742 } while(0)
 743
 744
 745 extern ALint RTPrioLevel;
 746
 747
 748 extern ALuint CPUCapFlags;
 749 enum {
 750     CPU_CAP_SSE    = 1<<0,
 751     CPU_CAP_SSE2   = 1<<1,
 752     CPU_CAP_SSE3   = 1<<2,
 753     CPU_CAP_SSE4_1 = 1<<3,
 754     CPU_CAP_NEON   = 1<<4,
 755 };
 756
 757 void FillCPUCaps(ALuint capfilter);
 758
 759 vector_al_string SearchDataFiles(const char *match, const char *subdir);
 760
 761 /* Small hack to use a pointer-to-array type as a normal argument type.
 762  * Shouldn't be used directly. */
 763 typedef ALfloat ALfloatBUFFERSIZE[BUFFERSIZE];
 764
 765
 766 #ifdef __cplusplus
 767 }
 768 #endif
 769
 770 #endif