From f9d52ea5b9d6acea6981a03c9ca3cbd6ed1d1fa7 Mon Sep 17 00:00:00 2001 From: Ani Date: Thu, 29 Apr 2021 19:31:49 +0100 Subject: [PATCH] OpenAL: Update include from 1.20.1 to 1.21.1 --- .gitignore | 6 +- 3rdparty/OpenAL/include/al.h | 63 +++++++++-------- 3rdparty/OpenAL/include/alc.h | 75 ++++++++++++++------ 3rdparty/OpenAL/include/alext.h | 87 ++++++++++++++++++------ 3rdparty/OpenAL/include/efx.h | 60 ++++++++-------- 3rdparty/OpenAL/libs/Win64/OpenAL32.def | 80 ++++++++++++++++++++++ 3rdparty/OpenAL/libs/Win64/OpenAL32.lib | Bin 70616 -> 130648 bytes 7 files changed, 268 insertions(+), 103 deletions(-) diff --git a/.gitignore b/.gitignore index fc0f0e22c2..6b176a17d3 100644 --- a/.gitignore +++ b/.gitignore @@ -9,7 +9,7 @@ # Compiled Static libraries *.lai *.la -# *.a # Commented out since OpenAL Soft's binaries use this extension. +*.a *.opensdf *.sdf *.suo @@ -45,6 +45,10 @@ !/bin /bin/* +# Audio DLLs +!/bin/soft_oal.dll +!/bin/xaudio2_9redist.dll + # Themes !/bin/GuiConfigs/ /bin/GuiConfigs/*.ini diff --git a/3rdparty/OpenAL/include/al.h b/3rdparty/OpenAL/include/al.h index 413b38331e..8749e1b77e 100644 --- a/3rdparty/OpenAL/include/al.h +++ b/3rdparty/OpenAL/include/al.h @@ -22,7 +22,7 @@ extern "C" { #endif -/** Deprecated macro. */ +/* Deprecated macros. */ #define OPENAL #define ALAPI AL_API #define ALAPIENTRY AL_APIENTRY @@ -30,7 +30,7 @@ extern "C" { #define AL_ILLEGAL_ENUM AL_INVALID_ENUM #define AL_ILLEGAL_COMMAND AL_INVALID_OPERATION -/** Supported AL version. */ +/* Supported AL versions. */ #define AL_VERSION_1_0 #define AL_VERSION_1_1 @@ -234,7 +234,7 @@ typedef void ALvoid; */ #define AL_SOURCE_STATE 0x1010 -/** Source state value. */ +/* Source state values. */ #define AL_INITIAL 0x1011 #define AL_PLAYING 0x1012 #define AL_PAUSED 0x1013 @@ -300,7 +300,7 @@ typedef void ALvoid; * Source maximum distance. * Type: ALfloat * Range: [0.0 - ] - * Default: +inf + * Default: FLT_MAX * * The distance above which the source is not attenuated any further with a * clamped distance model, or where attenuation reaches 0.0 gain for linear @@ -330,15 +330,18 @@ typedef void ALvoid; */ #define AL_SOURCE_TYPE 0x1027 -/** Source type value. */ +/* Source type values. */ #define AL_STATIC 0x1028 #define AL_STREAMING 0x1029 #define AL_UNDETERMINED 0x1030 -/** Buffer format specifier. */ +/** Unsigned 8-bit mono buffer format. */ #define AL_FORMAT_MONO8 0x1100 +/** Signed 16-bit mono buffer format. */ #define AL_FORMAT_MONO16 0x1101 +/** Unsigned 8-bit stereo buffer format. */ #define AL_FORMAT_STEREO8 0x1102 +/** Signed 16-bit stereo buffer format. */ #define AL_FORMAT_STEREO16 0x1103 /** Buffer frequency (query only). */ @@ -350,11 +353,7 @@ typedef void ALvoid; /** Buffer data size (query only). */ #define AL_SIZE 0x2004 -/** - * Buffer state. - * - * Not for public use. - */ +/* Buffer state. Not for public use. */ #define AL_UNUSED 0x2010 #define AL_PENDING 0x2011 #define AL_PROCESSED 0x2012 @@ -441,7 +440,7 @@ AL_API void AL_APIENTRY alSpeedOfSound(ALfloat value); #define AL_DISTANCE_MODEL 0xD000 AL_API void AL_APIENTRY alDistanceModel(ALenum distanceModel); -/** Distance model value. */ +/* Distance model values. */ #define AL_INVERSE_DISTANCE 0xD001 #define AL_INVERSE_DISTANCE_CLAMPED 0xD002 #define AL_LINEAR_DISTANCE 0xD003 @@ -449,12 +448,12 @@ AL_API void AL_APIENTRY alDistanceModel(ALenum distanceModel); #define AL_EXPONENT_DISTANCE 0xD005 #define AL_EXPONENT_DISTANCE_CLAMPED 0xD006 -/** Renderer State management. */ +/* Renderer State management. */ AL_API void AL_APIENTRY alEnable(ALenum capability); AL_API void AL_APIENTRY alDisable(ALenum capability); AL_API ALboolean AL_APIENTRY alIsEnabled(ALenum capability); -/** State retrieval. */ +/* State retrieval. */ AL_API const ALchar* AL_APIENTRY alGetString(ALenum param); AL_API void AL_APIENTRY alGetBooleanv(ALenum param, ALboolean *values); AL_API void AL_APIENTRY alGetIntegerv(ALenum param, ALint *values); @@ -465,25 +464,25 @@ AL_API ALint AL_APIENTRY alGetInteger(ALenum param); AL_API ALfloat AL_APIENTRY alGetFloat(ALenum param); AL_API ALdouble AL_APIENTRY alGetDouble(ALenum param); -/** - * Error retrieval. - * - * Obtain the first error generated in the AL context since the last check. - */ +/* Error retrieval. */ + +/** Obtain the first error generated in the AL context since the last check. */ AL_API ALenum AL_APIENTRY alGetError(void); -/** - * Extension support. - * - * Query for the presence of an extension, and obtain any appropriate function - * pointers and enum values. - */ +/** Query for the presence of an extension on the AL context. */ AL_API ALboolean AL_APIENTRY alIsExtensionPresent(const ALchar *extname); +/** + * Retrieve the address of a function. The returned function may be context- + * specific. + */ AL_API void* AL_APIENTRY alGetProcAddress(const ALchar *fname); +/** + * Retrieve the value of an enum. The returned value may be context-specific. + */ AL_API ALenum AL_APIENTRY alGetEnumValue(const ALchar *ename); -/** Set Listener parameters */ +/* Set Listener parameters */ AL_API void AL_APIENTRY alListenerf(ALenum param, ALfloat value); AL_API void AL_APIENTRY alListener3f(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3); AL_API void AL_APIENTRY alListenerfv(ALenum param, const ALfloat *values); @@ -491,7 +490,7 @@ AL_API void AL_APIENTRY alListeneri(ALenum param, ALint value); AL_API void AL_APIENTRY alListener3i(ALenum param, ALint value1, ALint value2, ALint value3); AL_API void AL_APIENTRY alListeneriv(ALenum param, const ALint *values); -/** Get Listener parameters */ +/* Get Listener parameters */ AL_API void AL_APIENTRY alGetListenerf(ALenum param, ALfloat *value); AL_API void AL_APIENTRY alGetListener3f(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3); AL_API void AL_APIENTRY alGetListenerfv(ALenum param, ALfloat *values); @@ -507,7 +506,7 @@ AL_API void AL_APIENTRY alDeleteSources(ALsizei n, const ALuint *sources); /** Verify a handle is a valid Source. */ AL_API ALboolean AL_APIENTRY alIsSource(ALuint source); -/** Set Source parameters. */ +/* Set Source parameters. */ AL_API void AL_APIENTRY alSourcef(ALuint source, ALenum param, ALfloat value); AL_API void AL_APIENTRY alSource3f(ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3); AL_API void AL_APIENTRY alSourcefv(ALuint source, ALenum param, const ALfloat *values); @@ -515,7 +514,7 @@ AL_API void AL_APIENTRY alSourcei(ALuint source, ALenum param, ALint value); AL_API void AL_APIENTRY alSource3i(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3); AL_API void AL_APIENTRY alSourceiv(ALuint source, ALenum param, const ALint *values); -/** Get Source parameters. */ +/* Get Source parameters. */ AL_API void AL_APIENTRY alGetSourcef(ALuint source, ALenum param, ALfloat *value); AL_API void AL_APIENTRY alGetSource3f(ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3); AL_API void AL_APIENTRY alGetSourcefv(ALuint source, ALenum param, ALfloat *values); @@ -558,7 +557,7 @@ AL_API ALboolean AL_APIENTRY alIsBuffer(ALuint buffer); /** Specifies the data to be copied into a buffer */ AL_API void AL_APIENTRY alBufferData(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei freq); -/** Set Buffer parameters, */ +/* Set Buffer parameters, */ AL_API void AL_APIENTRY alBufferf(ALuint buffer, ALenum param, ALfloat value); AL_API void AL_APIENTRY alBuffer3f(ALuint buffer, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3); AL_API void AL_APIENTRY alBufferfv(ALuint buffer, ALenum param, const ALfloat *values); @@ -566,7 +565,7 @@ AL_API void AL_APIENTRY alBufferi(ALuint buffer, ALenum param, ALint value); AL_API void AL_APIENTRY alBuffer3i(ALuint buffer, ALenum param, ALint value1, ALint value2, ALint value3); AL_API void AL_APIENTRY alBufferiv(ALuint buffer, ALenum param, const ALint *values); -/** Get Buffer parameters. */ +/* Get Buffer parameters. */ AL_API void AL_APIENTRY alGetBufferf(ALuint buffer, ALenum param, ALfloat *value); AL_API void AL_APIENTRY alGetBuffer3f(ALuint buffer, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3); AL_API void AL_APIENTRY alGetBufferfv(ALuint buffer, ALenum param, ALfloat *values); @@ -574,7 +573,7 @@ AL_API void AL_APIENTRY alGetBufferi(ALuint buffer, ALenum param, ALint *value); AL_API void AL_APIENTRY alGetBuffer3i(ALuint buffer, ALenum param, ALint *value1, ALint *value2, ALint *value3); AL_API void AL_APIENTRY alGetBufferiv(ALuint buffer, ALenum param, ALint *values); -/** Pointer-to-function type, useful for dynamically getting AL entry points. */ +/* Pointer-to-function type, useful for dynamically getting AL entry points. */ typedef void (AL_APIENTRY *LPALENABLE)(ALenum capability); typedef void (AL_APIENTRY *LPALDISABLE)(ALenum capability); typedef ALboolean (AL_APIENTRY *LPALISENABLED)(ALenum capability); diff --git a/3rdparty/OpenAL/include/alc.h b/3rdparty/OpenAL/include/alc.h index 5786bad208..c73b6e9179 100644 --- a/3rdparty/OpenAL/include/alc.h +++ b/3rdparty/OpenAL/include/alc.h @@ -22,7 +22,7 @@ extern "C" { #endif -/** Deprecated macro. */ +/* Deprecated macros. */ #define ALCAPI ALC_API #define ALCAPIENTRY ALC_APIENTRY #define ALC_INVALID 0 @@ -89,7 +89,7 @@ typedef void ALCvoid; /** Context attribute: Hz. */ #define ALC_REFRESH 0x1008 -/** Context attribute: AL_TRUE or AL_FALSE. */ +/** Context attribute: AL_TRUE or AL_FALSE synchronous context? */ #define ALC_SYNC 0x1009 /** Context attribute: requested Mono (3D) Sources. */ @@ -117,12 +117,14 @@ typedef void ALCvoid; #define ALC_OUT_OF_MEMORY 0xA005 -/** Runtime ALC version. */ +/** Runtime ALC major version. */ #define ALC_MAJOR_VERSION 0x1000 +/** Runtime ALC minor version. */ #define ALC_MINOR_VERSION 0x1001 -/** Context attribute list properties. */ +/** Context attribute list size. */ #define ALC_ATTRIBUTES_SIZE 0x1002 +/** Context attribute list properties. */ #define ALC_ALL_ATTRIBUTES 0x1003 /** String for the default device specifier. */ @@ -166,49 +168,80 @@ typedef void ALCvoid; #define ALC_ALL_DEVICES_SPECIFIER 0x1013 -/** Context management. */ -ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint* attrlist); +/* Context management. */ + +/** Create and attach a context to the given device. */ +ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrlist); +/** + * Makes the given context the active process-wide context. Passing NULL clears + * the active context. + */ ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context); +/** Resumes processing updates for the given context. */ ALC_API void ALC_APIENTRY alcProcessContext(ALCcontext *context); +/** Suspends updates for the given context. */ ALC_API void ALC_APIENTRY alcSuspendContext(ALCcontext *context); +/** Remove a context from its device and destroys it. */ ALC_API void ALC_APIENTRY alcDestroyContext(ALCcontext *context); +/** Returns the currently active context. */ ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(void); +/** Returns the device that a particular context is attached to. */ ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice(ALCcontext *context); -/** Device management. */ +/* Device management. */ + +/** Opens the named playback device. */ ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *devicename); +/** Closes the given playback device. */ ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *device); +/* Error support. */ -/** - * Error support. - * - * Obtain the most recent Device error. - */ +/** Obtain the most recent Device error. */ ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device); +/* Extension support. */ + /** - * Extension support. - * - * Query for the presence of an extension, and obtain any appropriate - * function pointers and enum values. + * Query for the presence of an extension on the device. Pass a NULL device to + * query a device-inspecific extension. */ ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extname); -ALC_API void* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcname); +/** + * Retrieve the address of a function. Given a non-NULL device, the returned + * function may be device-specific. + */ +ALC_API ALCvoid* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcname); +/** + * Retrieve the value of an enum. Given a non-NULL device, the returned value + * may be device-specific. + */ ALC_API ALCenum ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumname); -/** Query function. */ +/* Query functions. */ + +/** Returns information about the device, and error strings. */ ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *device, ALCenum param); +/** Returns information about the device and the version of OpenAL. */ ALC_API void ALC_APIENTRY alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values); -/** Capture function. */ +/* Capture functions. */ + +/** + * Opens the named capture device with the given frequency, format, and buffer + * size. + */ ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize); +/** Closes the given capture device. */ ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *device); +/** Starts capturing samples into the device buffer. */ ALC_API void ALC_APIENTRY alcCaptureStart(ALCdevice *device); +/** Stops capturing samples. Samples in the device buffer remain available. */ ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device); +/** Reads samples from the device buffer. */ ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples); -/** Pointer-to-function type, useful for dynamically getting ALC entry points. */ +/* Pointer-to-function type, useful for dynamically getting ALC entry points. */ typedef ALCcontext* (ALC_APIENTRY *LPALCCREATECONTEXT)(ALCdevice *device, const ALCint *attrlist); typedef ALCboolean (ALC_APIENTRY *LPALCMAKECONTEXTCURRENT)(ALCcontext *context); typedef void (ALC_APIENTRY *LPALCPROCESSCONTEXT)(ALCcontext *context); @@ -220,7 +253,7 @@ typedef ALCdevice* (ALC_APIENTRY *LPALCOPENDEVICE)(const ALCchar *devicename typedef ALCboolean (ALC_APIENTRY *LPALCCLOSEDEVICE)(ALCdevice *device); typedef ALCenum (ALC_APIENTRY *LPALCGETERROR)(ALCdevice *device); typedef ALCboolean (ALC_APIENTRY *LPALCISEXTENSIONPRESENT)(ALCdevice *device, const ALCchar *extname); -typedef void* (ALC_APIENTRY *LPALCGETPROCADDRESS)(ALCdevice *device, const ALCchar *funcname); +typedef ALCvoid* (ALC_APIENTRY *LPALCGETPROCADDRESS)(ALCdevice *device, const ALCchar *funcname); typedef ALCenum (ALC_APIENTRY *LPALCGETENUMVALUE)(ALCdevice *device, const ALCchar *enumname); typedef const ALCchar* (ALC_APIENTRY *LPALCGETSTRING)(ALCdevice *device, ALCenum param); typedef void (ALC_APIENTRY *LPALCGETINTEGERV)(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values); diff --git a/3rdparty/OpenAL/include/alext.h b/3rdparty/OpenAL/include/alext.h index bfc7c1048f..f80b0708ab 100644 --- a/3rdparty/OpenAL/include/alext.h +++ b/3rdparty/OpenAL/include/alext.h @@ -22,17 +22,20 @@ #define AL_ALEXT_H #include -/* Define int64_t and uint64_t types */ -#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L -#include -#elif defined(_WIN32) && defined(__GNUC__) +/* Define int64 and uint64 types */ +#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || \ + (defined(__cplusplus) && __cplusplus >= 201103L) #include +typedef int64_t _alsoft_int64_t; +typedef uint64_t _alsoft_uint64_t; #elif defined(_WIN32) -typedef __int64 int64_t; -typedef unsigned __int64 uint64_t; +typedef __int64 _alsoft_int64_t; +typedef unsigned __int64 _alsoft_uint64_t; #else /* Fallback if nothing above works */ -#include +#include +typedef int64_t _alsoft_int64_t; +typedef uint64_t _alsoft_uint64_t; #endif #include "alc.h" @@ -158,9 +161,9 @@ extern "C" { #ifndef AL_EXT_STATIC_BUFFER #define AL_EXT_STATIC_BUFFER 1 -typedef ALvoid (AL_APIENTRY*PFNALBUFFERDATASTATICPROC)(const ALint,ALenum,ALvoid*,ALsizei,ALsizei); +typedef void (AL_APIENTRY*PFNALBUFFERDATASTATICPROC)(const ALint,ALenum,ALvoid*,ALsizei,ALsizei); #ifdef AL_ALEXT_PROTOTYPES -AL_API ALvoid AL_APIENTRY alBufferDataStatic(const ALint buffer, ALenum format, ALvoid *data, ALsizei len, ALsizei freq); +AL_API void AL_APIENTRY alBufferDataStatic(const ALint buffer, ALenum format, ALvoid *data, ALsizei len, ALsizei freq); #endif #endif @@ -193,9 +196,9 @@ ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void); #define AL_SOFT_buffer_sub_data 1 #define AL_BYTE_RW_OFFSETS_SOFT 0x1031 #define AL_SAMPLE_RW_OFFSETS_SOFT 0x1032 -typedef ALvoid (AL_APIENTRY*PFNALBUFFERSUBDATASOFTPROC)(ALuint,ALenum,const ALvoid*,ALsizei,ALsizei); +typedef void (AL_APIENTRY*PFNALBUFFERSUBDATASOFTPROC)(ALuint,ALenum,const ALvoid*,ALsizei,ALsizei); #ifdef AL_ALEXT_PROTOTYPES -AL_API ALvoid AL_APIENTRY alBufferSubDataSOFT(ALuint buffer,ALenum format,const ALvoid *data,ALsizei offset,ALsizei length); +AL_API void AL_APIENTRY alBufferSubDataSOFT(ALuint buffer,ALenum format,const ALvoid *data,ALsizei offset,ALsizei length); #endif #endif @@ -343,8 +346,8 @@ ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffe #define AL_SOFT_source_latency 1 #define AL_SAMPLE_OFFSET_LATENCY_SOFT 0x1200 #define AL_SEC_OFFSET_LATENCY_SOFT 0x1201 -typedef int64_t ALint64SOFT; -typedef uint64_t ALuint64SOFT; +typedef _alsoft_int64_t ALint64SOFT; +typedef _alsoft_uint64_t ALuint64SOFT; typedef void (AL_APIENTRY*LPALSOURCEDSOFT)(ALuint,ALenum,ALdouble); typedef void (AL_APIENTRY*LPALSOURCE3DSOFT)(ALuint,ALenum,ALdouble,ALdouble,ALdouble); typedef void (AL_APIENTRY*LPALSOURCEDVSOFT)(ALuint,ALenum,const ALdouble*); @@ -381,11 +384,11 @@ AL_API void AL_APIENTRY alGetSourcei64vSOFT(ALuint source, ALenum param, ALint64 #ifndef AL_SOFT_deferred_updates #define AL_SOFT_deferred_updates 1 #define AL_DEFERRED_UPDATES_SOFT 0xC002 -typedef ALvoid (AL_APIENTRY*LPALDEFERUPDATESSOFT)(void); -typedef ALvoid (AL_APIENTRY*LPALPROCESSUPDATESSOFT)(void); +typedef void (AL_APIENTRY*LPALDEFERUPDATESSOFT)(void); +typedef void (AL_APIENTRY*LPALPROCESSUPDATESSOFT)(void); #ifdef AL_ALEXT_PROTOTYPES -AL_API ALvoid AL_APIENTRY alDeferUpdatesSOFT(void); -AL_API ALvoid AL_APIENTRY alProcessUpdatesSOFT(void); +AL_API void AL_APIENTRY alDeferUpdatesSOFT(void); +AL_API void AL_APIENTRY alProcessUpdatesSOFT(void); #endif #endif @@ -496,8 +499,8 @@ AL_API const ALchar* AL_APIENTRY alGetStringiSOFT(ALenum pname, ALsizei index); #ifndef ALC_SOFT_device_clock #define ALC_SOFT_device_clock 1 -typedef int64_t ALCint64SOFT; -typedef uint64_t ALCuint64SOFT; +typedef _alsoft_int64_t ALCint64SOFT; +typedef _alsoft_uint64_t ALCuint64SOFT; #define ALC_DEVICE_CLOCK_SOFT 0x1600 #define ALC_DEVICE_LATENCY_SOFT 0x1601 #define ALC_DEVICE_CLOCK_LATENCY_SOFT 0x1602 @@ -530,6 +533,52 @@ ALC_API void ALC_APIENTRY alcGetInteger64vSOFT(ALCdevice *device, ALCenum pname, #define AL_N3D_SOFT 0x0002 #endif +#ifndef ALC_SOFT_loopback_bformat +#define ALC_SOFT_loopback_bformat 1 +#define ALC_AMBISONIC_LAYOUT_SOFT 0x1997 +#define ALC_AMBISONIC_SCALING_SOFT 0x1998 +#define ALC_AMBISONIC_ORDER_SOFT 0x1999 +#define ALC_MAX_AMBISONIC_ORDER_SOFT 0x199B + +#define ALC_BFORMAT3D_SOFT 0x1507 + +/* Ambisonic layouts */ +#define ALC_FUMA_SOFT 0x0000 +#define ALC_ACN_SOFT 0x0001 + +/* Ambisonic scalings (normalization) */ +/*#define ALC_FUMA_SOFT*/ +#define ALC_SN3D_SOFT 0x0001 +#define ALC_N3D_SOFT 0x0002 +#endif + +#ifndef AL_SOFT_effect_target +#define AL_SOFT_effect_target +#define AL_EFFECTSLOT_TARGET_SOFT 0x199C +#endif + +#ifndef AL_SOFT_events +#define AL_SOFT_events 1 +#define AL_EVENT_CALLBACK_FUNCTION_SOFT 0x19A2 +#define AL_EVENT_CALLBACK_USER_PARAM_SOFT 0x19A3 +#define AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT 0x19A4 +#define AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT 0x19A5 +#define AL_EVENT_TYPE_DISCONNECTED_SOFT 0x19A6 +typedef void (AL_APIENTRY*ALEVENTPROCSOFT)(ALenum eventType, ALuint object, ALuint param, + ALsizei length, const ALchar *message, + void *userParam); +typedef void (AL_APIENTRY*LPALEVENTCONTROLSOFT)(ALsizei count, const ALenum *types, ALboolean enable); +typedef void (AL_APIENTRY*LPALEVENTCALLBACKSOFT)(ALEVENTPROCSOFT callback, void *userParam); +typedef void* (AL_APIENTRY*LPALGETPOINTERSOFT)(ALenum pname); +typedef void (AL_APIENTRY*LPALGETPOINTERVSOFT)(ALenum pname, void **values); +#ifdef AL_ALEXT_PROTOTYPES +AL_API void AL_APIENTRY alEventControlSOFT(ALsizei count, const ALenum *types, ALboolean enable); +AL_API void AL_APIENTRY alEventCallbackSOFT(ALEVENTPROCSOFT callback, void *userParam); +AL_API void* AL_APIENTRY alGetPointerSOFT(ALenum pname); +AL_API void AL_APIENTRY alGetPointervSOFT(ALenum pname, void **values); +#endif +#endif + #ifdef __cplusplus } #endif diff --git a/3rdparty/OpenAL/include/efx.h b/3rdparty/OpenAL/include/efx.h index 34085651af..5ab64a64d7 100644 --- a/3rdparty/OpenAL/include/efx.h +++ b/3rdparty/OpenAL/include/efx.h @@ -243,41 +243,41 @@ typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTF)(ALuint, ALenum, ALfloat* typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTFV)(ALuint, ALenum, ALfloat*); #ifdef AL_ALEXT_PROTOTYPES -AL_API ALvoid AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects); -AL_API ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, const ALuint *effects); +AL_API void AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects); +AL_API void AL_APIENTRY alDeleteEffects(ALsizei n, const ALuint *effects); AL_API ALboolean AL_APIENTRY alIsEffect(ALuint effect); -AL_API ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue); -AL_API ALvoid AL_APIENTRY alEffectiv(ALuint effect, ALenum param, const ALint *piValues); -AL_API ALvoid AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat flValue); -AL_API ALvoid AL_APIENTRY alEffectfv(ALuint effect, ALenum param, const ALfloat *pflValues); -AL_API ALvoid AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *piValue); -AL_API ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *piValues); -AL_API ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pflValue); -AL_API ALvoid AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *pflValues); +AL_API void AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue); +AL_API void AL_APIENTRY alEffectiv(ALuint effect, ALenum param, const ALint *piValues); +AL_API void AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat flValue); +AL_API void AL_APIENTRY alEffectfv(ALuint effect, ALenum param, const ALfloat *pflValues); +AL_API void AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *piValue); +AL_API void AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *piValues); +AL_API void AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pflValue); +AL_API void AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *pflValues); -AL_API ALvoid AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters); -AL_API ALvoid AL_APIENTRY alDeleteFilters(ALsizei n, const ALuint *filters); +AL_API void AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters); +AL_API void AL_APIENTRY alDeleteFilters(ALsizei n, const ALuint *filters); AL_API ALboolean AL_APIENTRY alIsFilter(ALuint filter); -AL_API ALvoid AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint iValue); -AL_API ALvoid AL_APIENTRY alFilteriv(ALuint filter, ALenum param, const ALint *piValues); -AL_API ALvoid AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat flValue); -AL_API ALvoid AL_APIENTRY alFilterfv(ALuint filter, ALenum param, const ALfloat *pflValues); -AL_API ALvoid AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *piValue); -AL_API ALvoid AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *piValues); -AL_API ALvoid AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pflValue); -AL_API ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *pflValues); +AL_API void AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint iValue); +AL_API void AL_APIENTRY alFilteriv(ALuint filter, ALenum param, const ALint *piValues); +AL_API void AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat flValue); +AL_API void AL_APIENTRY alFilterfv(ALuint filter, ALenum param, const ALfloat *pflValues); +AL_API void AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *piValue); +AL_API void AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *piValues); +AL_API void AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pflValue); +AL_API void AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *pflValues); -AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots); -AL_API ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, const ALuint *effectslots); +AL_API void AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots); +AL_API void AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, const ALuint *effectslots); AL_API ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot); -AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue); -AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, const ALint *piValues); -AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat flValue); -AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, const ALfloat *pflValues); -AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *piValue); -AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues); -AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *pflValue); -AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues); +AL_API void AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue); +AL_API void AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, const ALint *piValues); +AL_API void AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat flValue); +AL_API void AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, const ALfloat *pflValues); +AL_API void AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *piValue); +AL_API void AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues); +AL_API void AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *pflValue); +AL_API void AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues); #endif /* Filter ranges and defaults. */ diff --git a/3rdparty/OpenAL/libs/Win64/OpenAL32.def b/3rdparty/OpenAL/libs/Win64/OpenAL32.def index 32820731c0..a5c4c00097 100644 --- a/3rdparty/OpenAL/libs/Win64/OpenAL32.def +++ b/3rdparty/OpenAL/libs/Win64/OpenAL32.def @@ -1,35 +1,84 @@ EXPORTS + alAuxiliaryEffectSlotPlaySOFT + alAuxiliaryEffectSlotPlayvSOFT + alAuxiliaryEffectSlotStopSOFT + alAuxiliaryEffectSlotStopvSOFT + alAuxiliaryEffectSlotf + alAuxiliaryEffectSlotfv + alAuxiliaryEffectSloti + alAuxiliaryEffectSlotiv alBuffer3f alBuffer3i + alBufferCallbackSOFT alBufferData + alBufferSamplesSOFT + alBufferStorageSOFT + alBufferSubDataSOFT + alBufferSubSamplesSOFT alBufferf alBufferfv alBufferi alBufferiv + alDeferUpdatesSOFT + alDeleteAuxiliaryEffectSlots alDeleteBuffers + alDeleteEffects + alDeleteFilters alDeleteSources alDisable alDistanceModel alDopplerFactor alDopplerVelocity + alEffectf + alEffectfv + alEffecti + alEffectiv alEnable + alEventCallbackSOFT + alEventControlSOFT + alFilterf + alFilterfv + alFilteri + alFilteriv + alFlushMappedBufferSOFT + alGenAuxiliaryEffectSlots alGenBuffers + alGenEffects + alGenFilters alGenSources + alGetAuxiliaryEffectSlotf + alGetAuxiliaryEffectSlotfv + alGetAuxiliaryEffectSloti + alGetAuxiliaryEffectSlotiv alGetBoolean alGetBooleanv + alGetBuffer3PtrSOFT alGetBuffer3f alGetBuffer3i + alGetBufferPtrSOFT + alGetBufferPtrvSOFT + alGetBufferSamplesSOFT alGetBufferf alGetBufferfv alGetBufferi alGetBufferiv alGetDouble alGetDoublev + alGetEffectf + alGetEffectfv + alGetEffecti + alGetEffectiv alGetEnumValue alGetError + alGetFilterf + alGetFilterfv + alGetFilteri + alGetFilteriv alGetFloat alGetFloatv alGetInteger + alGetInteger64SOFT + alGetInteger64vSOFT alGetIntegerv alGetListener3f alGetListener3i @@ -37,17 +86,30 @@ EXPORTS alGetListenerfv alGetListeneri alGetListeneriv + alGetPointerSOFT + alGetPointervSOFT alGetProcAddress + alGetSource3dSOFT alGetSource3f alGetSource3i + alGetSource3i64SOFT + alGetSourcedSOFT + alGetSourcedvSOFT alGetSourcef alGetSourcefv alGetSourcei + alGetSourcei64SOFT + alGetSourcei64vSOFT alGetSourceiv alGetString + alGetStringiSOFT + alIsAuxiliaryEffectSlot alIsBuffer + alIsBufferFormatSupportedSOFT + alIsEffect alIsEnabled alIsExtensionPresent + alIsFilter alIsSource alListener3f alListener3i @@ -55,8 +117,12 @@ EXPORTS alListenerfv alListeneri alListeneriv + alMapBufferSOFT + alProcessUpdatesSOFT + alSource3dSOFT alSource3f alSource3i + alSource3i64SOFT alSourcePause alSourcePausev alSourcePlay @@ -67,11 +133,16 @@ EXPORTS alSourceStop alSourceStopv alSourceUnqueueBuffers + alSourcedSOFT + alSourcedvSOFT alSourcef alSourcefv alSourcei + alSourcei64SOFT + alSourcei64vSOFT alSourceiv alSpeedOfSound + alUnmapBufferSOFT alcCaptureCloseDevice alcCaptureOpenDevice alcCaptureSamples @@ -80,17 +151,26 @@ EXPORTS alcCloseDevice alcCreateContext alcDestroyContext + alcDevicePauseSOFT + alcDeviceResumeSOFT alcGetContextsDevice alcGetCurrentContext alcGetEnumValue alcGetError + alcGetInteger64vSOFT alcGetIntegerv alcGetProcAddress alcGetString + alcGetStringiSOFT alcGetThreadContext alcIsExtensionPresent + alcIsRenderFormatSupportedSOFT + alcLoopbackOpenDeviceSOFT alcMakeContextCurrent alcOpenDevice alcProcessContext + alcRenderSamplesSOFT + alcResetDeviceSOFT alcSetThreadContext alcSuspendContext + alsoft_get_version diff --git a/3rdparty/OpenAL/libs/Win64/OpenAL32.lib b/3rdparty/OpenAL/libs/Win64/OpenAL32.lib index 2ea3cd9d95ed84f7ecee9d931f65d772131bad25..9c6ec3e4fca624ac0c1f0f202b7da16522ed174b 100644 GIT binary patch literal 130648 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