mirrors/SFML
1
0
Fork 0
mirror of https://github.com/SFML/SFML.git synced 2024-11-24 20:31:05 +08:00
Code Issues Packages Projects Releases Wiki Activity

Replaced OpenAL with miniaudio.

Browse Source
This commit is contained in:
binary1248 2023-04-16 16:12:31 +02:00
parent af5edaab91
commit 7b4a82e620
No known key found for this signature in database
GPG Key ID: E5E52A5D6082224A
72 changed files with 96249 additions and 3945 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@ -417,10 +417,6 @@ elseif(SFML_OS_MACOSX)
if(VORBISFILE_LIBRARY STREQUAL "${PROJECT_SOURCE_DIR}/extlibs/libs-osx/Frameworks/vorbisfile.framework")
install(DIRECTORY extlibs/libs-osx/Frameworks/vorbisfile.framework DESTINATION ${CMAKE_INSTALL_LIBDIR})
endif()
if(OPENAL_LIBRARY STREQUAL "${PROJECT_SOURCE_DIR}/extlibs/libs-osx/Frameworks/OpenAL.framework")
install(DIRECTORY "${OPENAL_LIBRARY}" DESTINATION ${CMAKE_INSTALL_LIBDIR})
endif()
endif()
# install the Xcode templates if requested

1
cmake/SFMLConfigDependencies.cmake.in
View File

@ -70,7 +70,6 @@ if(SFML_STATIC_LIBRARIES)
# SFML::Audio
list(FIND SFML_FIND_COMPONENTS "Audio" FIND_SFML_AUDIO_COMPONENT_INDEX)
if(FIND_SFML_AUDIO_COMPONENT_INDEX GREATER -1)
sfml_bind_dependency(TARGET OpenAL FRIENDLY_NAME "OpenAL" SEARCH_NAMES "OpenAL" "openal" "openal32")
if(NOT FIND_SFML_OS_IOS)
sfml_bind_dependency(TARGET VORBIS FRIENDLY_NAME "VorbisFile" SEARCH_NAMES "vorbisfile")
sfml_bind_dependency(TARGET VORBIS FRIENDLY_NAME "VorbisEnc" SEARCH_NAMES "vorbisenc")

1
examples/android/app/src/main/jni/Android.mk
View File

@ -12,7 +12,6 @@ LOCAL_SHARED_LIBRARIES += sfml-graphics-d
LOCAL_SHARED_LIBRARIES += sfml-audio-d
LOCAL_SHARED_LIBRARIES += sfml-network-d
LOCAL_SHARED_LIBRARIES += sfml-activity-d
LOCAL_SHARED_LIBRARIES += openal
LOCAL_WHOLE_STATIC_LIBRARIES := sfml-main-d
include $(BUILD_SHARED_LIBRARY)

30
examples/sound_capture/SoundCapture.cpp
View File

@ -24,6 +24,30 @@ int main()
return EXIT_SUCCESS;
}
// List the available capture devices
auto devices = sf::SoundRecorder::getAvailableDevices();
std::cout << "Available capture devices:\n" << std::endl;
for (auto i = 0u; i < devices.size(); ++i)
std::cout << i << ": " << devices[i] << '\n';
std::cout << std::endl;
std::size_t deviceIndex = 0;
// Choose the capture device
if (devices.size() > 1)
{
deviceIndex = devices.size();
std::cout << "Please choose the capture device to use [0-" << devices.size() - 1 << "]: ";
do
{
std::cin >> deviceIndex;
std::cin.ignore(10000, '\n');
} while (deviceIndex >= devices.size());
}
// Choose the sample rate
unsigned int sampleRate;
std::cout << "Please choose the sample rate for sound capture (44100 is CD quality): ";
@ -37,6 +61,12 @@ int main()
// Here we'll use an integrated custom recorder, which saves the captured data into a SoundBuffer
sf::SoundBufferRecorder recorder;
if (!recorder.setDevice(devices[deviceIndex]))
{
std::cerr << "Failed to set the capture device" << std::endl;
return EXIT_FAILURE;
}
// Audio capture is done in a separate thread, so we can block the main thread while it is capturing
if (!recorder.start(sampleRate))
{

2
examples/voip/Server.cpp
View File

@ -31,7 +31,7 @@ public:
NetworkAudioStream()
{
// Set the sound parameters
initialize(1, 44100);
initialize(1, 44100, {sf::SoundChannel::Mono});
}
////////////////////////////////////////////////////////////

6
extlibs/Android.mk vendored
View File

@ -5,9 +5,3 @@ LOCAL_MODULE := freetype
LOCAL_SRC_FILES := lib/$(TARGET_ARCH_ABI)/libfreetype.a
LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/include
include $(PREBUILT_STATIC_LIBRARY)
include $(CLEAR_VARS)
LOCAL_MODULE := openal
LOCAL_SRC_FILES := lib/$(TARGET_ARCH_ABI)/libopenal.so
LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/include
include $(PREBUILT_SHARED_LIBRARY)

BIN
extlibs/bin/x64/openal32.dll vendored
View File

Binary file not shown.

BIN
extlibs/bin/x86/openal32.dll vendored
View File

Binary file not shown.

656
extlibs/headers/AL/al.h vendored
View File

@ -1,656 +0,0 @@
#ifndef AL_AL_H
#define AL_AL_H
#if defined(__cplusplus)
extern "C" {
#endif
#ifndef AL_API
#if defined(AL_LIBTYPE_STATIC)
#define AL_API
#elif defined(_WIN32)
#define AL_API __declspec(dllimport)
#else
#define AL_API extern
#endif
#endif
#if defined(_WIN32)
#define AL_APIENTRY __cdecl
#else
#define AL_APIENTRY
#endif
/** Deprecated macro. */
#define OPENAL
#define ALAPI AL_API
#define ALAPIENTRY AL_APIENTRY
#define AL_INVALID (-1)
#define AL_ILLEGAL_ENUM AL_INVALID_ENUM
#define AL_ILLEGAL_COMMAND AL_INVALID_OPERATION
/** Supported AL version. */
#define AL_VERSION_1_0
#define AL_VERSION_1_1
/** 8-bit boolean */
typedef char ALboolean;
/** character */
typedef char ALchar;
/** signed 8-bit 2's complement integer */
typedef signed char ALbyte;
/** unsigned 8-bit integer */
typedef unsigned char ALubyte;
/** signed 16-bit 2's complement integer */
typedef short ALshort;
/** unsigned 16-bit integer */
typedef unsigned short ALushort;
/** signed 32-bit 2's complement integer */
typedef int ALint;
/** unsigned 32-bit integer */
typedef unsigned int ALuint;
/** non-negative 32-bit binary integer size */
typedef int ALsizei;
/** enumerated 32-bit value */
typedef int ALenum;
/** 32-bit IEEE754 floating-point */
typedef float ALfloat;
/** 64-bit IEEE754 floating-point */
typedef double ALdouble;
/** void type (for opaque pointers only) */
typedef void ALvoid;
/* Enumerant values begin at column 50. No tabs. */
/** "no distance model" or "no buffer" */
#define AL_NONE 0
/** Boolean False. */
#define AL_FALSE 0
/** Boolean True. */
#define AL_TRUE 1
/**
* Relative source.
* Type: ALboolean
* Range: [AL_TRUE, AL_FALSE]
* Default: AL_FALSE
*
* Specifies if the Source has relative coordinates.
*/
#define AL_SOURCE_RELATIVE 0x202
/**
* Inner cone angle, in degrees.
* Type: ALint, ALfloat
* Range: [0 - 360]
* Default: 360
*
* The angle covered by the inner cone, where the source will not attenuate.
*/
#define AL_CONE_INNER_ANGLE 0x1001
/**
* Outer cone angle, in degrees.
* Range: [0 - 360]
* Default: 360
*
* The angle covered by the outer cone, where the source will be fully
* attenuated.
*/
#define AL_CONE_OUTER_ANGLE 0x1002
/**
* Source pitch.
* Type: ALfloat
* Range: [0.5 - 2.0]
* Default: 1.0
*
* A multiplier for the frequency (sample rate) of the source's buffer.
*/
#define AL_PITCH 0x1003
/**
* Source or listener position.
* Type: ALfloat[3], ALint[3]
* Default: {0, 0, 0}
*
* The source or listener location in three dimensional space.
*
* OpenAL, like OpenGL, uses a right handed coordinate system, where in a
* frontal default view X (thumb) points right, Y points up (index finger), and
* Z points towards the viewer/camera (middle finger).
*
* To switch from a left handed coordinate system, flip the sign on the Z
* coordinate.
*/
#define AL_POSITION 0x1004
/**
* Source direction.
* Type: ALfloat[3], ALint[3]
* Default: {0, 0, 0}
*
* Specifies the current direction in local space.
* A zero-length vector specifies an omni-directional source (cone is ignored).
*/
#define AL_DIRECTION 0x1005
/**
* Source or listener velocity.
* Type: ALfloat[3], ALint[3]
* Default: {0, 0, 0}
*
* Specifies the current velocity in local space.
*/
#define AL_VELOCITY 0x1006
/**
* Source looping.
* Type: ALboolean
* Range: [AL_TRUE, AL_FALSE]
* Default: AL_FALSE
*
* Specifies whether source is looping.
*/
#define AL_LOOPING 0x1007
/**
* Source buffer.
* Type: ALuint
* Range: any valid Buffer.
*
* Specifies the buffer to provide sound samples.
*/
#define AL_BUFFER 0x1009
/**
* Source or listener gain.
* Type: ALfloat
* Range: [0.0 - ]
*
* A value of 1.0 means unattenuated. Each division by 2 equals an attenuation
* of about -6dB. Each multiplicaton by 2 equals an amplification of about
* +6dB.
*
* A value of 0.0 is meaningless with respect to a logarithmic scale; it is
* silent.
*/
#define AL_GAIN 0x100A
/**
* Minimum source gain.
* Type: ALfloat
* Range: [0.0 - 1.0]
*
* The minimum gain allowed for a source, after distance and cone attenation is
* applied (if applicable).
*/
#define AL_MIN_GAIN 0x100D
/**
* Maximum source gain.
* Type: ALfloat
* Range: [0.0 - 1.0]
*
* The maximum gain allowed for a source, after distance and cone attenation is
* applied (if applicable).
*/
#define AL_MAX_GAIN 0x100E
/**
* Listener orientation.
* Type: ALfloat[6]
* Default: {0.0, 0.0, -1.0, 0.0, 1.0, 0.0}
*
* Effectively two three dimensional vectors. The first vector is the front (or
* "at") and the second is the top (or "up").
*
* Both vectors are in local space.
*/
#define AL_ORIENTATION 0x100F
/**
* Source state (query only).
* Type: ALint
* Range: [AL_INITIAL, AL_PLAYING, AL_PAUSED, AL_STOPPED]
*/
#define AL_SOURCE_STATE 0x1010
/** Source state value. */
#define AL_INITIAL 0x1011
#define AL_PLAYING 0x1012
#define AL_PAUSED 0x1013
#define AL_STOPPED 0x1014
/**
* Source Buffer Queue size (query only).
* Type: ALint
*
* The number of buffers queued using alSourceQueueBuffers, minus the buffers
* removed with alSourceUnqueueBuffers.
*/
#define AL_BUFFERS_QUEUED 0x1015
/**
* Source Buffer Queue processed count (query only).
* Type: ALint
*
* The number of queued buffers that have been fully processed, and can be
* removed with alSourceUnqueueBuffers.
*
* Looping sources will never fully process buffers because they will be set to
* play again for when the source loops.
*/
#define AL_BUFFERS_PROCESSED 0x1016
/**
* Source reference distance.
* Type: ALfloat
* Range: [0.0 - ]
* Default: 1.0
*
* The distance in units that no attenuation occurs.
*
* At 0.0, no distance attenuation ever occurs on non-linear attenuation models.
*/
#define AL_REFERENCE_DISTANCE 0x1020
/**
* Source rolloff factor.
* Type: ALfloat
* Range: [0.0 - ]
* Default: 1.0
*
* Multiplier to exaggerate or diminish distance attenuation.
*
* At 0.0, no distance attenuation ever occurs.
*/
#define AL_ROLLOFF_FACTOR 0x1021
/**
* Outer cone gain.
* Type: ALfloat
* Range: [0.0 - 1.0]
* Default: 0.0
*
* The gain attenuation applied when the listener is outside of the source's
* outer cone.
*/
#define AL_CONE_OUTER_GAIN 0x1022
/**
* Source maximum distance.
* Type: ALfloat
* Range: [0.0 - ]
* Default: +inf
*
* 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
* distance models with a default rolloff factor.
*/
#define AL_MAX_DISTANCE 0x1023
/** Source buffer position, in seconds */
#define AL_SEC_OFFSET 0x1024
/** Source buffer position, in sample frames */
#define AL_SAMPLE_OFFSET 0x1025
/** Source buffer position, in bytes */
#define AL_BYTE_OFFSET 0x1026
/**
* Source type (query only).
* Type: ALint
* Range: [AL_STATIC, AL_STREAMING, AL_UNDETERMINED]
*
* A Source is Static if a Buffer has been attached using AL_BUFFER.
*
* A Source is Streaming if one or more Buffers have been attached using
* alSourceQueueBuffers.
*
* A Source is Undetermined when it has the NULL buffer attached using
* AL_BUFFER.
*/
#define AL_SOURCE_TYPE 0x1027
/** Source type value. */
#define AL_STATIC 0x1028
#define AL_STREAMING 0x1029
#define AL_UNDETERMINED 0x1030
/** Buffer format specifier. */
#define AL_FORMAT_MONO8 0x1100
#define AL_FORMAT_MONO16 0x1101
#define AL_FORMAT_STEREO8 0x1102
#define AL_FORMAT_STEREO16 0x1103
/** Buffer frequency (query only). */
#define AL_FREQUENCY 0x2001
/** Buffer bits per sample (query only). */
#define AL_BITS 0x2002
/** Buffer channel count (query only). */
#define AL_CHANNELS 0x2003
/** Buffer data size (query only). */
#define AL_SIZE 0x2004
/**
* Buffer state.
*
* Not for public use.
*/
#define AL_UNUSED 0x2010
#define AL_PENDING 0x2011
#define AL_PROCESSED 0x2012
/** No error. */
#define AL_NO_ERROR 0
/** Invalid name paramater passed to AL call. */
#define AL_INVALID_NAME 0xA001
/** Invalid enum parameter passed to AL call. */
#define AL_INVALID_ENUM 0xA002
/** Invalid value parameter passed to AL call. */
#define AL_INVALID_VALUE 0xA003
/** Illegal AL call. */
#define AL_INVALID_OPERATION 0xA004
/** Not enough memory. */
#define AL_OUT_OF_MEMORY 0xA005
/** Context string: Vendor ID. */
#define AL_VENDOR 0xB001
/** Context string: Version. */
#define AL_VERSION 0xB002
/** Context string: Renderer ID. */
#define AL_RENDERER 0xB003
/** Context string: Space-separated extension list. */
#define AL_EXTENSIONS 0xB004
/**
* Doppler scale.
* Type: ALfloat
* Range: [0.0 - ]
* Default: 1.0
*
* Scale for source and listener velocities.
*/
#define AL_DOPPLER_FACTOR 0xC000
AL_API void AL_APIENTRY alDopplerFactor(ALfloat value);
/**
* Doppler velocity (deprecated).
*
* A multiplier applied to the Speed of Sound.
*/
#define AL_DOPPLER_VELOCITY 0xC001
AL_API void AL_APIENTRY alDopplerVelocity(ALfloat value);
/**
* Speed of Sound, in units per second.
* Type: ALfloat
* Range: [0.0001 - ]
* Default: 343.3
*
* The speed at which sound waves are assumed to travel, when calculating the
* doppler effect.
*/
#define AL_SPEED_OF_SOUND 0xC003
AL_API void AL_APIENTRY alSpeedOfSound(ALfloat value);
/**
* Distance attenuation model.
* Type: ALint
* Range: [AL_NONE, AL_INVERSE_DISTANCE, AL_INVERSE_DISTANCE_CLAMPED,
* AL_LINEAR_DISTANCE, AL_LINEAR_DISTANCE_CLAMPED,
* AL_EXPONENT_DISTANCE, AL_EXPONENT_DISTANCE_CLAMPED]
* Default: AL_INVERSE_DISTANCE_CLAMPED
*
* The model by which sources attenuate with distance.
*
* None - No distance attenuation.
* Inverse - Doubling the distance halves the source gain.
* Linear - Linear gain scaling between the reference and max distances.
* Exponent - Exponential gain dropoff.
*
* Clamped variations work like the non-clamped counterparts, except the
* distance calculated is clamped between the reference and max distances.
*/
#define AL_DISTANCE_MODEL 0xD000
AL_API void AL_APIENTRY alDistanceModel(ALenum distanceModel);
/** Distance model value. */
#define AL_INVERSE_DISTANCE 0xD001
#define AL_INVERSE_DISTANCE_CLAMPED 0xD002
#define AL_LINEAR_DISTANCE 0xD003
#define AL_LINEAR_DISTANCE_CLAMPED 0xD004
#define AL_EXPONENT_DISTANCE 0xD005
#define AL_EXPONENT_DISTANCE_CLAMPED 0xD006
/** 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. */
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);
AL_API void AL_APIENTRY alGetFloatv(ALenum param, ALfloat *values);
AL_API void AL_APIENTRY alGetDoublev(ALenum param, ALdouble *values);
AL_API ALboolean AL_APIENTRY alGetBoolean(ALenum param);
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.
*/
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.
*/
AL_API ALboolean AL_APIENTRY alIsExtensionPresent(const ALchar *extname);
AL_API void* AL_APIENTRY alGetProcAddress(const ALchar *fname);
AL_API ALenum AL_APIENTRY alGetEnumValue(const ALchar *ename);
/** 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);
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 */
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);
AL_API void AL_APIENTRY alGetListeneri(ALenum param, ALint *value);
AL_API void AL_APIENTRY alGetListener3i(ALenum param, ALint *value1, ALint *value2, ALint *value3);
AL_API void AL_APIENTRY alGetListeneriv(ALenum param, ALint *values);
/** Create Source objects. */
AL_API void AL_APIENTRY alGenSources(ALsizei n, ALuint *sources);
/** Delete Source objects. */
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. */
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);
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. */
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);
AL_API void AL_APIENTRY alGetSourcei(ALuint source, ALenum param, ALint *value);
AL_API void AL_APIENTRY alGetSource3i(ALuint source, ALenum param, ALint *value1, ALint *value2, ALint *value3);
AL_API void AL_APIENTRY alGetSourceiv(ALuint source, ALenum param, ALint *values);
/** Play, replay, or resume (if paused) a list of Sources */
AL_API void AL_APIENTRY alSourcePlayv(ALsizei n, const ALuint *sources);
/** Stop a list of Sources */
AL_API void AL_APIENTRY alSourceStopv(ALsizei n, const ALuint *sources);
/** Rewind a list of Sources */
AL_API void AL_APIENTRY alSourceRewindv(ALsizei n, const ALuint *sources);
/** Pause a list of Sources */
AL_API void AL_APIENTRY alSourcePausev(ALsizei n, const ALuint *sources);
/** Play, replay, or resume a Source */
AL_API void AL_APIENTRY alSourcePlay(ALuint source);
/** Stop a Source */
AL_API void AL_APIENTRY alSourceStop(ALuint source);
/** Rewind a Source (set playback postiton to beginning) */
AL_API void AL_APIENTRY alSourceRewind(ALuint source);
/** Pause a Source */
AL_API void AL_APIENTRY alSourcePause(ALuint source);
/** Queue buffers onto a source */
AL_API void AL_APIENTRY alSourceQueueBuffers(ALuint source, ALsizei nb, const ALuint *buffers);
/** Unqueue processed buffers from a source */
AL_API void AL_APIENTRY alSourceUnqueueBuffers(ALuint source, ALsizei nb, ALuint *buffers);
/** Create Buffer objects */
AL_API void AL_APIENTRY alGenBuffers(ALsizei n, ALuint *buffers);
/** Delete Buffer objects */
AL_API void AL_APIENTRY alDeleteBuffers(ALsizei n, const ALuint *buffers);
/** Verify a handle is a valid Buffer */
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, */
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);
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. */
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);
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. */
typedef void (AL_APIENTRY *LPALENABLE)(ALenum capability);
typedef void (AL_APIENTRY *LPALDISABLE)(ALenum capability);
typedef ALboolean (AL_APIENTRY *LPALISENABLED)(ALenum capability);
typedef const ALchar* (AL_APIENTRY *LPALGETSTRING)(ALenum param);
typedef void (AL_APIENTRY *LPALGETBOOLEANV)(ALenum param, ALboolean *values);
typedef void (AL_APIENTRY *LPALGETINTEGERV)(ALenum param, ALint *values);
typedef void (AL_APIENTRY *LPALGETFLOATV)(ALenum param, ALfloat *values);
typedef void (AL_APIENTRY *LPALGETDOUBLEV)(ALenum param, ALdouble *values);
typedef ALboolean (AL_APIENTRY *LPALGETBOOLEAN)(ALenum param);
typedef ALint (AL_APIENTRY *LPALGETINTEGER)(ALenum param);
typedef ALfloat (AL_APIENTRY *LPALGETFLOAT)(ALenum param);
typedef ALdouble (AL_APIENTRY *LPALGETDOUBLE)(ALenum param);
typedef ALenum (AL_APIENTRY *LPALGETERROR)(void);
typedef ALboolean (AL_APIENTRY *LPALISEXTENSIONPRESENT)(const ALchar *extname);
typedef void* (AL_APIENTRY *LPALGETPROCADDRESS)(const ALchar *fname);
typedef ALenum (AL_APIENTRY *LPALGETENUMVALUE)(const ALchar *ename);
typedef void (AL_APIENTRY *LPALLISTENERF)(ALenum param, ALfloat value);
typedef void (AL_APIENTRY *LPALLISTENER3F)(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
typedef void (AL_APIENTRY *LPALLISTENERFV)(ALenum param, const ALfloat *values);
typedef void (AL_APIENTRY *LPALLISTENERI)(ALenum param, ALint value);
typedef void (AL_APIENTRY *LPALLISTENER3I)(ALenum param, ALint value1, ALint value2, ALint value3);
typedef void (AL_APIENTRY *LPALLISTENERIV)(ALenum param, const ALint *values);
typedef void (AL_APIENTRY *LPALGETLISTENERF)(ALenum param, ALfloat *value);
typedef void (AL_APIENTRY *LPALGETLISTENER3F)(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
typedef void (AL_APIENTRY *LPALGETLISTENERFV)(ALenum param, ALfloat *values);
typedef void (AL_APIENTRY *LPALGETLISTENERI)(ALenum param, ALint *value);
typedef void (AL_APIENTRY *LPALGETLISTENER3I)(ALenum param, ALint *value1, ALint *value2, ALint *value3);
typedef void (AL_APIENTRY *LPALGETLISTENERIV)(ALenum param, ALint *values);
typedef void (AL_APIENTRY *LPALGENSOURCES)(ALsizei n, ALuint *sources);
typedef void (AL_APIENTRY *LPALDELETESOURCES)(ALsizei n, const ALuint *sources);
typedef ALboolean (AL_APIENTRY *LPALISSOURCE)(ALuint source);
typedef void (AL_APIENTRY *LPALSOURCEF)(ALuint source, ALenum param, ALfloat value);
typedef void (AL_APIENTRY *LPALSOURCE3F)(ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
typedef void (AL_APIENTRY *LPALSOURCEFV)(ALuint source, ALenum param, const ALfloat *values);
typedef void (AL_APIENTRY *LPALSOURCEI)(ALuint source, ALenum param, ALint value);
typedef void (AL_APIENTRY *LPALSOURCE3I)(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3);
typedef void (AL_APIENTRY *LPALSOURCEIV)(ALuint source, ALenum param, const ALint *values);
typedef void (AL_APIENTRY *LPALGETSOURCEF)(ALuint source, ALenum param, ALfloat *value);
typedef void (AL_APIENTRY *LPALGETSOURCE3F)(ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
typedef void (AL_APIENTRY *LPALGETSOURCEFV)(ALuint source, ALenum param, ALfloat *values);
typedef void (AL_APIENTRY *LPALGETSOURCEI)(ALuint source, ALenum param, ALint *value);
typedef void (AL_APIENTRY *LPALGETSOURCE3I)(ALuint source, ALenum param, ALint *value1, ALint *value2, ALint *value3);
typedef void (AL_APIENTRY *LPALGETSOURCEIV)(ALuint source, ALenum param, ALint *values);
typedef void (AL_APIENTRY *LPALSOURCEPLAYV)(ALsizei n, const ALuint *sources);
typedef void (AL_APIENTRY *LPALSOURCESTOPV)(ALsizei n, const ALuint *sources);
typedef void (AL_APIENTRY *LPALSOURCEREWINDV)(ALsizei n, const ALuint *sources);
typedef void (AL_APIENTRY *LPALSOURCEPAUSEV)(ALsizei n, const ALuint *sources);
typedef void (AL_APIENTRY *LPALSOURCEPLAY)(ALuint source);
typedef void (AL_APIENTRY *LPALSOURCESTOP)(ALuint source);
typedef void (AL_APIENTRY *LPALSOURCEREWIND)(ALuint source);
typedef void (AL_APIENTRY *LPALSOURCEPAUSE)(ALuint source);
typedef void (AL_APIENTRY *LPALSOURCEQUEUEBUFFERS)(ALuint source, ALsizei nb, const ALuint *buffers);
typedef void (AL_APIENTRY *LPALSOURCEUNQUEUEBUFFERS)(ALuint source, ALsizei nb, ALuint *buffers);
typedef void (AL_APIENTRY *LPALGENBUFFERS)(ALsizei n, ALuint *buffers);
typedef void (AL_APIENTRY *LPALDELETEBUFFERS)(ALsizei n, const ALuint *buffers);
typedef ALboolean (AL_APIENTRY *LPALISBUFFER)(ALuint buffer);
typedef void (AL_APIENTRY *LPALBUFFERDATA)(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei freq);
typedef void (AL_APIENTRY *LPALBUFFERF)(ALuint buffer, ALenum param, ALfloat value);
typedef void (AL_APIENTRY *LPALBUFFER3F)(ALuint buffer, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
typedef void (AL_APIENTRY *LPALBUFFERFV)(ALuint buffer, ALenum param, const ALfloat *values);
typedef void (AL_APIENTRY *LPALBUFFERI)(ALuint buffer, ALenum param, ALint value);
typedef void (AL_APIENTRY *LPALBUFFER3I)(ALuint buffer, ALenum param, ALint value1, ALint value2, ALint value3);
typedef void (AL_APIENTRY *LPALBUFFERIV)(ALuint buffer, ALenum param, const ALint *values);
typedef void (AL_APIENTRY *LPALGETBUFFERF)(ALuint buffer, ALenum param, ALfloat *value);
typedef void (AL_APIENTRY *LPALGETBUFFER3F)(ALuint buffer, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
typedef void (AL_APIENTRY *LPALGETBUFFERFV)(ALuint buffer, ALenum param, ALfloat *values);
typedef void (AL_APIENTRY *LPALGETBUFFERI)(ALuint buffer, ALenum param, ALint *value);
typedef void (AL_APIENTRY *LPALGETBUFFER3I)(ALuint buffer, ALenum param, ALint *value1, ALint *value2, ALint *value3);
typedef void (AL_APIENTRY *LPALGETBUFFERIV)(ALuint buffer, ALenum param, ALint *values);
typedef void (AL_APIENTRY *LPALDOPPLERFACTOR)(ALfloat value);
typedef void (AL_APIENTRY *LPALDOPPLERVELOCITY)(ALfloat value);
typedef void (AL_APIENTRY *LPALSPEEDOFSOUND)(ALfloat value);
typedef void (AL_APIENTRY *LPALDISTANCEMODEL)(ALenum distanceModel);
#if defined(__cplusplus)
} /* extern "C" */
#endif
#endif /* AL_AL_H */

237
extlibs/headers/AL/alc.h vendored
View File

@ -1,237 +0,0 @@
#ifndef AL_ALC_H
#define AL_ALC_H
#if defined(__cplusplus)
extern "C" {
#endif
#ifndef ALC_API
#if defined(AL_LIBTYPE_STATIC)
#define ALC_API
#elif defined(_WIN32)
#define ALC_API __declspec(dllimport)
#else
#define ALC_API extern
#endif
#endif
#if defined(_WIN32)
#define ALC_APIENTRY __cdecl
#else
#define ALC_APIENTRY
#endif
/** Deprecated macro. */
#define ALCAPI ALC_API
#define ALCAPIENTRY ALC_APIENTRY
#define ALC_INVALID 0
/** Supported ALC version? */
#define ALC_VERSION_0_1 1
/** Opaque device handle */
typedef struct ALCdevice_struct ALCdevice;
/** Opaque context handle */
typedef struct ALCcontext_struct ALCcontext;
/** 8-bit boolean */
typedef char ALCboolean;
/** character */
typedef char ALCchar;
/** signed 8-bit 2's complement integer */
typedef signed char ALCbyte;
/** unsigned 8-bit integer */
typedef unsigned char ALCubyte;
/** signed 16-bit 2's complement integer */
typedef short ALCshort;
/** unsigned 16-bit integer */
typedef unsigned short ALCushort;
/** signed 32-bit 2's complement integer */
typedef int ALCint;
/** unsigned 32-bit integer */
typedef unsigned int ALCuint;
/** non-negative 32-bit binary integer size */
typedef int ALCsizei;
/** enumerated 32-bit value */
typedef int ALCenum;
/** 32-bit IEEE754 floating-point */
typedef float ALCfloat;
/** 64-bit IEEE754 floating-point */
typedef double ALCdouble;
/** void type (for opaque pointers only) */
typedef void ALCvoid;
/* Enumerant values begin at column 50. No tabs. */
/** Boolean False. */
#define ALC_FALSE 0
/** Boolean True. */
#define ALC_TRUE 1
/** Context attribute: <int> Hz. */
#define ALC_FREQUENCY 0x1007
/** Context attribute: <int> Hz. */
#define ALC_REFRESH 0x1008
/** Context attribute: AL_TRUE or AL_FALSE. */
#define ALC_SYNC 0x1009
/** Context attribute: <int> requested Mono (3D) Sources. */
#define ALC_MONO_SOURCES 0x1010
/** Context attribute: <int> requested Stereo Sources. */
#define ALC_STEREO_SOURCES 0x1011
/** No error. */
#define ALC_NO_ERROR 0
/** Invalid device handle. */
#define ALC_INVALID_DEVICE 0xA001
/** Invalid context handle. */
#define ALC_INVALID_CONTEXT 0xA002
/** Invalid enum parameter passed to an ALC call. */
#define ALC_INVALID_ENUM 0xA003
/** Invalid value parameter passed to an ALC call. */
#define ALC_INVALID_VALUE 0xA004
/** Out of memory. */
#define ALC_OUT_OF_MEMORY 0xA005
/** Runtime ALC version. */
#define ALC_MAJOR_VERSION 0x1000
#define ALC_MINOR_VERSION 0x1001
/** Context attribute list properties. */
#define ALC_ATTRIBUTES_SIZE 0x1002
#define ALC_ALL_ATTRIBUTES 0x1003
/** String for the default device specifier. */
#define ALC_DEFAULT_DEVICE_SPECIFIER 0x1004
/**
* String for the given device's specifier.
*
* If device handle is NULL, it is instead a null-char separated list of
* strings of known device specifiers (list ends with an empty string).
*/
#define ALC_DEVICE_SPECIFIER 0x1005
/** String for space-separated list of ALC extensions. */
#define ALC_EXTENSIONS 0x1006
/** Capture extension */
#define ALC_EXT_CAPTURE 1
/**
* String for the given capture device's specifier.
*
* If device handle is NULL, it is instead a null-char separated list of
* strings of known capture device specifiers (list ends with an empty string).
*/
#define ALC_CAPTURE_DEVICE_SPECIFIER 0x310
/** String for the default capture device specifier. */
#define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER 0x311
/** Number of sample frames available for capture. */
#define ALC_CAPTURE_SAMPLES 0x312
/** Enumerate All extension */
#define ALC_ENUMERATE_ALL_EXT 1
/** String for the default extended device specifier. */
#define ALC_DEFAULT_ALL_DEVICES_SPECIFIER 0x1012
/**
* String for the given extended device's specifier.
*
* If device handle is NULL, it is instead a null-char separated list of
* strings of known extended device specifiers (list ends with an empty string).
*/
#define ALC_ALL_DEVICES_SPECIFIER 0x1013
/** Context management. */
ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint* attrlist);
ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context);
ALC_API void ALC_APIENTRY alcProcessContext(ALCcontext *context);
ALC_API void ALC_APIENTRY alcSuspendContext(ALCcontext *context);
ALC_API void ALC_APIENTRY alcDestroyContext(ALCcontext *context);
ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(void);
ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice(ALCcontext *context);
/** Device management. */
ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *devicename);
ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *device);
/**
* Error support.
*
* Obtain the most recent Device error.
*/
ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device);
/**
* Extension support.
*
* Query for the presence of an extension, and obtain any appropriate
* function pointers and enum values.
*/
ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extname);
ALC_API void* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcname);
ALC_API ALCenum ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumname);
/** Query function. */
ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *device, ALCenum param);
ALC_API void ALC_APIENTRY alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values);
/** Capture function. */
ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize);
ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *device);
ALC_API void ALC_APIENTRY alcCaptureStart(ALCdevice *device);
ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device);
ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples);
/** 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);
typedef void (ALC_APIENTRY *LPALCSUSPENDCONTEXT)(ALCcontext *context);
typedef void (ALC_APIENTRY *LPALCDESTROYCONTEXT)(ALCcontext *context);
typedef ALCcontext* (ALC_APIENTRY *LPALCGETCURRENTCONTEXT)(void);
typedef ALCdevice* (ALC_APIENTRY *LPALCGETCONTEXTSDEVICE)(ALCcontext *context);
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 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);
typedef ALCdevice* (ALC_APIENTRY *LPALCCAPTUREOPENDEVICE)(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize);
typedef ALCboolean (ALC_APIENTRY *LPALCCAPTURECLOSEDEVICE)(ALCdevice *device);
typedef void (ALC_APIENTRY *LPALCCAPTURESTART)(ALCdevice *device);
typedef void (ALC_APIENTRY *LPALCCAPTURESTOP)(ALCdevice *device);
typedef void (ALC_APIENTRY *LPALCCAPTURESAMPLES)(ALCdevice *device, ALCvoid *buffer, ALCsizei samples);
#if defined(__cplusplus)
}
#endif
#endif /* AL_ALC_H */

355
extlibs/headers/AL/alext.h vendored
View File

@ -1,355 +0,0 @@
/**
* OpenAL cross platform audio library
* Copyright (C) 2008 by authors.
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
* Or go to http://www.gnu.org/copyleft/lgpl.html
*/
#ifndef AL_ALEXT_H
#define AL_ALEXT_H
#include <stddef.h>
/* Define int64_t and uint64_t types */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
#include <inttypes.h>
#elif defined(_WIN32) && defined(__GNUC__)
#include <stdint.h>
#elif defined(_WIN32)
typedef __int64 int64_t;
typedef unsigned __int64 uint64_t;
#else
/* Fallback if nothing above works */
#include <inttypes.h>
#endif
#include "alc.h"
#include "al.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifndef AL_LOKI_IMA_ADPCM_format
#define AL_LOKI_IMA_ADPCM_format 1
#define AL_FORMAT_IMA_ADPCM_MONO16_EXT 0x10000
#define AL_FORMAT_IMA_ADPCM_STEREO16_EXT 0x10001
#endif
#ifndef AL_LOKI_WAVE_format
#define AL_LOKI_WAVE_format 1
#define AL_FORMAT_WAVE_EXT 0x10002
#endif
#ifndef AL_EXT_vorbis
#define AL_EXT_vorbis 1
#define AL_FORMAT_VORBIS_EXT 0x10003
#endif
#ifndef AL_LOKI_quadriphonic
#define AL_LOKI_quadriphonic 1
#define AL_FORMAT_QUAD8_LOKI 0x10004
#define AL_FORMAT_QUAD16_LOKI 0x10005
#endif
#ifndef AL_EXT_float32
#define AL_EXT_float32 1
#define AL_FORMAT_MONO_FLOAT32 0x10010
#define AL_FORMAT_STEREO_FLOAT32 0x10011
#endif
#ifndef AL_EXT_double
#define AL_EXT_double 1
#define AL_FORMAT_MONO_DOUBLE_EXT 0x10012
#define AL_FORMAT_STEREO_DOUBLE_EXT 0x10013
#endif
#ifndef AL_EXT_MULAW
#define AL_EXT_MULAW 1
#define AL_FORMAT_MONO_MULAW_EXT 0x10014
#define AL_FORMAT_STEREO_MULAW_EXT 0x10015
#endif
#ifndef AL_EXT_ALAW
#define AL_EXT_ALAW 1
#define AL_FORMAT_MONO_ALAW_EXT 0x10016
#define AL_FORMAT_STEREO_ALAW_EXT 0x10017
#endif
#ifndef ALC_LOKI_audio_channel
#define ALC_LOKI_audio_channel 1
#define ALC_CHAN_MAIN_LOKI 0x500001
#define ALC_CHAN_PCM_LOKI 0x500002
#define ALC_CHAN_CD_LOKI 0x500003
#endif
#ifndef AL_EXT_MCFORMATS
#define AL_EXT_MCFORMATS 1
#define AL_FORMAT_QUAD8 0x1204
#define AL_FORMAT_QUAD16 0x1205
#define AL_FORMAT_QUAD32 0x1206
#define AL_FORMAT_REAR8 0x1207
#define AL_FORMAT_REAR16 0x1208
#define AL_FORMAT_REAR32 0x1209
#define AL_FORMAT_51CHN8 0x120A
#define AL_FORMAT_51CHN16 0x120B
#define AL_FORMAT_51CHN32 0x120C
#define AL_FORMAT_61CHN8 0x120D
#define AL_FORMAT_61CHN16 0x120E
#define AL_FORMAT_61CHN32 0x120F
#define AL_FORMAT_71CHN8 0x1210
#define AL_FORMAT_71CHN16 0x1211
#define AL_FORMAT_71CHN32 0x1212
#endif
#ifndef AL_EXT_MULAW_MCFORMATS
#define AL_EXT_MULAW_MCFORMATS 1
#define AL_FORMAT_MONO_MULAW 0x10014
#define AL_FORMAT_STEREO_MULAW 0x10015
#define AL_FORMAT_QUAD_MULAW 0x10021
#define AL_FORMAT_REAR_MULAW 0x10022
#define AL_FORMAT_51CHN_MULAW 0x10023
#define AL_FORMAT_61CHN_MULAW 0x10024
#define AL_FORMAT_71CHN_MULAW 0x10025
#endif
#ifndef AL_EXT_IMA4
#define AL_EXT_IMA4 1
#define AL_FORMAT_MONO_IMA4 0x1300
#define AL_FORMAT_STEREO_IMA4 0x1301
#endif
#ifndef AL_EXT_STATIC_BUFFER
#define AL_EXT_STATIC_BUFFER 1
typedef ALvoid (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);
#endif
#endif
#ifndef ALC_EXT_EFX
#define ALC_EXT_EFX 1
#include "efx.h"
#endif
#ifndef ALC_EXT_disconnect
#define ALC_EXT_disconnect 1
#define ALC_CONNECTED 0x313
#endif
#ifndef ALC_EXT_thread_local_context
#define ALC_EXT_thread_local_context 1
typedef ALCboolean (ALC_APIENTRY*PFNALCSETTHREADCONTEXTPROC)(ALCcontext *context);
typedef ALCcontext* (ALC_APIENTRY*PFNALCGETTHREADCONTEXTPROC)(void);
#ifdef AL_ALEXT_PROTOTYPES
ALC_API ALCboolean ALC_APIENTRY alcSetThreadContext(ALCcontext *context);
ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void);
#endif
#endif
#ifndef AL_EXT_source_distance_model
#define AL_EXT_source_distance_model 1
#define AL_SOURCE_DISTANCE_MODEL 0x200
#endif
#ifndef AL_SOFT_buffer_sub_data
#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);
#ifdef AL_ALEXT_PROTOTYPES
AL_API ALvoid AL_APIENTRY alBufferSubDataSOFT(ALuint buffer,ALenum format,const ALvoid *data,ALsizei offset,ALsizei length);
#endif
#endif
#ifndef AL_SOFT_loop_points
#define AL_SOFT_loop_points 1
#define AL_LOOP_POINTS_SOFT 0x2015
#endif
#ifndef AL_EXT_FOLDBACK
#define AL_EXT_FOLDBACK 1
#define AL_EXT_FOLDBACK_NAME "AL_EXT_FOLDBACK"
#define AL_FOLDBACK_EVENT_BLOCK 0x4112
#define AL_FOLDBACK_EVENT_START 0x4111
#define AL_FOLDBACK_EVENT_STOP 0x4113
#define AL_FOLDBACK_MODE_MONO 0x4101
#define AL_FOLDBACK_MODE_STEREO 0x4102
typedef void (AL_APIENTRY*LPALFOLDBACKCALLBACK)(ALenum,ALsizei);
typedef void (AL_APIENTRY*LPALREQUESTFOLDBACKSTART)(ALenum,ALsizei,ALsizei,ALfloat*,LPALFOLDBACKCALLBACK);
typedef void (AL_APIENTRY*LPALREQUESTFOLDBACKSTOP)(void);
#ifdef AL_ALEXT_PROTOTYPES
AL_API void AL_APIENTRY alRequestFoldbackStart(ALenum mode,ALsizei count,ALsizei length,ALfloat *mem,LPALFOLDBACKCALLBACK callback);
AL_API void AL_APIENTRY alRequestFoldbackStop(void);
#endif
#endif
#ifndef ALC_EXT_DEDICATED
#define ALC_EXT_DEDICATED 1
#define AL_DEDICATED_GAIN 0x0001
#define AL_EFFECT_DEDICATED_DIALOGUE 0x9001
#define AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT 0x9000
#endif
#ifndef AL_SOFT_buffer_samples
#define AL_SOFT_buffer_samples 1
/* Channel configurations */
#define AL_MONO_SOFT 0x1500
#define AL_STEREO_SOFT 0x1501
#define AL_REAR_SOFT 0x1502
#define AL_QUAD_SOFT 0x1503
#define AL_5POINT1_SOFT 0x1504
#define AL_6POINT1_SOFT 0x1505
#define AL_7POINT1_SOFT 0x1506
/* Sample types */
#define AL_BYTE_SOFT 0x1400
#define AL_UNSIGNED_BYTE_SOFT 0x1401
#define AL_SHORT_SOFT 0x1402
#define AL_UNSIGNED_SHORT_SOFT 0x1403
#define AL_INT_SOFT 0x1404
#define AL_UNSIGNED_INT_SOFT 0x1405
#define AL_FLOAT_SOFT 0x1406
#define AL_DOUBLE_SOFT 0x1407
#define AL_BYTE3_SOFT 0x1408
#define AL_UNSIGNED_BYTE3_SOFT 0x1409
/* Storage formats */
#define AL_MONO8_SOFT 0x1100
#define AL_MONO16_SOFT 0x1101
#define AL_MONO32F_SOFT 0x10010
#define AL_STEREO8_SOFT 0x1102
#define AL_STEREO16_SOFT 0x1103
#define AL_STEREO32F_SOFT 0x10011
#define AL_QUAD8_SOFT 0x1204
#define AL_QUAD16_SOFT 0x1205
#define AL_QUAD32F_SOFT 0x1206
#define AL_REAR8_SOFT 0x1207
#define AL_REAR16_SOFT 0x1208
#define AL_REAR32F_SOFT 0x1209
#define AL_5POINT1_8_SOFT 0x120A
#define AL_5POINT1_16_SOFT 0x120B
#define AL_5POINT1_32F_SOFT 0x120C
#define AL_6POINT1_8_SOFT 0x120D
#define AL_6POINT1_16_SOFT 0x120E
#define AL_6POINT1_32F_SOFT 0x120F
#define AL_7POINT1_8_SOFT 0x1210
#define AL_7POINT1_16_SOFT 0x1211
#define AL_7POINT1_32F_SOFT 0x1212
/* Buffer attributes */
#define AL_INTERNAL_FORMAT_SOFT 0x2008
#define AL_BYTE_LENGTH_SOFT 0x2009
#define AL_SAMPLE_LENGTH_SOFT 0x200A
#define AL_SEC_LENGTH_SOFT 0x200B
typedef void (AL_APIENTRY*LPALBUFFERSAMPLESSOFT)(ALuint,ALuint,ALenum,ALsizei,ALenum,ALenum,const ALvoid*);
typedef void (AL_APIENTRY*LPALBUFFERSUBSAMPLESSOFT)(ALuint,ALsizei,ALsizei,ALenum,ALenum,const ALvoid*);
typedef void (AL_APIENTRY*LPALGETBUFFERSAMPLESSOFT)(ALuint,ALsizei,ALsizei,ALenum,ALenum,ALvoid*);
typedef ALboolean (AL_APIENTRY*LPALISBUFFERFORMATSUPPORTEDSOFT)(ALenum);
#ifdef AL_ALEXT_PROTOTYPES
AL_API void AL_APIENTRY alBufferSamplesSOFT(ALuint buffer, ALuint samplerate, ALenum internalformat, ALsizei samples, ALenum channels, ALenum type, const ALvoid *data);
AL_API void AL_APIENTRY alBufferSubSamplesSOFT(ALuint buffer, ALsizei offset, ALsizei samples, ALenum channels, ALenum type, const ALvoid *data);
AL_API void AL_APIENTRY alGetBufferSamplesSOFT(ALuint buffer, ALsizei offset, ALsizei samples, ALenum channels, ALenum type, ALvoid *data);
AL_API ALboolean AL_APIENTRY alIsBufferFormatSupportedSOFT(ALenum format);
#endif
#endif
#ifndef AL_SOFT_direct_channels
#define AL_SOFT_direct_channels 1
#define AL_DIRECT_CHANNELS_SOFT 0x1033
#endif
#ifndef ALC_SOFT_loopback
#define ALC_SOFT_loopback 1
#define ALC_FORMAT_CHANNELS_SOFT 0x1990
#define ALC_FORMAT_TYPE_SOFT 0x1991
/* Sample types */
#define ALC_BYTE_SOFT 0x1400
#define ALC_UNSIGNED_BYTE_SOFT 0x1401
#define ALC_SHORT_SOFT 0x1402
#define ALC_UNSIGNED_SHORT_SOFT 0x1403
#define ALC_INT_SOFT 0x1404
#define ALC_UNSIGNED_INT_SOFT 0x1405
#define ALC_FLOAT_SOFT 0x1406
/* Channel configurations */
#define ALC_MONO_SOFT 0x1500
#define ALC_STEREO_SOFT 0x1501
#define ALC_QUAD_SOFT 0x1503
#define ALC_5POINT1_SOFT 0x1504
#define ALC_6POINT1_SOFT 0x1505
#define ALC_7POINT1_SOFT 0x1506
typedef ALCdevice* (ALC_APIENTRY*LPALCLOOPBACKOPENDEVICESOFT)(const ALCchar*);
typedef ALCboolean (ALC_APIENTRY*LPALCISRENDERFORMATSUPPORTEDSOFT)(ALCdevice*,ALCsizei,ALCenum,ALCenum);
typedef void (ALC_APIENTRY*LPALCRENDERSAMPLESSOFT)(ALCdevice*,ALCvoid*,ALCsizei);
#ifdef AL_ALEXT_PROTOTYPES
ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(const ALCchar *deviceName);
ALC_API ALCboolean ALC_APIENTRY alcIsRenderFormatSupportedSOFT(ALCdevice *device, ALCsizei freq, ALCenum channels, ALCenum type);
ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffer, ALCsizei samples);
#endif
#endif
#ifndef AL_EXT_STEREO_ANGLES
#define AL_EXT_STEREO_ANGLES 1
#define AL_STEREO_ANGLES 0x1030
#endif
#ifndef AL_EXT_SOURCE_RADIUS
#define AL_EXT_SOURCE_RADIUS 1
#define AL_SOURCE_RADIUS 0x1031
#endif
#ifndef AL_SOFT_source_latency
#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 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*);
typedef void (AL_APIENTRY*LPALGETSOURCEDSOFT)(ALuint,ALenum,ALdouble*);
typedef void (AL_APIENTRY*LPALGETSOURCE3DSOFT)(ALuint,ALenum,ALdouble*,ALdouble*,ALdouble*);
typedef void (AL_APIENTRY*LPALGETSOURCEDVSOFT)(ALuint,ALenum,ALdouble*);
typedef void (AL_APIENTRY*LPALSOURCEI64SOFT)(ALuint,ALenum,ALint64SOFT);
typedef void (AL_APIENTRY*LPALSOURCE3I64SOFT)(ALuint,ALenum,ALint64SOFT,ALint64SOFT,ALint64SOFT);
typedef void (AL_APIENTRY*LPALSOURCEI64VSOFT)(ALuint,ALenum,const ALint64SOFT*);
typedef void (AL_APIENTRY*LPALGETSOURCEI64SOFT)(ALuint,ALenum,ALint64SOFT*);
typedef void (AL_APIENTRY*LPALGETSOURCE3I64SOFT)(ALuint,ALenum,ALint64SOFT*,ALint64SOFT*,ALint64SOFT*);
typedef void (AL_APIENTRY*LPALGETSOURCEI64VSOFT)(ALuint,ALenum,ALint64SOFT*);
#ifdef AL_ALEXT_PROTOTYPES
AL_API void AL_APIENTRY alSourcedSOFT(ALuint source, ALenum param, ALdouble value);
AL_API void AL_APIENTRY alSource3dSOFT(ALuint source, ALenum param, ALdouble value1, ALdouble value2, ALdouble value3);
AL_API void AL_APIENTRY alSourcedvSOFT(ALuint source, ALenum param, const ALdouble *values);
AL_API void AL_APIENTRY alGetSourcedSOFT(ALuint source, ALenum param, ALdouble *value);
AL_API void AL_APIENTRY alGetSource3dSOFT(ALuint source, ALenum param, ALdouble *value1, ALdouble *value2, ALdouble *value3);
AL_API void AL_APIENTRY alGetSourcedvSOFT(ALuint source, ALenum param, ALdouble *values);
AL_API void AL_APIENTRY alSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT value);
AL_API void AL_APIENTRY alSource3i64SOFT(ALuint source, ALenum param, ALint64SOFT value1, ALint64SOFT value2, ALint64SOFT value3);
AL_API void AL_APIENTRY alSourcei64vSOFT(ALuint source, ALenum param, const ALint64SOFT *values);
AL_API void AL_APIENTRY alGetSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT *value);
AL_API void AL_APIENTRY alGetSource3i64SOFT(ALuint source, ALenum param, ALint64SOFT *value1, ALint64SOFT *value2, ALint64SOFT *value3);
AL_API void AL_APIENTRY alGetSourcei64vSOFT(ALuint source, ALenum param, ALint64SOFT *values);
#endif
#endif
#ifdef __cplusplus
}
#endif
#endif

3
extlibs/headers/AL/efx-creative.h vendored
View File

@ -1,3 +0,0 @@
/* The tokens that would be defined here are already defined in efx.h. This
* empty file is here to provide compatibility with Windows-based projects
* that would include it. */

402
extlibs/headers/AL/efx-presets.h vendored
View File

@ -1,402 +0,0 @@
/* Reverb presets for EFX */
#ifndef EFX_PRESETS_H
#define EFX_PRESETS_H
#ifndef EFXEAXREVERBPROPERTIES_DEFINED
#define EFXEAXREVERBPROPERTIES_DEFINED
typedef struct {
float flDensity;
float flDiffusion;
float flGain;
float flGainHF;
float flGainLF;
float flDecayTime;
float flDecayHFRatio;
float flDecayLFRatio;
float flReflectionsGain;
float flReflectionsDelay;
float flReflectionsPan[3];
float flLateReverbGain;
float flLateReverbDelay;
float flLateReverbPan[3];
float flEchoTime;
float flEchoDepth;
float flModulationTime;
float flModulationDepth;
float flAirAbsorptionGainHF;
float flHFReference;
float flLFReference;
float flRoomRolloffFactor;
int iDecayHFLimit;
} EFXEAXREVERBPROPERTIES, *LPEFXEAXREVERBPROPERTIES;
#endif
/* Default Presets */
#define EFX_REVERB_PRESET_GENERIC \
{ 1.0000f, 1.0000f, 0.3162f, 0.8913f, 1.0000f, 1.4900f, 0.8300f, 1.0000f, 0.0500f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_PADDEDCELL \
{ 0.1715f, 1.0000f, 0.3162f, 0.0010f, 1.0000f, 0.1700f, 0.1000f, 1.0000f, 0.2500f, 0.0010f, { 0.0000f, 0.0000f, 0.0000f }, 1.2691f, 0.0020f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_ROOM \
{ 0.4287f, 1.0000f, 0.3162f, 0.5929f, 1.0000f, 0.4000f, 0.8300f, 1.0000f, 0.1503f, 0.0020f, { 0.0000f, 0.0000f, 0.0000f }, 1.0629f, 0.0030f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_BATHROOM \
{ 0.1715f, 1.0000f, 0.3162f, 0.2512f, 1.0000f, 1.4900f, 0.5400f, 1.0000f, 0.6531f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 3.2734f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_LIVINGROOM \
{ 0.9766f, 1.0000f, 0.3162f, 0.0010f, 1.0000f, 0.5000f, 0.1000f, 1.0000f, 0.2051f, 0.0030f, { 0.0000f, 0.0000f, 0.0000f }, 0.2805f, 0.0040f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_STONEROOM \
{ 1.0000f, 1.0000f, 0.3162f, 0.7079f, 1.0000f, 2.3100f, 0.6400f, 1.0000f, 0.4411f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.1003f, 0.0170f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_AUDITORIUM \
{ 1.0000f, 1.0000f, 0.3162f, 0.5781f, 1.0000f, 4.3200f, 0.5900f, 1.0000f, 0.4032f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 0.7170f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_CONCERTHALL \
{ 1.0000f, 1.0000f, 0.3162f, 0.5623f, 1.0000f, 3.9200f, 0.7000f, 1.0000f, 0.2427f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 0.9977f, 0.0290f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_CAVE \
{ 1.0000f, 1.0000f, 0.3162f, 1.0000f, 1.0000f, 2.9100f, 1.3000f, 1.0000f, 0.5000f, 0.0150f, { 0.0000f, 0.0000f, 0.0000f }, 0.7063f, 0.0220f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_ARENA \
{ 1.0000f, 1.0000f, 0.3162f, 0.4477f, 1.0000f, 7.2400f, 0.3300f, 1.0000f, 0.2612f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 1.0186f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_HANGAR \
{ 1.0000f, 1.0000f, 0.3162f, 0.3162f, 1.0000f, 10.0500f, 0.2300f, 1.0000f, 0.5000f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 1.2560f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_CARPETEDHALLWAY \
{ 0.4287f, 1.0000f, 0.3162f, 0.0100f, 1.0000f, 0.3000f, 0.1000f, 1.0000f, 0.1215f, 0.0020f, { 0.0000f, 0.0000f, 0.0000f }, 0.1531f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_HALLWAY \
{ 0.3645f, 1.0000f, 0.3162f, 0.7079f, 1.0000f, 1.4900f, 0.5900f, 1.0000f, 0.2458f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.6615f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_STONECORRIDOR \
{ 1.0000f, 1.0000f, 0.3162f, 0.7612f, 1.0000f, 2.7000f, 0.7900f, 1.0000f, 0.2472f, 0.0130f, { 0.0000f, 0.0000f, 0.0000f }, 1.5758f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_ALLEY \
{ 1.0000f, 0.3000f, 0.3162f, 0.7328f, 1.0000f, 1.4900f, 0.8600f, 1.0000f, 0.2500f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 0.9954f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.1250f, 0.9500f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_FOREST \
{ 1.0000f, 0.3000f, 0.3162f, 0.0224f, 1.0000f, 1.4900f, 0.5400f, 1.0000f, 0.0525f, 0.1620f, { 0.0000f, 0.0000f, 0.0000f }, 0.7682f, 0.0880f, { 0.0000f, 0.0000f, 0.0000f }, 0.1250f, 1.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_CITY \
{ 1.0000f, 0.5000f, 0.3162f, 0.3981f, 1.0000f, 1.4900f, 0.6700f, 1.0000f, 0.0730f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 0.1427f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_MOUNTAINS \
{ 1.0000f, 0.2700f, 0.3162f, 0.0562f, 1.0000f, 1.4900f, 0.2100f, 1.0000f, 0.0407f, 0.3000f, { 0.0000f, 0.0000f, 0.0000f }, 0.1919f, 0.1000f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_QUARRY \
{ 1.0000f, 1.0000f, 0.3162f, 0.3162f, 1.0000f, 1.4900f, 0.8300f, 1.0000f, 0.0000f, 0.0610f, { 0.0000f, 0.0000f, 0.0000f }, 1.7783f, 0.0250f, { 0.0000f, 0.0000f, 0.0000f }, 0.1250f, 0.7000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_PLAIN \
{ 1.0000f, 0.2100f, 0.3162f, 0.1000f, 1.0000f, 1.4900f, 0.5000f, 1.0000f, 0.0585f, 0.1790f, { 0.0000f, 0.0000f, 0.0000f }, 0.1089f, 0.1000f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_PARKINGLOT \
{ 1.0000f, 1.0000f, 0.3162f, 1.0000f, 1.0000f, 1.6500f, 1.5000f, 1.0000f, 0.2082f, 0.0080f, { 0.0000f, 0.0000f, 0.0000f }, 0.2652f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_SEWERPIPE \
{ 0.3071f, 0.8000f, 0.3162f, 0.3162f, 1.0000f, 2.8100f, 0.1400f, 1.0000f, 1.6387f, 0.0140f, { 0.0000f, 0.0000f, 0.0000f }, 3.2471f, 0.0210f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_UNDERWATER \
{ 0.3645f, 1.0000f, 0.3162f, 0.0100f, 1.0000f, 1.4900f, 0.1000f, 1.0000f, 0.5963f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 7.0795f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 1.1800f, 0.3480f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_DRUGGED \
{ 0.4287f, 0.5000f, 0.3162f, 1.0000f, 1.0000f, 8.3900f, 1.3900f, 1.0000f, 0.8760f, 0.0020f, { 0.0000f, 0.0000f, 0.0000f }, 3.1081f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 1.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_DIZZY \
{ 0.3645f, 0.6000f, 0.3162f, 0.6310f, 1.0000f, 17.2300f, 0.5600f, 1.0000f, 0.1392f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 0.4937f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.8100f, 0.3100f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_PSYCHOTIC \
{ 0.0625f, 0.5000f, 0.3162f, 0.8404f, 1.0000f, 7.5600f, 0.9100f, 1.0000f, 0.4864f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 2.4378f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 4.0000f, 1.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
/* Castle Presets */
#define EFX_REVERB_PRESET_CASTLE_SMALLROOM \
{ 1.0000f, 0.8900f, 0.3162f, 0.3981f, 0.1000f, 1.2200f, 0.8300f, 0.3100f, 0.8913f, 0.0220f, { 0.0000f, 0.0000f, 0.0000f }, 1.9953f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.1380f, 0.0800f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_CASTLE_SHORTPASSAGE \
{ 1.0000f, 0.8900f, 0.3162f, 0.3162f, 0.1000f, 2.3200f, 0.8300f, 0.3100f, 0.8913f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0230f, { 0.0000f, 0.0000f, 0.0000f }, 0.1380f, 0.0800f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_CASTLE_MEDIUMROOM \
{ 1.0000f, 0.9300f, 0.3162f, 0.2818f, 0.1000f, 2.0400f, 0.8300f, 0.4600f, 0.6310f, 0.0220f, { 0.0000f, 0.0000f, 0.0000f }, 1.5849f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.1550f, 0.0300f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_CASTLE_LARGEROOM \
{ 1.0000f, 0.8200f, 0.3162f, 0.2818f, 0.1259f, 2.5300f, 0.8300f, 0.5000f, 0.4467f, 0.0340f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0160f, { 0.0000f, 0.0000f, 0.0000f }, 0.1850f, 0.0700f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_CASTLE_LONGPASSAGE \
{ 1.0000f, 0.8900f, 0.3162f, 0.3981f, 0.1000f, 3.4200f, 0.8300f, 0.3100f, 0.8913f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0230f, { 0.0000f, 0.0000f, 0.0000f }, 0.1380f, 0.0800f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_CASTLE_HALL \
{ 1.0000f, 0.8100f, 0.3162f, 0.2818f, 0.1778f, 3.1400f, 0.7900f, 0.6200f, 0.1778f, 0.0560f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0240f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_CASTLE_CUPBOARD \
{ 1.0000f, 0.8900f, 0.3162f, 0.2818f, 0.1000f, 0.6700f, 0.8700f, 0.3100f, 1.4125f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 3.5481f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 0.1380f, 0.0800f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_CASTLE_COURTYARD \
{ 1.0000f, 0.4200f, 0.3162f, 0.4467f, 0.1995f, 2.1300f, 0.6100f, 0.2300f, 0.2239f, 0.1600f, { 0.0000f, 0.0000f, 0.0000f }, 0.7079f, 0.0360f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.3700f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_CASTLE_ALCOVE \
{ 1.0000f, 0.8900f, 0.3162f, 0.5012f, 0.1000f, 1.6400f, 0.8700f, 0.3100f, 1.0000f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0340f, { 0.0000f, 0.0000f, 0.0000f }, 0.1380f, 0.0800f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 }
/* Factory Presets */
#define EFX_REVERB_PRESET_FACTORY_SMALLROOM \
{ 0.3645f, 0.8200f, 0.3162f, 0.7943f, 0.5012f, 1.7200f, 0.6500f, 1.3100f, 0.7079f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.7783f, 0.0240f, { 0.0000f, 0.0000f, 0.0000f }, 0.1190f, 0.0700f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_FACTORY_SHORTPASSAGE \
{ 0.3645f, 0.6400f, 0.2512f, 0.7943f, 0.5012f, 2.5300f, 0.6500f, 1.3100f, 1.0000f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0380f, { 0.0000f, 0.0000f, 0.0000f }, 0.1350f, 0.2300f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_FACTORY_MEDIUMROOM \
{ 0.4287f, 0.8200f, 0.2512f, 0.7943f, 0.5012f, 2.7600f, 0.6500f, 1.3100f, 0.2818f, 0.0220f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0230f, { 0.0000f, 0.0000f, 0.0000f }, 0.1740f, 0.0700f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_FACTORY_LARGEROOM \
{ 0.4287f, 0.7500f, 0.2512f, 0.7079f, 0.6310f, 4.2400f, 0.5100f, 1.3100f, 0.1778f, 0.0390f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0230f, { 0.0000f, 0.0000f, 0.0000f }, 0.2310f, 0.0700f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_FACTORY_LONGPASSAGE \
{ 0.3645f, 0.6400f, 0.2512f, 0.7943f, 0.5012f, 4.0600f, 0.6500f, 1.3100f, 1.0000f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0370f, { 0.0000f, 0.0000f, 0.0000f }, 0.1350f, 0.2300f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_FACTORY_HALL \
{ 0.4287f, 0.7500f, 0.3162f, 0.7079f, 0.6310f, 7.4300f, 0.5100f, 1.3100f, 0.0631f, 0.0730f, { 0.0000f, 0.0000f, 0.0000f }, 0.8913f, 0.0270f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0700f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_FACTORY_CUPBOARD \
{ 0.3071f, 0.6300f, 0.2512f, 0.7943f, 0.5012f, 0.4900f, 0.6500f, 1.3100f, 1.2589f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.9953f, 0.0320f, { 0.0000f, 0.0000f, 0.0000f }, 0.1070f, 0.0700f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_FACTORY_COURTYARD \
{ 0.3071f, 0.5700f, 0.3162f, 0.3162f, 0.6310f, 2.3200f, 0.2900f, 0.5600f, 0.2239f, 0.1400f, { 0.0000f, 0.0000f, 0.0000f }, 0.3981f, 0.0390f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.2900f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_FACTORY_ALCOVE \
{ 0.3645f, 0.5900f, 0.2512f, 0.7943f, 0.5012f, 3.1400f, 0.6500f, 1.3100f, 1.4125f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.0000f, 0.0380f, { 0.0000f, 0.0000f, 0.0000f }, 0.1140f, 0.1000f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 }
/* Ice Palace Presets */
#define EFX_REVERB_PRESET_ICEPALACE_SMALLROOM \
{ 1.0000f, 0.8400f, 0.3162f, 0.5623f, 0.2818f, 1.5100f, 1.5300f, 0.2700f, 0.8913f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.1640f, 0.1400f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_ICEPALACE_SHORTPASSAGE \
{ 1.0000f, 0.7500f, 0.3162f, 0.5623f, 0.2818f, 1.7900f, 1.4600f, 0.2800f, 0.5012f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0190f, { 0.0000f, 0.0000f, 0.0000f }, 0.1770f, 0.0900f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_ICEPALACE_MEDIUMROOM \
{ 1.0000f, 0.8700f, 0.3162f, 0.5623f, 0.4467f, 2.2200f, 1.5300f, 0.3200f, 0.3981f, 0.0390f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0270f, { 0.0000f, 0.0000f, 0.0000f }, 0.1860f, 0.1200f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_ICEPALACE_LARGEROOM \
{ 1.0000f, 0.8100f, 0.3162f, 0.5623f, 0.4467f, 3.1400f, 1.5300f, 0.3200f, 0.2512f, 0.0390f, { 0.0000f, 0.0000f, 0.0000f }, 1.0000f, 0.0270f, { 0.0000f, 0.0000f, 0.0000f }, 0.2140f, 0.1100f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_ICEPALACE_LONGPASSAGE \
{ 1.0000f, 0.7700f, 0.3162f, 0.5623f, 0.3981f, 3.0100f, 1.4600f, 0.2800f, 0.7943f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0250f, { 0.0000f, 0.0000f, 0.0000f }, 0.1860f, 0.0400f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_ICEPALACE_HALL \
{ 1.0000f, 0.7600f, 0.3162f, 0.4467f, 0.5623f, 5.4900f, 1.5300f, 0.3800f, 0.1122f, 0.0540f, { 0.0000f, 0.0000f, 0.0000f }, 0.6310f, 0.0520f, { 0.0000f, 0.0000f, 0.0000f }, 0.2260f, 0.1100f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_ICEPALACE_CUPBOARD \
{ 1.0000f, 0.8300f, 0.3162f, 0.5012f, 0.2239f, 0.7600f, 1.5300f, 0.2600f, 1.1220f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.9953f, 0.0160f, { 0.0000f, 0.0000f, 0.0000f }, 0.1430f, 0.0800f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_ICEPALACE_COURTYARD \
{ 1.0000f, 0.5900f, 0.3162f, 0.2818f, 0.3162f, 2.0400f, 1.2000f, 0.3800f, 0.3162f, 0.1730f, { 0.0000f, 0.0000f, 0.0000f }, 0.3162f, 0.0430f, { 0.0000f, 0.0000f, 0.0000f }, 0.2350f, 0.4800f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_ICEPALACE_ALCOVE \
{ 1.0000f, 0.8400f, 0.3162f, 0.5623f, 0.2818f, 2.7600f, 1.4600f, 0.2800f, 1.1220f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 0.8913f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.1610f, 0.0900f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 }
/* Space Station Presets */
#define EFX_REVERB_PRESET_SPACESTATION_SMALLROOM \
{ 0.2109f, 0.7000f, 0.3162f, 0.7079f, 0.8913f, 1.7200f, 0.8200f, 0.5500f, 0.7943f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0130f, { 0.0000f, 0.0000f, 0.0000f }, 0.1880f, 0.2600f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_SPACESTATION_SHORTPASSAGE \
{ 0.2109f, 0.8700f, 0.3162f, 0.6310f, 0.8913f, 3.5700f, 0.5000f, 0.5500f, 1.0000f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0160f, { 0.0000f, 0.0000f, 0.0000f }, 0.1720f, 0.2000f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_SPACESTATION_MEDIUMROOM \
{ 0.2109f, 0.7500f, 0.3162f, 0.6310f, 0.8913f, 3.0100f, 0.5000f, 0.5500f, 0.3981f, 0.0340f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0350f, { 0.0000f, 0.0000f, 0.0000f }, 0.2090f, 0.3100f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_SPACESTATION_LARGEROOM \
{ 0.3645f, 0.8100f, 0.3162f, 0.6310f, 0.8913f, 3.8900f, 0.3800f, 0.6100f, 0.3162f, 0.0560f, { 0.0000f, 0.0000f, 0.0000f }, 0.8913f, 0.0350f, { 0.0000f, 0.0000f, 0.0000f }, 0.2330f, 0.2800f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_SPACESTATION_LONGPASSAGE \
{ 0.4287f, 0.8200f, 0.3162f, 0.6310f, 0.8913f, 4.6200f, 0.6200f, 0.5500f, 1.0000f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0310f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.2300f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_SPACESTATION_HALL \
{ 0.4287f, 0.8700f, 0.3162f, 0.6310f, 0.8913f, 7.1100f, 0.3800f, 0.6100f, 0.1778f, 0.1000f, { 0.0000f, 0.0000f, 0.0000f }, 0.6310f, 0.0470f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.2500f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_SPACESTATION_CUPBOARD \
{ 0.1715f, 0.5600f, 0.3162f, 0.7079f, 0.8913f, 0.7900f, 0.8100f, 0.5500f, 1.4125f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.7783f, 0.0180f, { 0.0000f, 0.0000f, 0.0000f }, 0.1810f, 0.3100f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_SPACESTATION_ALCOVE \
{ 0.2109f, 0.7800f, 0.3162f, 0.7079f, 0.8913f, 1.1600f, 0.8100f, 0.5500f, 1.4125f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.0000f, 0.0180f, { 0.0000f, 0.0000f, 0.0000f }, 0.1920f, 0.2100f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 }
/* Wooden Galleon Presets */
#define EFX_REVERB_PRESET_WOODEN_SMALLROOM \
{ 1.0000f, 1.0000f, 0.3162f, 0.1122f, 0.3162f, 0.7900f, 0.3200f, 0.8700f, 1.0000f, 0.0320f, { 0.0000f, 0.0000f, 0.0000f }, 0.8913f, 0.0290f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_WOODEN_SHORTPASSAGE \
{ 1.0000f, 1.0000f, 0.3162f, 0.1259f, 0.3162f, 1.7500f, 0.5000f, 0.8700f, 0.8913f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 0.6310f, 0.0240f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_WOODEN_MEDIUMROOM \
{ 1.0000f, 1.0000f, 0.3162f, 0.1000f, 0.2818f, 1.4700f, 0.4200f, 0.8200f, 0.8913f, 0.0490f, { 0.0000f, 0.0000f, 0.0000f }, 0.8913f, 0.0290f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_WOODEN_LARGEROOM \
{ 1.0000f, 1.0000f, 0.3162f, 0.0891f, 0.2818f, 2.6500f, 0.3300f, 0.8200f, 0.8913f, 0.0660f, { 0.0000f, 0.0000f, 0.0000f }, 0.7943f, 0.0490f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_WOODEN_LONGPASSAGE \
{ 1.0000f, 1.0000f, 0.3162f, 0.1000f, 0.3162f, 1.9900f, 0.4000f, 0.7900f, 1.0000f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 0.4467f, 0.0360f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_WOODEN_HALL \
{ 1.0000f, 1.0000f, 0.3162f, 0.0794f, 0.2818f, 3.4500f, 0.3000f, 0.8200f, 0.8913f, 0.0880f, { 0.0000f, 0.0000f, 0.0000f }, 0.7943f, 0.0630f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_WOODEN_CUPBOARD \
{ 1.0000f, 1.0000f, 0.3162f, 0.1413f, 0.3162f, 0.5600f, 0.4600f, 0.9100f, 1.1220f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0280f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_WOODEN_COURTYARD \
{ 1.0000f, 0.6500f, 0.3162f, 0.0794f, 0.3162f, 1.7900f, 0.3500f, 0.7900f, 0.5623f, 0.1230f, { 0.0000f, 0.0000f, 0.0000f }, 0.1000f, 0.0320f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_WOODEN_ALCOVE \
{ 1.0000f, 1.0000f, 0.3162f, 0.1259f, 0.3162f, 1.2200f, 0.6200f, 0.9100f, 1.1220f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 0.7079f, 0.0240f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 }
/* Sports Presets */
#define EFX_REVERB_PRESET_SPORT_EMPTYSTADIUM \
{ 1.0000f, 1.0000f, 0.3162f, 0.4467f, 0.7943f, 6.2600f, 0.5100f, 1.1000f, 0.0631f, 0.1830f, { 0.0000f, 0.0000f, 0.0000f }, 0.3981f, 0.0380f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_SPORT_SQUASHCOURT \
{ 1.0000f, 0.7500f, 0.3162f, 0.3162f, 0.7943f, 2.2200f, 0.9100f, 1.1600f, 0.4467f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 0.7943f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.1260f, 0.1900f, 0.2500f, 0.0000f, 0.9943f, 7176.8999f, 211.2000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_SPORT_SMALLSWIMMINGPOOL \
{ 1.0000f, 0.7000f, 0.3162f, 0.7943f, 0.8913f, 2.7600f, 1.2500f, 1.1400f, 0.6310f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 0.7943f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.1790f, 0.1500f, 0.8950f, 0.1900f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_SPORT_LARGESWIMMINGPOOL \
{ 1.0000f, 0.8200f, 0.3162f, 0.7943f, 1.0000f, 5.4900f, 1.3100f, 1.1400f, 0.4467f, 0.0390f, { 0.0000f, 0.0000f, 0.0000f }, 0.5012f, 0.0490f, { 0.0000f, 0.0000f, 0.0000f }, 0.2220f, 0.5500f, 1.1590f, 0.2100f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_SPORT_GYMNASIUM \
{ 1.0000f, 0.8100f, 0.3162f, 0.4467f, 0.8913f, 3.1400f, 1.0600f, 1.3500f, 0.3981f, 0.0290f, { 0.0000f, 0.0000f, 0.0000f }, 0.5623f, 0.0450f, { 0.0000f, 0.0000f, 0.0000f }, 0.1460f, 0.1400f, 0.2500f, 0.0000f, 0.9943f, 7176.8999f, 211.2000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_SPORT_FULLSTADIUM \
{ 1.0000f, 1.0000f, 0.3162f, 0.0708f, 0.7943f, 5.2500f, 0.1700f, 0.8000f, 0.1000f, 0.1880f, { 0.0000f, 0.0000f, 0.0000f }, 0.2818f, 0.0380f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_SPORT_STADIUMTANNOY \
{ 1.0000f, 0.7800f, 0.3162f, 0.5623f, 0.5012f, 2.5300f, 0.8800f, 0.6800f, 0.2818f, 0.2300f, { 0.0000f, 0.0000f, 0.0000f }, 0.5012f, 0.0630f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.2000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
/* Prefab Presets */
#define EFX_REVERB_PRESET_PREFAB_WORKSHOP \
{ 0.4287f, 1.0000f, 0.3162f, 0.1413f, 0.3981f, 0.7600f, 1.0000f, 1.0000f, 1.0000f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_PREFAB_SCHOOLROOM \
{ 0.4022f, 0.6900f, 0.3162f, 0.6310f, 0.5012f, 0.9800f, 0.4500f, 0.1800f, 1.4125f, 0.0170f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0150f, { 0.0000f, 0.0000f, 0.0000f }, 0.0950f, 0.1400f, 0.2500f, 0.0000f, 0.9943f, 7176.8999f, 211.2000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_PREFAB_PRACTISEROOM \
{ 0.4022f, 0.8700f, 0.3162f, 0.3981f, 0.5012f, 1.1200f, 0.5600f, 0.1800f, 1.2589f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.0950f, 0.1400f, 0.2500f, 0.0000f, 0.9943f, 7176.8999f, 211.2000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_PREFAB_OUTHOUSE \
{ 1.0000f, 0.8200f, 0.3162f, 0.1122f, 0.1585f, 1.3800f, 0.3800f, 0.3500f, 0.8913f, 0.0240f, { 0.0000f, 0.0000f, -0.0000f }, 0.6310f, 0.0440f, { 0.0000f, 0.0000f, 0.0000f }, 0.1210f, 0.1700f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 107.5000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_PREFAB_CARAVAN \
{ 1.0000f, 1.0000f, 0.3162f, 0.0891f, 0.1259f, 0.4300f, 1.5000f, 1.0000f, 1.0000f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.9953f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
/* Dome and Pipe Presets */
#define EFX_REVERB_PRESET_DOME_TOMB \
{ 1.0000f, 0.7900f, 0.3162f, 0.3548f, 0.2239f, 4.1800f, 0.2100f, 0.1000f, 0.3868f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 1.6788f, 0.0220f, { 0.0000f, 0.0000f, 0.0000f }, 0.1770f, 0.1900f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 20.0000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_PIPE_SMALL \
{ 1.0000f, 1.0000f, 0.3162f, 0.3548f, 0.2239f, 5.0400f, 0.1000f, 0.1000f, 0.5012f, 0.0320f, { 0.0000f, 0.0000f, 0.0000f }, 2.5119f, 0.0150f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 20.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_DOME_SAINTPAULS \
{ 1.0000f, 0.8700f, 0.3162f, 0.3548f, 0.2239f, 10.4800f, 0.1900f, 0.1000f, 0.1778f, 0.0900f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0420f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.1200f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 20.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_PIPE_LONGTHIN \
{ 0.2560f, 0.9100f, 0.3162f, 0.4467f, 0.2818f, 9.2100f, 0.1800f, 0.1000f, 0.7079f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 0.7079f, 0.0220f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 20.0000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_PIPE_LARGE \
{ 1.0000f, 1.0000f, 0.3162f, 0.3548f, 0.2239f, 8.4500f, 0.1000f, 0.1000f, 0.3981f, 0.0460f, { 0.0000f, 0.0000f, 0.0000f }, 1.5849f, 0.0320f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 20.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_PIPE_RESONANT \
{ 0.1373f, 0.9100f, 0.3162f, 0.4467f, 0.2818f, 6.8100f, 0.1800f, 0.1000f, 0.7079f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.0000f, 0.0220f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 20.0000f, 0.0000f, 0x0 }
/* Outdoors Presets */
#define EFX_REVERB_PRESET_OUTDOORS_BACKYARD \
{ 1.0000f, 0.4500f, 0.3162f, 0.2512f, 0.5012f, 1.1200f, 0.3400f, 0.4600f, 0.4467f, 0.0690f, { 0.0000f, 0.0000f, -0.0000f }, 0.7079f, 0.0230f, { 0.0000f, 0.0000f, 0.0000f }, 0.2180f, 0.3400f, 0.2500f, 0.0000f, 0.9943f, 4399.1001f, 242.9000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_OUTDOORS_ROLLINGPLAINS \
{ 1.0000f, 0.0000f, 0.3162f, 0.0112f, 0.6310f, 2.1300f, 0.2100f, 0.4600f, 0.1778f, 0.3000f, { 0.0000f, 0.0000f, -0.0000f }, 0.4467f, 0.0190f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.2500f, 0.0000f, 0.9943f, 4399.1001f, 242.9000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_OUTDOORS_DEEPCANYON \
{ 1.0000f, 0.7400f, 0.3162f, 0.1778f, 0.6310f, 3.8900f, 0.2100f, 0.4600f, 0.3162f, 0.2230f, { 0.0000f, 0.0000f, -0.0000f }, 0.3548f, 0.0190f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.2500f, 0.0000f, 0.9943f, 4399.1001f, 242.9000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_OUTDOORS_CREEK \
{ 1.0000f, 0.3500f, 0.3162f, 0.1778f, 0.5012f, 2.1300f, 0.2100f, 0.4600f, 0.3981f, 0.1150f, { 0.0000f, 0.0000f, -0.0000f }, 0.1995f, 0.0310f, { 0.0000f, 0.0000f, 0.0000f }, 0.2180f, 0.3400f, 0.2500f, 0.0000f, 0.9943f, 4399.1001f, 242.9000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_OUTDOORS_VALLEY \
{ 1.0000f, 0.2800f, 0.3162f, 0.0282f, 0.1585f, 2.8800f, 0.2600f, 0.3500f, 0.1413f, 0.2630f, { 0.0000f, 0.0000f, -0.0000f }, 0.3981f, 0.1000f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.3400f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 107.5000f, 0.0000f, 0x0 }
/* Mood Presets */
#define EFX_REVERB_PRESET_MOOD_HEAVEN \
{ 1.0000f, 0.9400f, 0.3162f, 0.7943f, 0.4467f, 5.0400f, 1.1200f, 0.5600f, 0.2427f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0290f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0800f, 2.7420f, 0.0500f, 0.9977f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_MOOD_HELL \
{ 1.0000f, 0.5700f, 0.3162f, 0.3548f, 0.4467f, 3.5700f, 0.4900f, 2.0000f, 0.0000f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.1100f, 0.0400f, 2.1090f, 0.5200f, 0.9943f, 5000.0000f, 139.5000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_MOOD_MEMORY \
{ 1.0000f, 0.8500f, 0.3162f, 0.6310f, 0.3548f, 4.0600f, 0.8200f, 0.5600f, 0.0398f, 0.0000f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0000f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.4740f, 0.4500f, 0.9886f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
/* Driving Presets */
#define EFX_REVERB_PRESET_DRIVING_COMMENTATOR \
{ 1.0000f, 0.0000f, 3.1623f, 0.5623f, 0.5012f, 2.4200f, 0.8800f, 0.6800f, 0.1995f, 0.0930f, { 0.0000f, 0.0000f, 0.0000f }, 0.2512f, 0.0170f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.2500f, 0.0000f, 0.9886f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_DRIVING_PITGARAGE \
{ 0.4287f, 0.5900f, 0.3162f, 0.7079f, 0.5623f, 1.7200f, 0.9300f, 0.8700f, 0.5623f, 0.0000f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0160f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.1100f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_DRIVING_INCAR_RACER \
{ 0.0832f, 0.8000f, 0.3162f, 1.0000f, 0.7943f, 0.1700f, 2.0000f, 0.4100f, 1.7783f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 0.7079f, 0.0150f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 10268.2002f, 251.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_DRIVING_INCAR_SPORTS \
{ 0.0832f, 0.8000f, 0.3162f, 0.6310f, 1.0000f, 0.1700f, 0.7500f, 0.4100f, 1.0000f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 0.5623f, 0.0000f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 10268.2002f, 251.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_DRIVING_INCAR_LUXURY \
{ 0.2560f, 1.0000f, 0.3162f, 0.1000f, 0.5012f, 0.1300f, 0.4100f, 0.4600f, 0.7943f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.5849f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 10268.2002f, 251.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_DRIVING_FULLGRANDSTAND \
{ 1.0000f, 1.0000f, 0.3162f, 0.2818f, 0.6310f, 3.0100f, 1.3700f, 1.2800f, 0.3548f, 0.0900f, { 0.0000f, 0.0000f, 0.0000f }, 0.1778f, 0.0490f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 10420.2002f, 250.0000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_DRIVING_EMPTYGRANDSTAND \
{ 1.0000f, 1.0000f, 0.3162f, 1.0000f, 0.7943f, 4.6200f, 1.7500f, 1.4000f, 0.2082f, 0.0900f, { 0.0000f, 0.0000f, 0.0000f }, 0.2512f, 0.0490f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 10420.2002f, 250.0000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_DRIVING_TUNNEL \
{ 1.0000f, 0.8100f, 0.3162f, 0.3981f, 0.8913f, 3.4200f, 0.9400f, 1.3100f, 0.7079f, 0.0510f, { 0.0000f, 0.0000f, 0.0000f }, 0.7079f, 0.0470f, { 0.0000f, 0.0000f, 0.0000f }, 0.2140f, 0.0500f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 155.3000f, 0.0000f, 0x1 }
/* City Presets */
#define EFX_REVERB_PRESET_CITY_STREETS \
{ 1.0000f, 0.7800f, 0.3162f, 0.7079f, 0.8913f, 1.7900f, 1.1200f, 0.9100f, 0.2818f, 0.0460f, { 0.0000f, 0.0000f, 0.0000f }, 0.1995f, 0.0280f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.2000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_CITY_SUBWAY \
{ 1.0000f, 0.7400f, 0.3162f, 0.7079f, 0.8913f, 3.0100f, 1.2300f, 0.9100f, 0.7079f, 0.0460f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0280f, { 0.0000f, 0.0000f, 0.0000f }, 0.1250f, 0.2100f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_CITY_MUSEUM \
{ 1.0000f, 0.8200f, 0.3162f, 0.1778f, 0.1778f, 3.2800f, 1.4000f, 0.5700f, 0.2512f, 0.0390f, { 0.0000f, 0.0000f, -0.0000f }, 0.8913f, 0.0340f, { 0.0000f, 0.0000f, 0.0000f }, 0.1300f, 0.1700f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 107.5000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_CITY_LIBRARY \
{ 1.0000f, 0.8200f, 0.3162f, 0.2818f, 0.0891f, 2.7600f, 0.8900f, 0.4100f, 0.3548f, 0.0290f, { 0.0000f, 0.0000f, -0.0000f }, 0.8913f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 0.1300f, 0.1700f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 107.5000f, 0.0000f, 0x0 }
#define EFX_REVERB_PRESET_CITY_UNDERPASS \
{ 1.0000f, 0.8200f, 0.3162f, 0.4467f, 0.8913f, 3.5700f, 1.1200f, 0.9100f, 0.3981f, 0.0590f, { 0.0000f, 0.0000f, 0.0000f }, 0.8913f, 0.0370f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.1400f, 0.2500f, 0.0000f, 0.9920f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_CITY_ABANDONED \
{ 1.0000f, 0.6900f, 0.3162f, 0.7943f, 0.8913f, 3.2800f, 1.1700f, 0.9100f, 0.4467f, 0.0440f, { 0.0000f, 0.0000f, 0.0000f }, 0.2818f, 0.0240f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.2000f, 0.2500f, 0.0000f, 0.9966f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
/* Misc. Presets */
#define EFX_REVERB_PRESET_DUSTYROOM \
{ 0.3645f, 0.5600f, 0.3162f, 0.7943f, 0.7079f, 1.7900f, 0.3800f, 0.2100f, 0.5012f, 0.0020f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0060f, { 0.0000f, 0.0000f, 0.0000f }, 0.2020f, 0.0500f, 0.2500f, 0.0000f, 0.9886f, 13046.0000f, 163.3000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_CHAPEL \
{ 1.0000f, 0.8400f, 0.3162f, 0.5623f, 1.0000f, 4.6200f, 0.6400f, 1.2300f, 0.4467f, 0.0320f, { 0.0000f, 0.0000f, 0.0000f }, 0.7943f, 0.0490f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.1100f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
#define EFX_REVERB_PRESET_SMALLWATERROOM \
{ 1.0000f, 0.7000f, 0.3162f, 0.4477f, 1.0000f, 1.5100f, 1.2500f, 1.1400f, 0.8913f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.1790f, 0.1500f, 0.8950f, 0.1900f, 0.9920f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
#endif /* EFX_PRESETS_H */

761
extlibs/headers/AL/efx.h vendored
View File

@ -1,761 +0,0 @@
#ifndef AL_EFX_H
#define AL_EFX_H
#include "alc.h"
#include "al.h"
#ifdef __cplusplus
extern "C" {
#endif
#define ALC_EXT_EFX_NAME "ALC_EXT_EFX"
#define ALC_EFX_MAJOR_VERSION 0x20001
#define ALC_EFX_MINOR_VERSION 0x20002
#define ALC_MAX_AUXILIARY_SENDS 0x20003
/* Listener properties. */
#define AL_METERS_PER_UNIT 0x20004
/* Source properties. */
#define AL_DIRECT_FILTER 0x20005
#define AL_AUXILIARY_SEND_FILTER 0x20006
#define AL_AIR_ABSORPTION_FACTOR 0x20007
#define AL_ROOM_ROLLOFF_FACTOR 0x20008
#define AL_CONE_OUTER_GAINHF 0x20009
#define AL_DIRECT_FILTER_GAINHF_AUTO 0x2000A
#define AL_AUXILIARY_SEND_FILTER_GAIN_AUTO 0x2000B
#define AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO 0x2000C
/* Effect properties. */
/* Reverb effect parameters */
#define AL_REVERB_DENSITY 0x0001
#define AL_REVERB_DIFFUSION 0x0002
#define AL_REVERB_GAIN 0x0003
#define AL_REVERB_GAINHF 0x0004
#define AL_REVERB_DECAY_TIME 0x0005
#define AL_REVERB_DECAY_HFRATIO 0x0006
#define AL_REVERB_REFLECTIONS_GAIN 0x0007
#define AL_REVERB_REFLECTIONS_DELAY 0x0008
#define AL_REVERB_LATE_REVERB_GAIN 0x0009
#define AL_REVERB_LATE_REVERB_DELAY 0x000A
#define AL_REVERB_AIR_ABSORPTION_GAINHF 0x000B
#define AL_REVERB_ROOM_ROLLOFF_FACTOR 0x000C
#define AL_REVERB_DECAY_HFLIMIT 0x000D
/* EAX Reverb effect parameters */
#define AL_EAXREVERB_DENSITY 0x0001
#define AL_EAXREVERB_DIFFUSION 0x0002
#define AL_EAXREVERB_GAIN 0x0003
#define AL_EAXREVERB_GAINHF 0x0004
#define AL_EAXREVERB_GAINLF 0x0005
#define AL_EAXREVERB_DECAY_TIME 0x0006
#define AL_EAXREVERB_DECAY_HFRATIO 0x0007
#define AL_EAXREVERB_DECAY_LFRATIO 0x0008
#define AL_EAXREVERB_REFLECTIONS_GAIN 0x0009
#define AL_EAXREVERB_REFLECTIONS_DELAY 0x000A
#define AL_EAXREVERB_REFLECTIONS_PAN 0x000B
#define AL_EAXREVERB_LATE_REVERB_GAIN 0x000C
#define AL_EAXREVERB_LATE_REVERB_DELAY 0x000D
#define AL_EAXREVERB_LATE_REVERB_PAN 0x000E
#define AL_EAXREVERB_ECHO_TIME 0x000F
#define AL_EAXREVERB_ECHO_DEPTH 0x0010
#define AL_EAXREVERB_MODULATION_TIME 0x0011
#define AL_EAXREVERB_MODULATION_DEPTH 0x0012
#define AL_EAXREVERB_AIR_ABSORPTION_GAINHF 0x0013
#define AL_EAXREVERB_HFREFERENCE 0x0014
#define AL_EAXREVERB_LFREFERENCE 0x0015
#define AL_EAXREVERB_ROOM_ROLLOFF_FACTOR 0x0016
#define AL_EAXREVERB_DECAY_HFLIMIT 0x0017
/* Chorus effect parameters */
#define AL_CHORUS_WAVEFORM 0x0001
#define AL_CHORUS_PHASE 0x0002
#define AL_CHORUS_RATE 0x0003
#define AL_CHORUS_DEPTH 0x0004
#define AL_CHORUS_FEEDBACK 0x0005
#define AL_CHORUS_DELAY 0x0006
/* Distortion effect parameters */
#define AL_DISTORTION_EDGE 0x0001
#define AL_DISTORTION_GAIN 0x0002
#define AL_DISTORTION_LOWPASS_CUTOFF 0x0003
#define AL_DISTORTION_EQCENTER 0x0004
#define AL_DISTORTION_EQBANDWIDTH 0x0005
/* Echo effect parameters */
#define AL_ECHO_DELAY 0x0001
#define AL_ECHO_LRDELAY 0x0002
#define AL_ECHO_DAMPING 0x0003
#define AL_ECHO_FEEDBACK 0x0004
#define AL_ECHO_SPREAD 0x0005
/* Flanger effect parameters */
#define AL_FLANGER_WAVEFORM 0x0001
#define AL_FLANGER_PHASE 0x0002
#define AL_FLANGER_RATE 0x0003
#define AL_FLANGER_DEPTH 0x0004
#define AL_FLANGER_FEEDBACK 0x0005
#define AL_FLANGER_DELAY 0x0006
/* Frequency shifter effect parameters */
#define AL_FREQUENCY_SHIFTER_FREQUENCY 0x0001
#define AL_FREQUENCY_SHIFTER_LEFT_DIRECTION 0x0002
#define AL_FREQUENCY_SHIFTER_RIGHT_DIRECTION 0x0003
/* Vocal morpher effect parameters */
#define AL_VOCAL_MORPHER_PHONEMEA 0x0001
#define AL_VOCAL_MORPHER_PHONEMEA_COARSE_TUNING 0x0002
#define AL_VOCAL_MORPHER_PHONEMEB 0x0003
#define AL_VOCAL_MORPHER_PHONEMEB_COARSE_TUNING 0x0004
#define AL_VOCAL_MORPHER_WAVEFORM 0x0005
#define AL_VOCAL_MORPHER_RATE 0x0006
/* Pitchshifter effect parameters */
#define AL_PITCH_SHIFTER_COARSE_TUNE 0x0001
#define AL_PITCH_SHIFTER_FINE_TUNE 0x0002
/* Ringmodulator effect parameters */
#define AL_RING_MODULATOR_FREQUENCY 0x0001
#define AL_RING_MODULATOR_HIGHPASS_CUTOFF 0x0002
#define AL_RING_MODULATOR_WAVEFORM 0x0003
/* Autowah effect parameters */
#define AL_AUTOWAH_ATTACK_TIME 0x0001
#define AL_AUTOWAH_RELEASE_TIME 0x0002
#define AL_AUTOWAH_RESONANCE 0x0003
#define AL_AUTOWAH_PEAK_GAIN 0x0004
/* Compressor effect parameters */
#define AL_COMPRESSOR_ONOFF 0x0001
/* Equalizer effect parameters */
#define AL_EQUALIZER_LOW_GAIN 0x0001
#define AL_EQUALIZER_LOW_CUTOFF 0x0002
#define AL_EQUALIZER_MID1_GAIN 0x0003
#define AL_EQUALIZER_MID1_CENTER 0x0004
#define AL_EQUALIZER_MID1_WIDTH 0x0005
#define AL_EQUALIZER_MID2_GAIN 0x0006
#define AL_EQUALIZER_MID2_CENTER 0x0007
#define AL_EQUALIZER_MID2_WIDTH 0x0008
#define AL_EQUALIZER_HIGH_GAIN 0x0009
#define AL_EQUALIZER_HIGH_CUTOFF 0x000A
/* Effect type */
#define AL_EFFECT_FIRST_PARAMETER 0x0000
#define AL_EFFECT_LAST_PARAMETER 0x8000
#define AL_EFFECT_TYPE 0x8001
/* Effect types, used with the AL_EFFECT_TYPE property */
#define AL_EFFECT_NULL 0x0000
#define AL_EFFECT_REVERB 0x0001
#define AL_EFFECT_CHORUS 0x0002
#define AL_EFFECT_DISTORTION 0x0003
#define AL_EFFECT_ECHO 0x0004
#define AL_EFFECT_FLANGER 0x0005
#define AL_EFFECT_FREQUENCY_SHIFTER 0x0006
#define AL_EFFECT_VOCAL_MORPHER 0x0007
#define AL_EFFECT_PITCH_SHIFTER 0x0008
#define AL_EFFECT_RING_MODULATOR 0x0009
#define AL_EFFECT_AUTOWAH 0x000A
#define AL_EFFECT_COMPRESSOR 0x000B
#define AL_EFFECT_EQUALIZER 0x000C
#define AL_EFFECT_EAXREVERB 0x8000
/* Auxiliary Effect Slot properties. */
#define AL_EFFECTSLOT_EFFECT 0x0001
#define AL_EFFECTSLOT_GAIN 0x0002
#define AL_EFFECTSLOT_AUXILIARY_SEND_AUTO 0x0003
/* NULL Auxiliary Slot ID to disable a source send. */
#define AL_EFFECTSLOT_NULL 0x0000
/* Filter properties. */
/* Lowpass filter parameters */
#define AL_LOWPASS_GAIN 0x0001
#define AL_LOWPASS_GAINHF 0x0002
/* Highpass filter parameters */
#define AL_HIGHPASS_GAIN 0x0001
#define AL_HIGHPASS_GAINLF 0x0002
/* Bandpass filter parameters */
#define AL_BANDPASS_GAIN 0x0001
#define AL_BANDPASS_GAINLF 0x0002
#define AL_BANDPASS_GAINHF 0x0003
/* Filter type */
#define AL_FILTER_FIRST_PARAMETER 0x0000
#define AL_FILTER_LAST_PARAMETER 0x8000
#define AL_FILTER_TYPE 0x8001
/* Filter types, used with the AL_FILTER_TYPE property */
#define AL_FILTER_NULL 0x0000
#define AL_FILTER_LOWPASS 0x0001
#define AL_FILTER_HIGHPASS 0x0002
#define AL_FILTER_BANDPASS 0x0003
/* Effect object function types. */
typedef void (AL_APIENTRY *LPALGENEFFECTS)(ALsizei, ALuint*);
typedef void (AL_APIENTRY *LPALDELETEEFFECTS)(ALsizei, const ALuint*);
typedef ALboolean (AL_APIENTRY *LPALISEFFECT)(ALuint);
typedef void (AL_APIENTRY *LPALEFFECTI)(ALuint, ALenum, ALint);
typedef void (AL_APIENTRY *LPALEFFECTIV)(ALuint, ALenum, const ALint*);
typedef void (AL_APIENTRY *LPALEFFECTF)(ALuint, ALenum, ALfloat);
typedef void (AL_APIENTRY *LPALEFFECTFV)(ALuint, ALenum, const ALfloat*);
typedef void (AL_APIENTRY *LPALGETEFFECTI)(ALuint, ALenum, ALint*);
typedef void (AL_APIENTRY *LPALGETEFFECTIV)(ALuint, ALenum, ALint*);
typedef void (AL_APIENTRY *LPALGETEFFECTF)(ALuint, ALenum, ALfloat*);
typedef void (AL_APIENTRY *LPALGETEFFECTFV)(ALuint, ALenum, ALfloat*);
/* Filter object function types. */
typedef void (AL_APIENTRY *LPALGENFILTERS)(ALsizei, ALuint*);
typedef void (AL_APIENTRY *LPALDELETEFILTERS)(ALsizei, const ALuint*);
typedef ALboolean (AL_APIENTRY *LPALISFILTER)(ALuint);
typedef void (AL_APIENTRY *LPALFILTERI)(ALuint, ALenum, ALint);
typedef void (AL_APIENTRY *LPALFILTERIV)(ALuint, ALenum, const ALint*);
typedef void (AL_APIENTRY *LPALFILTERF)(ALuint, ALenum, ALfloat);
typedef void (AL_APIENTRY *LPALFILTERFV)(ALuint, ALenum, const ALfloat*);
typedef void (AL_APIENTRY *LPALGETFILTERI)(ALuint, ALenum, ALint*);
typedef void (AL_APIENTRY *LPALGETFILTERIV)(ALuint, ALenum, ALint*);
typedef void (AL_APIENTRY *LPALGETFILTERF)(ALuint, ALenum, ALfloat*);
typedef void (AL_APIENTRY *LPALGETFILTERFV)(ALuint, ALenum, ALfloat*);
/* Auxiliary Effect Slot object function types. */
typedef void (AL_APIENTRY *LPALGENAUXILIARYEFFECTSLOTS)(ALsizei, ALuint*);
typedef void (AL_APIENTRY *LPALDELETEAUXILIARYEFFECTSLOTS)(ALsizei, const ALuint*);
typedef ALboolean (AL_APIENTRY *LPALISAUXILIARYEFFECTSLOT)(ALuint);
typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTI)(ALuint, ALenum, ALint);
typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTIV)(ALuint, ALenum, const ALint*);
typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTF)(ALuint, ALenum, ALfloat);
typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTFV)(ALuint, ALenum, const ALfloat*);
typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTI)(ALuint, ALenum, ALint*);
typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTIV)(ALuint, ALenum, ALint*);
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 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 ALvoid AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters);
AL_API ALvoid 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 ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots);
AL_API ALvoid 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);
#endif
/* Filter ranges and defaults. */
/* Lowpass filter */
#define AL_LOWPASS_MIN_GAIN (0.0f)
#define AL_LOWPASS_MAX_GAIN (1.0f)
#define AL_LOWPASS_DEFAULT_GAIN (1.0f)
#define AL_LOWPASS_MIN_GAINHF (0.0f)
#define AL_LOWPASS_MAX_GAINHF (1.0f)
#define AL_LOWPASS_DEFAULT_GAINHF (1.0f)
/* Highpass filter */
#define AL_HIGHPASS_MIN_GAIN (0.0f)
#define AL_HIGHPASS_MAX_GAIN (1.0f)
#define AL_HIGHPASS_DEFAULT_GAIN (1.0f)
#define AL_HIGHPASS_MIN_GAINLF (0.0f)
#define AL_HIGHPASS_MAX_GAINLF (1.0f)
#define AL_HIGHPASS_DEFAULT_GAINLF (1.0f)
/* Bandpass filter */
#define AL_BANDPASS_MIN_GAIN (0.0f)
#define AL_BANDPASS_MAX_GAIN (1.0f)
#define AL_BANDPASS_DEFAULT_GAIN (1.0f)
#define AL_BANDPASS_MIN_GAINHF (0.0f)
#define AL_BANDPASS_MAX_GAINHF (1.0f)
#define AL_BANDPASS_DEFAULT_GAINHF (1.0f)
#define AL_BANDPASS_MIN_GAINLF (0.0f)
#define AL_BANDPASS_MAX_GAINLF (1.0f)
#define AL_BANDPASS_DEFAULT_GAINLF (1.0f)
/* Effect parameter ranges and defaults. */
/* Standard reverb effect */
#define AL_REVERB_MIN_DENSITY (0.0f)
#define AL_REVERB_MAX_DENSITY (1.0f)
#define AL_REVERB_DEFAULT_DENSITY (1.0f)
#define AL_REVERB_MIN_DIFFUSION (0.0f)
#define AL_REVERB_MAX_DIFFUSION (1.0f)
#define AL_REVERB_DEFAULT_DIFFUSION (1.0f)
#define AL_REVERB_MIN_GAIN (0.0f)
#define AL_REVERB_MAX_GAIN (1.0f)
#define AL_REVERB_DEFAULT_GAIN (0.32f)
#define AL_REVERB_MIN_GAINHF (0.0f)
#define AL_REVERB_MAX_GAINHF (1.0f)
#define AL_REVERB_DEFAULT_GAINHF (0.89f)
#define AL_REVERB_MIN_DECAY_TIME (0.1f)
#define AL_REVERB_MAX_DECAY_TIME (20.0f)
#define AL_REVERB_DEFAULT_DECAY_TIME (1.49f)
#define AL_REVERB_MIN_DECAY_HFRATIO (0.1f)
#define AL_REVERB_MAX_DECAY_HFRATIO (2.0f)
#define AL_REVERB_DEFAULT_DECAY_HFRATIO (0.83f)
#define AL_REVERB_MIN_REFLECTIONS_GAIN (0.0f)
#define AL_REVERB_MAX_REFLECTIONS_GAIN (3.16f)
#define AL_REVERB_DEFAULT_REFLECTIONS_GAIN (0.05f)
#define AL_REVERB_MIN_REFLECTIONS_DELAY (0.0f)
#define AL_REVERB_MAX_REFLECTIONS_DELAY (0.3f)
#define AL_REVERB_DEFAULT_REFLECTIONS_DELAY (0.007f)
#define AL_REVERB_MIN_LATE_REVERB_GAIN (0.0f)
#define AL_REVERB_MAX_LATE_REVERB_GAIN (10.0f)
#define AL_REVERB_DEFAULT_LATE_REVERB_GAIN (1.26f)
#define AL_REVERB_MIN_LATE_REVERB_DELAY (0.0f)
#define AL_REVERB_MAX_LATE_REVERB_DELAY (0.1f)
#define AL_REVERB_DEFAULT_LATE_REVERB_DELAY (0.011f)
#define AL_REVERB_MIN_AIR_ABSORPTION_GAINHF (0.892f)
#define AL_REVERB_MAX_AIR_ABSORPTION_GAINHF (1.0f)
#define AL_REVERB_DEFAULT_AIR_ABSORPTION_GAINHF (0.994f)
#define AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR (0.0f)
#define AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR (10.0f)
#define AL_REVERB_DEFAULT_ROOM_ROLLOFF_FACTOR (0.0f)
#define AL_REVERB_MIN_DECAY_HFLIMIT AL_FALSE
#define AL_REVERB_MAX_DECAY_HFLIMIT AL_TRUE
#define AL_REVERB_DEFAULT_DECAY_HFLIMIT AL_TRUE
/* EAX reverb effect */
#define AL_EAXREVERB_MIN_DENSITY (0.0f)
#define AL_EAXREVERB_MAX_DENSITY (1.0f)
#define AL_EAXREVERB_DEFAULT_DENSITY (1.0f)
#define AL_EAXREVERB_MIN_DIFFUSION (0.0f)
#define AL_EAXREVERB_MAX_DIFFUSION (1.0f)
#define AL_EAXREVERB_DEFAULT_DIFFUSION (1.0f)
#define AL_EAXREVERB_MIN_GAIN (0.0f)
#define AL_EAXREVERB_MAX_GAIN (1.0f)
#define AL_EAXREVERB_DEFAULT_GAIN (0.32f)
#define AL_EAXREVERB_MIN_GAINHF (0.0f)
#define AL_EAXREVERB_MAX_GAINHF (1.0f)
#define AL_EAXREVERB_DEFAULT_GAINHF (0.89f)
#define AL_EAXREVERB_MIN_GAINLF (0.0f)
#define AL_EAXREVERB_MAX_GAINLF (1.0f)
#define AL_EAXREVERB_DEFAULT_GAINLF (1.0f)
#define AL_EAXREVERB_MIN_DECAY_TIME (0.1f)
#define AL_EAXREVERB_MAX_DECAY_TIME (20.0f)
#define AL_EAXREVERB_DEFAULT_DECAY_TIME (1.49f)
#define AL_EAXREVERB_MIN_DECAY_HFRATIO (0.1f)
#define AL_EAXREVERB_MAX_DECAY_HFRATIO (2.0f)
#define AL_EAXREVERB_DEFAULT_DECAY_HFRATIO (0.83f)
#define AL_EAXREVERB_MIN_DECAY_LFRATIO (0.1f)
#define AL_EAXREVERB_MAX_DECAY_LFRATIO (2.0f)
#define AL_EAXREVERB_DEFAULT_DECAY_LFRATIO (1.0f)
#define AL_EAXREVERB_MIN_REFLECTIONS_GAIN (0.0f)
#define AL_EAXREVERB_MAX_REFLECTIONS_GAIN (3.16f)
#define AL_EAXREVERB_DEFAULT_REFLECTIONS_GAIN (0.05f)
#define AL_EAXREVERB_MIN_REFLECTIONS_DELAY (0.0f)
#define AL_EAXREVERB_MAX_REFLECTIONS_DELAY (0.3f)
#define AL_EAXREVERB_DEFAULT_REFLECTIONS_DELAY (0.007f)
#define AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ (0.0f)
#define AL_EAXREVERB_MIN_LATE_REVERB_GAIN (0.0f)
#define AL_EAXREVERB_MAX_LATE_REVERB_GAIN (10.0f)
#define AL_EAXREVERB_DEFAULT_LATE_REVERB_GAIN (1.26f)
#define AL_EAXREVERB_MIN_LATE_REVERB_DELAY (0.0f)
#define AL_EAXREVERB_MAX_LATE_REVERB_DELAY (0.1f)
#define AL_EAXREVERB_DEFAULT_LATE_REVERB_DELAY (0.011f)
#define AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ (0.0f)
#define AL_EAXREVERB_MIN_ECHO_TIME (0.075f)
#define AL_EAXREVERB_MAX_ECHO_TIME (0.25f)
#define AL_EAXREVERB_DEFAULT_ECHO_TIME (0.25f)
#define AL_EAXREVERB_MIN_ECHO_DEPTH (0.0f)
#define AL_EAXREVERB_MAX_ECHO_DEPTH (1.0f)
#define AL_EAXREVERB_DEFAULT_ECHO_DEPTH (0.0f)
#define AL_EAXREVERB_MIN_MODULATION_TIME (0.04f)
#define AL_EAXREVERB_MAX_MODULATION_TIME (4.0f)
#define AL_EAXREVERB_DEFAULT_MODULATION_TIME (0.25f)
#define AL_EAXREVERB_MIN_MODULATION_DEPTH (0.0f)
#define AL_EAXREVERB_MAX_MODULATION_DEPTH (1.0f)
#define AL_EAXREVERB_DEFAULT_MODULATION_DEPTH (0.0f)
#define AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF (0.892f)
#define AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF (1.0f)
#define AL_EAXREVERB_DEFAULT_AIR_ABSORPTION_GAINHF (0.994f)
#define AL_EAXREVERB_MIN_HFREFERENCE (1000.0f)
#define AL_EAXREVERB_MAX_HFREFERENCE (20000.0f)
#define AL_EAXREVERB_DEFAULT_HFREFERENCE (5000.0f)
#define AL_EAXREVERB_MIN_LFREFERENCE (20.0f)
#define AL_EAXREVERB_MAX_LFREFERENCE (1000.0f)
#define AL_EAXREVERB_DEFAULT_LFREFERENCE (250.0f)
#define AL_EAXREVERB_MIN_ROOM_ROLLOFF_FACTOR (0.0f)
#define AL_EAXREVERB_MAX_ROOM_ROLLOFF_FACTOR (10.0f)
#define AL_EAXREVERB_DEFAULT_ROOM_ROLLOFF_FACTOR (0.0f)
#define AL_EAXREVERB_MIN_DECAY_HFLIMIT AL_FALSE
#define AL_EAXREVERB_MAX_DECAY_HFLIMIT AL_TRUE
#define AL_EAXREVERB_DEFAULT_DECAY_HFLIMIT AL_TRUE
/* Chorus effect */
#define AL_CHORUS_WAVEFORM_SINUSOID (0)
#define AL_CHORUS_WAVEFORM_TRIANGLE (1)
#define AL_CHORUS_MIN_WAVEFORM (0)
#define AL_CHORUS_MAX_WAVEFORM (1)
#define AL_CHORUS_DEFAULT_WAVEFORM (1)
#define AL_CHORUS_MIN_PHASE (-180)
#define AL_CHORUS_MAX_PHASE (180)
#define AL_CHORUS_DEFAULT_PHASE (90)
#define AL_CHORUS_MIN_RATE (0.0f)
#define AL_CHORUS_MAX_RATE (10.0f)
#define AL_CHORUS_DEFAULT_RATE (1.1f)
#define AL_CHORUS_MIN_DEPTH (0.0f)
#define AL_CHORUS_MAX_DEPTH (1.0f)
#define AL_CHORUS_DEFAULT_DEPTH (0.1f)
#define AL_CHORUS_MIN_FEEDBACK (-1.0f)
#define AL_CHORUS_MAX_FEEDBACK (1.0f)
#define AL_CHORUS_DEFAULT_FEEDBACK (0.25f)
#define AL_CHORUS_MIN_DELAY (0.0f)
#define AL_CHORUS_MAX_DELAY (0.016f)
#define AL_CHORUS_DEFAULT_DELAY (0.016f)
/* Distortion effect */
#define AL_DISTORTION_MIN_EDGE (0.0f)
#define AL_DISTORTION_MAX_EDGE (1.0f)
#define AL_DISTORTION_DEFAULT_EDGE (0.2f)
#define AL_DISTORTION_MIN_GAIN (0.01f)
#define AL_DISTORTION_MAX_GAIN (1.0f)
#define AL_DISTORTION_DEFAULT_GAIN (0.05f)
#define AL_DISTORTION_MIN_LOWPASS_CUTOFF (80.0f)
#define AL_DISTORTION_MAX_LOWPASS_CUTOFF (24000.0f)
#define AL_DISTORTION_DEFAULT_LOWPASS_CUTOFF (8000.0f)
#define AL_DISTORTION_MIN_EQCENTER (80.0f)
#define AL_DISTORTION_MAX_EQCENTER (24000.0f)
#define AL_DISTORTION_DEFAULT_EQCENTER (3600.0f)
#define AL_DISTORTION_MIN_EQBANDWIDTH (80.0f)
#define AL_DISTORTION_MAX_EQBANDWIDTH (24000.0f)
#define AL_DISTORTION_DEFAULT_EQBANDWIDTH (3600.0f)
/* Echo effect */
#define AL_ECHO_MIN_DELAY (0.0f)
#define AL_ECHO_MAX_DELAY (0.207f)
#define AL_ECHO_DEFAULT_DELAY (0.1f)
#define AL_ECHO_MIN_LRDELAY (0.0f)
#define AL_ECHO_MAX_LRDELAY (0.404f)
#define AL_ECHO_DEFAULT_LRDELAY (0.1f)
#define AL_ECHO_MIN_DAMPING (0.0f)
#define AL_ECHO_MAX_DAMPING (0.99f)
#define AL_ECHO_DEFAULT_DAMPING (0.5f)
#define AL_ECHO_MIN_FEEDBACK (0.0f)
#define AL_ECHO_MAX_FEEDBACK (1.0f)
#define AL_ECHO_DEFAULT_FEEDBACK (0.5f)
#define AL_ECHO_MIN_SPREAD (-1.0f)
#define AL_ECHO_MAX_SPREAD (1.0f)
#define AL_ECHO_DEFAULT_SPREAD (-1.0f)
/* Flanger effect */
#define AL_FLANGER_WAVEFORM_SINUSOID (0)
#define AL_FLANGER_WAVEFORM_TRIANGLE (1)
#define AL_FLANGER_MIN_WAVEFORM (0)
#define AL_FLANGER_MAX_WAVEFORM (1)
#define AL_FLANGER_DEFAULT_WAVEFORM (1)
#define AL_FLANGER_MIN_PHASE (-180)
#define AL_FLANGER_MAX_PHASE (180)
#define AL_FLANGER_DEFAULT_PHASE (0)
#define AL_FLANGER_MIN_RATE (0.0f)
#define AL_FLANGER_MAX_RATE (10.0f)
#define AL_FLANGER_DEFAULT_RATE (0.27f)
#define AL_FLANGER_MIN_DEPTH (0.0f)
#define AL_FLANGER_MAX_DEPTH (1.0f)
#define AL_FLANGER_DEFAULT_DEPTH (1.0f)
#define AL_FLANGER_MIN_FEEDBACK (-1.0f)
#define AL_FLANGER_MAX_FEEDBACK (1.0f)
#define AL_FLANGER_DEFAULT_FEEDBACK (-0.5f)
#define AL_FLANGER_MIN_DELAY (0.0f)
#define AL_FLANGER_MAX_DELAY (0.004f)
#define AL_FLANGER_DEFAULT_DELAY (0.002f)
/* Frequency shifter effect */
#define AL_FREQUENCY_SHIFTER_MIN_FREQUENCY (0.0f)
#define AL_FREQUENCY_SHIFTER_MAX_FREQUENCY (24000.0f)
#define AL_FREQUENCY_SHIFTER_DEFAULT_FREQUENCY (0.0f)
#define AL_FREQUENCY_SHIFTER_MIN_LEFT_DIRECTION (0)
#define AL_FREQUENCY_SHIFTER_MAX_LEFT_DIRECTION (2)
#define AL_FREQUENCY_SHIFTER_DEFAULT_LEFT_DIRECTION (0)
#define AL_FREQUENCY_SHIFTER_DIRECTION_DOWN (0)
#define AL_FREQUENCY_SHIFTER_DIRECTION_UP (1)
#define AL_FREQUENCY_SHIFTER_DIRECTION_OFF (2)
#define AL_FREQUENCY_SHIFTER_MIN_RIGHT_DIRECTION (0)
#define AL_FREQUENCY_SHIFTER_MAX_RIGHT_DIRECTION (2)
#define AL_FREQUENCY_SHIFTER_DEFAULT_RIGHT_DIRECTION (0)
/* Vocal morpher effect */
#define AL_VOCAL_MORPHER_MIN_PHONEMEA (0)
#define AL_VOCAL_MORPHER_MAX_PHONEMEA (29)
#define AL_VOCAL_MORPHER_DEFAULT_PHONEMEA (0)
#define AL_VOCAL_MORPHER_MIN_PHONEMEA_COARSE_TUNING (-24)
#define AL_VOCAL_MORPHER_MAX_PHONEMEA_COARSE_TUNING (24)
#define AL_VOCAL_MORPHER_DEFAULT_PHONEMEA_COARSE_TUNING (0)
#define AL_VOCAL_MORPHER_MIN_PHONEMEB (0)
#define AL_VOCAL_MORPHER_MAX_PHONEMEB (29)
#define AL_VOCAL_MORPHER_DEFAULT_PHONEMEB (10)
#define AL_VOCAL_MORPHER_MIN_PHONEMEB_COARSE_TUNING (-24)
#define AL_VOCAL_MORPHER_MAX_PHONEMEB_COARSE_TUNING (24)
#define AL_VOCAL_MORPHER_DEFAULT_PHONEMEB_COARSE_TUNING (0)
#define AL_VOCAL_MORPHER_PHONEME_A (0)
#define AL_VOCAL_MORPHER_PHONEME_E (1)
#define AL_VOCAL_MORPHER_PHONEME_I (2)
#define AL_VOCAL_MORPHER_PHONEME_O (3)
#define AL_VOCAL_MORPHER_PHONEME_U (4)
#define AL_VOCAL_MORPHER_PHONEME_AA (5)
#define AL_VOCAL_MORPHER_PHONEME_AE (6)
#define AL_VOCAL_MORPHER_PHONEME_AH (7)
#define AL_VOCAL_MORPHER_PHONEME_AO (8)
#define AL_VOCAL_MORPHER_PHONEME_EH (9)
#define AL_VOCAL_MORPHER_PHONEME_ER (10)
#define AL_VOCAL_MORPHER_PHONEME_IH (11)
#define AL_VOCAL_MORPHER_PHONEME_IY (12)
#define AL_VOCAL_MORPHER_PHONEME_UH (13)
#define AL_VOCAL_MORPHER_PHONEME_UW (14)
#define AL_VOCAL_MORPHER_PHONEME_B (15)
#define AL_VOCAL_MORPHER_PHONEME_D (16)
#define AL_VOCAL_MORPHER_PHONEME_F (17)
#define AL_VOCAL_MORPHER_PHONEME_G (18)
#define AL_VOCAL_MORPHER_PHONEME_J (19)
#define AL_VOCAL_MORPHER_PHONEME_K (20)
#define AL_VOCAL_MORPHER_PHONEME_L (21)
#define AL_VOCAL_MORPHER_PHONEME_M (22)
#define AL_VOCAL_MORPHER_PHONEME_N (23)
#define AL_VOCAL_MORPHER_PHONEME_P (24)
#define AL_VOCAL_MORPHER_PHONEME_R (25)
#define AL_VOCAL_MORPHER_PHONEME_S (26)
#define AL_VOCAL_MORPHER_PHONEME_T (27)
#define AL_VOCAL_MORPHER_PHONEME_V (28)
#define AL_VOCAL_MORPHER_PHONEME_Z (29)
#define AL_VOCAL_MORPHER_WAVEFORM_SINUSOID (0)
#define AL_VOCAL_MORPHER_WAVEFORM_TRIANGLE (1)
#define AL_VOCAL_MORPHER_WAVEFORM_SAWTOOTH (2)
#define AL_VOCAL_MORPHER_MIN_WAVEFORM (0)
#define AL_VOCAL_MORPHER_MAX_WAVEFORM (2)
#define AL_VOCAL_MORPHER_DEFAULT_WAVEFORM (0)
#define AL_VOCAL_MORPHER_MIN_RATE (0.0f)
#define AL_VOCAL_MORPHER_MAX_RATE (10.0f)
#define AL_VOCAL_MORPHER_DEFAULT_RATE (1.41f)
/* Pitch shifter effect */
#define AL_PITCH_SHIFTER_MIN_COARSE_TUNE (-12)
#define AL_PITCH_SHIFTER_MAX_COARSE_TUNE (12)
#define AL_PITCH_SHIFTER_DEFAULT_COARSE_TUNE (12)
#define AL_PITCH_SHIFTER_MIN_FINE_TUNE (-50)
#define AL_PITCH_SHIFTER_MAX_FINE_TUNE (50)
#define AL_PITCH_SHIFTER_DEFAULT_FINE_TUNE (0)
/* Ring modulator effect */
#define AL_RING_MODULATOR_MIN_FREQUENCY (0.0f)
#define AL_RING_MODULATOR_MAX_FREQUENCY (8000.0f)
#define AL_RING_MODULATOR_DEFAULT_FREQUENCY (440.0f)
#define AL_RING_MODULATOR_MIN_HIGHPASS_CUTOFF (0.0f)
#define AL_RING_MODULATOR_MAX_HIGHPASS_CUTOFF (24000.0f)
#define AL_RING_MODULATOR_DEFAULT_HIGHPASS_CUTOFF (800.0f)
#define AL_RING_MODULATOR_SINUSOID (0)
#define AL_RING_MODULATOR_SAWTOOTH (1)
#define AL_RING_MODULATOR_SQUARE (2)
#define AL_RING_MODULATOR_MIN_WAVEFORM (0)
#define AL_RING_MODULATOR_MAX_WAVEFORM (2)
#define AL_RING_MODULATOR_DEFAULT_WAVEFORM (0)
/* Autowah effect */
#define AL_AUTOWAH_MIN_ATTACK_TIME (0.0001f)
#define AL_AUTOWAH_MAX_ATTACK_TIME (1.0f)
#define AL_AUTOWAH_DEFAULT_ATTACK_TIME (0.06f)
#define AL_AUTOWAH_MIN_RELEASE_TIME (0.0001f)
#define AL_AUTOWAH_MAX_RELEASE_TIME (1.0f)
#define AL_AUTOWAH_DEFAULT_RELEASE_TIME (0.06f)
#define AL_AUTOWAH_MIN_RESONANCE (2.0f)
#define AL_AUTOWAH_MAX_RESONANCE (1000.0f)
#define AL_AUTOWAH_DEFAULT_RESONANCE (1000.0f)
#define AL_AUTOWAH_MIN_PEAK_GAIN (0.00003f)
#define AL_AUTOWAH_MAX_PEAK_GAIN (31621.0f)
#define AL_AUTOWAH_DEFAULT_PEAK_GAIN (11.22f)
/* Compressor effect */
#define AL_COMPRESSOR_MIN_ONOFF (0)
#define AL_COMPRESSOR_MAX_ONOFF (1)
#define AL_COMPRESSOR_DEFAULT_ONOFF (1)
/* Equalizer effect */
#define AL_EQUALIZER_MIN_LOW_GAIN (0.126f)
#define AL_EQUALIZER_MAX_LOW_GAIN (7.943f)
#define AL_EQUALIZER_DEFAULT_LOW_GAIN (1.0f)
#define AL_EQUALIZER_MIN_LOW_CUTOFF (50.0f)
#define AL_EQUALIZER_MAX_LOW_CUTOFF (800.0f)
#define AL_EQUALIZER_DEFAULT_LOW_CUTOFF (200.0f)
#define AL_EQUALIZER_MIN_MID1_GAIN (0.126f)
#define AL_EQUALIZER_MAX_MID1_GAIN (7.943f)
#define AL_EQUALIZER_DEFAULT_MID1_GAIN (1.0f)
#define AL_EQUALIZER_MIN_MID1_CENTER (200.0f)
#define AL_EQUALIZER_MAX_MID1_CENTER (3000.0f)
#define AL_EQUALIZER_DEFAULT_MID1_CENTER (500.0f)
#define AL_EQUALIZER_MIN_MID1_WIDTH (0.01f)
#define AL_EQUALIZER_MAX_MID1_WIDTH (1.0f)
#define AL_EQUALIZER_DEFAULT_MID1_WIDTH (1.0f)
#define AL_EQUALIZER_MIN_MID2_GAIN (0.126f)
#define AL_EQUALIZER_MAX_MID2_GAIN (7.943f)
#define AL_EQUALIZER_DEFAULT_MID2_GAIN (1.0f)
#define AL_EQUALIZER_MIN_MID2_CENTER (1000.0f)
#define AL_EQUALIZER_MAX_MID2_CENTER (8000.0f)
#define AL_EQUALIZER_DEFAULT_MID2_CENTER (3000.0f)
#define AL_EQUALIZER_MIN_MID2_WIDTH (0.01f)
#define AL_EQUALIZER_MAX_MID2_WIDTH (1.0f)
#define AL_EQUALIZER_DEFAULT_MID2_WIDTH (1.0f)
#define AL_EQUALIZER_MIN_HIGH_GAIN (0.126f)
#define AL_EQUALIZER_MAX_HIGH_GAIN (7.943f)
#define AL_EQUALIZER_DEFAULT_HIGH_GAIN (1.0f)
#define AL_EQUALIZER_MIN_HIGH_CUTOFF (4000.0f)
#define AL_EQUALIZER_MAX_HIGH_CUTOFF (16000.0f)
#define AL_EQUALIZER_DEFAULT_HIGH_CUTOFF (6000.0f)
/* Source parameter value ranges and defaults. */
#define AL_MIN_AIR_ABSORPTION_FACTOR (0.0f)
#define AL_MAX_AIR_ABSORPTION_FACTOR (10.0f)
#define AL_DEFAULT_AIR_ABSORPTION_FACTOR (0.0f)
#define AL_MIN_ROOM_ROLLOFF_FACTOR (0.0f)
#define AL_MAX_ROOM_ROLLOFF_FACTOR (10.0f)
#define AL_DEFAULT_ROOM_ROLLOFF_FACTOR (0.0f)
#define AL_MIN_CONE_OUTER_GAINHF (0.0f)
#define AL_MAX_CONE_OUTER_GAINHF (1.0f)
#define AL_DEFAULT_CONE_OUTER_GAINHF (1.0f)
#define AL_MIN_DIRECT_FILTER_GAINHF_AUTO AL_FALSE
#define AL_MAX_DIRECT_FILTER_GAINHF_AUTO AL_TRUE
#define AL_DEFAULT_DIRECT_FILTER_GAINHF_AUTO AL_TRUE
#define AL_MIN_AUXILIARY_SEND_FILTER_GAIN_AUTO AL_FALSE
#define AL_MAX_AUXILIARY_SEND_FILTER_GAIN_AUTO AL_TRUE
#define AL_DEFAULT_AUXILIARY_SEND_FILTER_GAIN_AUTO AL_TRUE
#define AL_MIN_AUXILIARY_SEND_FILTER_GAINHF_AUTO AL_FALSE
#define AL_MAX_AUXILIARY_SEND_FILTER_GAINHF_AUTO AL_TRUE
#define AL_DEFAULT_AUXILIARY_SEND_FILTER_GAINHF_AUTO AL_TRUE
/* Listener parameter value ranges and defaults. */
#define AL_MIN_METERS_PER_UNIT FLT_MIN
#define AL_MAX_METERS_PER_UNIT FLT_MAX
#define AL_DEFAULT_METERS_PER_UNIT (1.0f)
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* AL_EFX_H */

93221
extlibs/headers/miniaudio/miniaudio.h vendored Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
extlibs/libs-msvc-universal/x64/openal32.lib vendored
View File

Binary file not shown.

BIN
extlibs/libs-msvc-universal/x86/openal32.lib vendored
View File

Binary file not shown.

1
extlibs/libs-osx/Frameworks/OpenAL.framework/OpenAL vendored
View File

@ -1 +0,0 @@
Versions/Current/OpenAL

1
extlibs/libs-osx/Frameworks/OpenAL.framework/Resources vendored
View File

@ -1 +0,0 @@
Versions/Current/Resources

BIN
extlibs/libs-osx/Frameworks/OpenAL.framework/Versions/A/OpenAL vendored
View File

Binary file not shown.

20
extlibs/libs-osx/Frameworks/OpenAL.framework/Versions/A/Resources/Info.plist vendored
View File

@ -1,20 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>CFBundleDevelopmentRegion</key>
<string>English</string>
<key>CFBundleExecutable</key>
<string>OpenAL</string>
<key>CFBundleIdentifier</key>
<string>org.sfml-dev.OpenAL</string>
<key>CFBundleInfoDictionaryVersion</key>
<string>6.0</string>
<key>CFBundlePackageType</key>
<string>FMWK</string>
<key>CFBundleSignature</key>
<string>????</string>
<key>CFBundleVersion</key>
<string>1.0</string>
</dict>
</plist>

1
extlibs/libs-osx/Frameworks/OpenAL.framework/Versions/Current vendored
View File

@ -1 +0,0 @@
A

16
include/SFML/Audio/AlResource.hpp → include/SFML/Audio/AudioResource.hpp
View File

@ -29,27 +29,29 @@
////////////////////////////////////////////////////////////
#include <SFML/Audio/Export.hpp>
#include <memory>
namespace sf
{
////////////////////////////////////////////////////////////
/// \brief Base class for classes that require an OpenAL context
/// \brief Base class for classes that require an audio device
///
////////////////////////////////////////////////////////////
class SFML_AUDIO_API AlResource
class SFML_AUDIO_API AudioResource
{
protected:
////////////////////////////////////////////////////////////
/// \brief Default constructor
///
////////////////////////////////////////////////////////////
AlResource();
AudioResource();
private:
////////////////////////////////////////////////////////////
/// \brief Destructor
///
// Member data
////////////////////////////////////////////////////////////
~AlResource();
const std::shared_ptr<void> m_device; //!< Sound device
};
} // namespace sf
@ -60,7 +62,7 @@ protected:
/// \ingroup audio
///
/// This class is for internal use only, it must be the base
/// of every class that requires a valid OpenAL context in
/// of every class that requires a valid audio device in
/// order to work.
///
////////////////////////////////////////////////////////////

15
include/SFML/Audio/InputSoundFile.hpp
View File

@ -33,6 +33,7 @@
#include <filesystem>
#include <memory>
#include <vector>
#include <cstddef>
@ -124,6 +125,19 @@ public:
////////////////////////////////////////////////////////////
unsigned int getSampleRate() const;
////////////////////////////////////////////////////////////
/// \brief Get the map of position in sample frame to sound channel
///
/// This is used to map a sample in the sample stream to a
/// position during spatialisation.
///
/// \return Map of position in sample frame to sound channel
///
/// \see getSampleRate, getChannelCount, getDuration
///
////////////////////////////////////////////////////////////
std::vector<SoundChannel> getChannelMap() const;
////////////////////////////////////////////////////////////
/// \brief Get the total duration of the sound file
///
@ -228,6 +242,7 @@ private:
std::uint64_t m_sampleCount{}; //!< Total number of samples in the file
unsigned int m_channelCount{}; //!< Number of channels of the sound
unsigned int m_sampleRate{}; //!< Number of samples per second
std::vector<SoundChannel> m_channelMap; //!< The map of position in sample frame to sound channel
};
} // namespace sf

64
include/SFML/Audio/Listener.hpp
View File

@ -29,6 +29,7 @@
////////////////////////////////////////////////////////////
#include <SFML/Audio/Export.hpp>
#include <SFML/System/Angle.hpp>
#include <SFML/System/Vector3.hpp>
@ -39,6 +40,24 @@
////////////////////////////////////////////////////////////
namespace sf::Listener
{
////////////////////////////////////////////////////////////
/// \brief Structure defining the properties of a directional cone
///
/// Sounds will play at gain 1 when they are positioned
/// within the inner angle of the cone. Sounds will play
/// at outerGain when they are positioned outside the
/// outer angle of the cone. The gain declines linearly
/// from 1 to outerGain as the sound moves from the inner
/// angle to the outer angle.
///
////////////////////////////////////////////////////////////
struct Cone
{
Angle innerAngle; //!< Inner angle, default is 360 degrees
Angle outerAngle; //!< Outer angle, default is 360 degrees
float outerGain; //!< Outer gain, default is 1
};
////////////////////////////////////////////////////////////
/// \brief Change the global volume of all the sounds and musics
///
@ -112,6 +131,51 @@ SFML_AUDIO_API void setDirection(const Vector3f& direction);
////////////////////////////////////////////////////////////
SFML_AUDIO_API Vector3f getDirection();
////////////////////////////////////////////////////////////
/// \brief Set the velocity of the listener in the scene
///
/// The default listener's velocity is (0, 0, -1).
///
/// \param velocity New listener's velocity
///
/// \see getVelocity, getDirection, setUpVector, setPosition
///
////////////////////////////////////////////////////////////
SFML_AUDIO_API void setVelocity(const Vector3f& velocity);
////////////////////////////////////////////////////////////
/// \brief Get the current forward vector of the listener in the scene
///
/// \return Listener's velocity
///
/// \see setVelocity
///
////////////////////////////////////////////////////////////
SFML_AUDIO_API Vector3f getVelocity();
////////////////////////////////////////////////////////////
/// \brief Set the cone properties of the listener in the audio scene
///
/// The cone defines how directional attenuation is applied.
/// The default cone of a sound is {2 * PI, 2 * PI, 1}.
///
/// \param cone Cone properties of the listener in the scene
///
/// \see getCone
///
////////////////////////////////////////////////////////////
SFML_AUDIO_API void setCone(const Listener::Cone& cone);
////////////////////////////////////////////////////////////
/// \brief Get the cone properties of the listener in the audio scene
///
/// \return Cone properties of the listener
///
/// \see setCone
///
////////////////////////////////////////////////////////////
SFML_AUDIO_API Listener::Cone getCone();
////////////////////////////////////////////////////////////
/// \brief Set the upward vector of the listener in the scene
///

14
include/SFML/Audio/Music.hpp
View File

@ -29,11 +29,9 @@
////////////////////////////////////////////////////////////
#include <SFML/Audio/Export.hpp>
#include <SFML/Audio/InputSoundFile.hpp>
#include <SFML/Audio/SoundStream.hpp>
#include <filesystem>
#include <vector>
namespace sf
@ -62,6 +60,12 @@ public:
// Define the relevant Span types
using TimeSpan = Span<Time>;
////////////////////////////////////////////////////////////
/// \brief Default constructor
///
////////////////////////////////////////////////////////////
Music();
////////////////////////////////////////////////////////////
/// \brief Destructor
///
@ -244,10 +248,8 @@ private:
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
InputSoundFile m_file; //!< The streamed music file
std::vector<std::int16_t> m_samples; //!< Temporary buffer of samples
std::recursive_mutex m_mutex; //!< Mutex protecting the data
Span<std::uint64_t> m_loopSpan; //!< Loop Range Specifier
struct Impl;
const std::unique_ptr<Impl> m_impl; //!< Implementation details
};
} // namespace sf

7
include/SFML/Audio/OutputSoundFile.hpp
View File

@ -29,6 +29,7 @@
////////////////////////////////////////////////////////////
#include <SFML/Audio/Export.hpp>
#include <SFML/Audio/SoundChannel.hpp>
#include <SFML/Audio/SoundFileWriter.hpp>
#include <filesystem>
@ -58,11 +59,15 @@ public:
/// \param filename Path of the sound file to write
/// \param sampleRate Sample rate of the sound
/// \param channelCount Number of channels in the sound
/// \param channelMap Map of position in sample frame to sound channel
///
/// \return True if the file was successfully opened
///
////////////////////////////////////////////////////////////
[[nodiscard]] bool openFromFile(const std::filesystem::path& filename, unsigned int sampleRate, unsigned int channelCount);
[[nodiscard]] bool openFromFile(const std::filesystem::path& filename,
unsigned int sampleRate,
unsigned int channelCount,
const std::vector<SoundChannel>& channelMap);
////////////////////////////////////////////////////////////
/// \brief Write audio samples to the file

12
include/SFML/Audio/Sound.hpp
View File

@ -32,6 +32,7 @@
#include <SFML/Audio/SoundSource.hpp>
#include <cstdlib>
#include <memory>
namespace sf
@ -225,10 +226,19 @@ public:
void resetBuffer();
private:
////////////////////////////////////////////////////////////
/// \brief Get the sound object
///
/// \return The sound object
///
////////////////////////////////////////////////////////////
void* getSound() const override;
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
const SoundBuffer* m_buffer{}; //!< Sound buffer bound to the source
struct Impl;
const std::unique_ptr<Impl> m_impl; //!< Implementation details
};
} // namespace sf

50
include/SFML/Audio/SoundBuffer.hpp
View File

@ -29,13 +29,12 @@
////////////////////////////////////////////////////////////
#include <SFML/Audio/Export.hpp>
#include <SFML/Audio/AlResource.hpp>
#include <SFML/Audio/SoundChannel.hpp>
#include <SFML/System/Time.hpp>
#include <filesystem>
#include <string>
#include <unordered_set>
#include <memory>
#include <vector>
@ -49,7 +48,7 @@ class InputStream;
/// \brief Storage for audio samples defining a sound
///
////////////////////////////////////////////////////////////
class SFML_AUDIO_API SoundBuffer : AlResource
class SFML_AUDIO_API SoundBuffer
{
public:
////////////////////////////////////////////////////////////
@ -127,16 +126,18 @@ public:
/// \param sampleCount Number of samples in the array
/// \param channelCount Number of channels (1 = mono, 2 = stereo, ...)
/// \param sampleRate Sample rate (number of samples to play per second)
/// \param channelMap Map of position in sample frame to sound channel
///
/// \return True if loading succeeded, false if it failed
///
/// \see loadFromFile, loadFromMemory, saveToFile
///
////////////////////////////////////////////////////////////
[[nodiscard]] bool loadFromSamples(const std::int16_t* samples,
std::uint64_t sampleCount,
unsigned int channelCount,
unsigned int sampleRate);
[[nodiscard]] bool loadFromSamples(const std::int16_t* samples,
std::uint64_t sampleCount,
unsigned int channelCount,
unsigned int sampleRate,
const std::vector<SoundChannel>& channelMap);
////////////////////////////////////////////////////////////
/// \brief Save the sound buffer to an audio file
@ -189,7 +190,7 @@ public:
///
/// \return Sample rate (number of samples per second)
///
/// \see getChannelCount, getDuration
/// \see getChannelCount, getChannelmap, getDuration
///
////////////////////////////////////////////////////////////
unsigned int getSampleRate() const;
@ -202,17 +203,30 @@ public:
///
/// \return Number of channels
///
/// \see getSampleRate, getDuration
/// \see getSampleRate, getChannelmap, getDuration
///
////////////////////////////////////////////////////////////
unsigned int getChannelCount() const;
////////////////////////////////////////////////////////////
/// \brief Get the map of position in sample frame to sound channel
///
/// This is used to map a sample in the sample stream to a
/// position during spatialisation.
///
/// \return Map of position in sample frame to sound channel
///
/// \see getSampleRate, getChannelCount, getDuration
///
////////////////////////////////////////////////////////////
std::vector<SoundChannel> getChannelMap() const;
////////////////////////////////////////////////////////////
/// \brief Get the total duration of the sound
///
/// \return Sound duration
///
/// \see getSampleRate, getChannelCount
/// \see getSampleRate, getChannelCount, getChannelmap
///
////////////////////////////////////////////////////////////
Time getDuration() const;
@ -245,11 +259,12 @@ private:
///
/// \param channelCount Number of channels
/// \param sampleRate Sample rate (number of samples per second)
/// \param channelMap Map of position in sample frame to sound channel
///
/// \return True on success, false if any error happened
///
////////////////////////////////////////////////////////////
[[nodiscard]] bool update(unsigned int channelCount, unsigned int sampleRate);
[[nodiscard]] bool update(unsigned int channelCount, unsigned int sampleRate, const std::vector<SoundChannel>& channelMap);
////////////////////////////////////////////////////////////
/// \brief Add a sound to the list of sounds that use this buffer
@ -267,18 +282,11 @@ private:
////////////////////////////////////////////////////////////
void detachSound(Sound* sound) const;
////////////////////////////////////////////////////////////
// Types
////////////////////////////////////////////////////////////
using SoundList = std::unordered_set<Sound*>; //!< Set of unique sound instances
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
unsigned int m_buffer{}; //!< OpenAL buffer identifier
std::vector<std::int16_t> m_samples; //!< Samples buffer
Time m_duration; //!< Sound duration
mutable SoundList m_sounds; //!< List of sounds that are using this buffer
struct Impl;
const std::unique_ptr<Impl> m_impl; //!< Implementation details
};
} // namespace sf

15
include/SFML/Audio/SoundBufferRecorder.hpp
View File

@ -29,14 +29,15 @@
////////////////////////////////////////////////////////////
#include <SFML/Audio/Export.hpp>
#include <SFML/Audio/SoundBuffer.hpp>
#include <SFML/Audio/SoundRecorder.hpp>
#include <vector>
#include <memory>
namespace sf
{
class SoundBuffer;
////////////////////////////////////////////////////////////
/// \brief Specialized SoundRecorder which stores the captured
/// audio data into a sound buffer
@ -45,6 +46,12 @@ namespace sf
class SFML_AUDIO_API SoundBufferRecorder : public SoundRecorder
{
public:
////////////////////////////////////////////////////////////
/// \brief Default constructor
///
////////////////////////////////////////////////////////////
SoundBufferRecorder();
////////////////////////////////////////////////////////////
/// \brief destructor
///
@ -94,8 +101,8 @@ private:
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
std::vector<std::int16_t> m_samples; //!< Temporary sample buffer to hold the recorded data
SoundBuffer m_buffer; //!< Sound buffer that will contain the recorded data
struct Impl;
const std::unique_ptr<Impl> m_impl; //!< Implementation details
};
} // namespace sf

65
include/SFML/Audio/SoundChannel.hpp Normal file
View File

@ -0,0 +1,65 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
// you must not claim that you wrote the original software.
// If you use this software in a product, an acknowledgment
// in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
// and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
////////////////////////////////////////////////////////////
#pragma once
namespace sf
{
////////////////////////////////////////////////////////////
/// \ingroup audio
/// \brief Types of sound channels that can be read/written from sound buffers/files
///
/// In multi-channel audio, each sound channel can be
/// assigned a position. The position of the channel is
/// used to determine where to place a sound when it
/// is spatialised. Assigning an incorrect sound channel
/// will result in multi-channel audio being positioned
/// incorrectly when using spatialisation.
///
////////////////////////////////////////////////////////////
enum class SoundChannel
{
Unspecified,
Mono,
FrontLeft,
FrontRight,
FrontCenter,
FrontLeftOfCenter,
FrontRightOfCenter,
LowFrequencyEffects,
BackLeft,
BackRight,
BackCenter,
SideLeft,
SideRight,
TopCenter,
TopFrontLeft,
TopFrontRight,
TopFrontCenter,
TopBackLeft,
TopBackRight,
TopBackCenter
};
} // namespace sf

10
include/SFML/Audio/SoundFileReader.hpp
View File

@ -29,7 +29,10 @@
////////////////////////////////////////////////////////////
#include <SFML/Audio/Export.hpp>
#include <SFML/Audio/SoundChannel.hpp>
#include <cstdint>
#include <vector>
namespace sf
@ -49,9 +52,10 @@ public:
////////////////////////////////////////////////////////////
struct Info
{
std::uint64_t sampleCount{}; //!< Total number of samples in the file
unsigned int channelCount{}; //!< Number of channels of the sound
unsigned int sampleRate{}; //!< Samples rate of the sound, in samples per second
std::uint64_t sampleCount{}; //!< Total number of samples in the file
unsigned int channelCount{}; //!< Number of channels of the sound
unsigned int sampleRate{}; //!< Samples rate of the sound, in samples per second
std::vector<SoundChannel> channelMap; //!< Map of position in sample frame to sound channel
};
////////////////////////////////////////////////////////////

12
include/SFML/Audio/SoundFileWriter.hpp
View File

@ -29,6 +29,8 @@
////////////////////////////////////////////////////////////
#include <SFML/Audio/Export.hpp>
#include <SFML/Audio/SoundChannel.hpp>
#include <filesystem>
@ -53,13 +55,15 @@ public:
/// \param filename Path of the file to open
/// \param sampleRate Sample rate of the sound
/// \param channelCount Number of channels of the sound
/// \param channelMap Map of position in sample frame to sound channel
///
/// \return True if the file was successfully opened
///
////////////////////////////////////////////////////////////
[[nodiscard]] virtual bool open(const std::filesystem::path& filename,
unsigned int sampleRate,
unsigned int channelCount) = 0;
[[nodiscard]] virtual bool open(const std::filesystem::path& filename,
unsigned int sampleRate,
unsigned int channelCount,
const std::vector<SoundChannel>& channelMap) = 0;
////////////////////////////////////////////////////////////
/// \brief Write audio samples to the open file
@ -101,7 +105,7 @@ public:
/// // return true if the writer can handle the format
/// }
///
/// [[nodiscard]] bool open(const std::filesystem::path& filename, unsigned int sampleRate, unsigned int channelCount) override
/// [[nodiscard]] bool open(const std::filesystem::path& filename, unsigned int sampleRate, unsigned int channelCount, const std::vector<SoundChannel>& channelMap) override
/// {
/// // open the file 'filename' for writing,
/// // write the given sample rate and channel count to the file header

89
include/SFML/Audio/SoundRecorder.hpp
View File

@ -29,12 +29,12 @@
////////////////////////////////////////////////////////////
#include <SFML/Audio/Export.hpp>
#include <SFML/Audio/AlResource.hpp>
#include <SFML/Audio/SoundChannel.hpp>
#include <SFML/System/Time.hpp>
#include <memory>
#include <string>
#include <thread>
#include <vector>
@ -44,7 +44,7 @@ namespace sf
/// \brief Abstract base class for capturing sound data
///
////////////////////////////////////////////////////////////
class SFML_AUDIO_API SoundRecorder : AlResource
class SFML_AUDIO_API SoundRecorder
{
public:
////////////////////////////////////////////////////////////
@ -173,6 +173,17 @@ public:
////////////////////////////////////////////////////////////
unsigned int getChannelCount() const;
////////////////////////////////////////////////////////////
/// \brief Get the map of position in sample frame to sound channel
///
/// This is used to map a sample in the sample stream to a
/// position during spatialisation.
///
/// \return Map of position in sample frame to sound channel
///
////////////////////////////////////////////////////////////
std::vector<SoundChannel> getChannelMap() const;
////////////////////////////////////////////////////////////
/// \brief Check if the system supports audio capture
///
@ -195,24 +206,6 @@ protected:
////////////////////////////////////////////////////////////
SoundRecorder();
////////////////////////////////////////////////////////////
/// \brief Set the processing interval
///
/// The processing interval controls the period
/// between calls to the onProcessSamples function. You may
/// want to use a small interval if you want to process the
/// recorded data in real time, for example.
///
/// Note: this is only a hint, the actual period may vary.
/// So don't rely on this parameter to implement precise timing.
///
/// The default processing interval is 100 ms.
///
/// \param interval Processing interval
///
////////////////////////////////////////////////////////////
void setProcessingInterval(Time interval);
////////////////////////////////////////////////////////////
/// \brief Start capturing audio data
///
@ -254,61 +247,11 @@ protected:
virtual void onStop();
private:
////////////////////////////////////////////////////////////
/// \brief Function called as the entry point of the thread
///
/// This function starts the recording loop, and returns
/// only when the capture is stopped.
///
////////////////////////////////////////////////////////////
void record();
////////////////////////////////////////////////////////////
/// \brief Get the new available audio samples and process them
///
/// This function is called continuously during the
/// capture loop. It retrieves the captured samples and
/// forwards them to the derived class.
///
////////////////////////////////////////////////////////////
void processCapturedSamples();
////////////////////////////////////////////////////////////
/// \brief Clean up the recorder's internal resources
///
/// This function is called when the capture stops.
///
////////////////////////////////////////////////////////////
void cleanup();
////////////////////////////////////////////////////////////
/// \brief Launch a new capture thread running 'record'
///
/// This function is called when the capture is started or
/// when the device is changed.
///
////////////////////////////////////////////////////////////
void launchCapturingThread();
////////////////////////////////////////////////////////////
/// \brief Stop capturing and wait for 'm_thread' to join
///
/// This function is called when the capture is stopped or
/// when the device is changed.
///
////////////////////////////////////////////////////////////
void awaitCapturingThread();
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
std::thread m_thread; //!< Thread running the background recording task
std::vector<std::int16_t> m_samples; //!< Buffer to store captured samples
unsigned int m_sampleRate{}; //!< Sample rate
Time m_processingInterval{milliseconds(100)}; //!< Time period between calls to onProcessSamples
bool m_isCapturing{}; //!< Capturing state
std::string m_deviceName{getDefaultDevice()}; //!< Name of the audio capture device
unsigned int m_channelCount{1}; //!< Number of recording channels
struct Impl;
const std::unique_ptr<Impl> m_impl; //!< Implementation details
};
} // namespace sf

285
include/SFML/Audio/SoundSource.hpp
View File

@ -29,10 +29,13 @@
////////////////////////////////////////////////////////////
#include <SFML/Audio/Export.hpp>
#include <SFML/Audio/AlResource.hpp>
#include <SFML/Audio/AudioResource.hpp>
#include <SFML/System/Angle.hpp>
#include <SFML/System/Vector3.hpp>
#include <memory>
namespace sf
{
@ -41,7 +44,7 @@ namespace sf
/// \brief Base class defining a sound's properties
///
////////////////////////////////////////////////////////////
class SFML_AUDIO_API SoundSource : AlResource
class SFML_AUDIO_API SoundSource : protected AudioResource
{
public:
////////////////////////////////////////////////////////////
@ -55,6 +58,24 @@ public:
Playing //!< Sound is playing
};
////////////////////////////////////////////////////////////
/// \brief Structure defining the properties of a directional cone
///
/// Sounds will play at gain 1 when the listener
/// is positioned within the inner angle of the cone.
/// Sounds will play at outerGain when the listener is
/// positioned outside the outer angle of the cone.
/// The gain declines linearly from 1 to outerGain as the
/// listener moves from the inner angle to the outer angle.
///
////////////////////////////////////////////////////////////
struct Cone
{
Angle innerAngle; //!< Inner angle, default is 360 degrees
Angle outerAngle; //!< Outer angle, default is 360 degrees
float outerGain; //!< Outer gain, default is 1
};
////////////////////////////////////////////////////////////
/// \brief Copy constructor
///
@ -67,7 +88,7 @@ public:
/// \brief Destructor
///
////////////////////////////////////////////////////////////
virtual ~SoundSource();
virtual ~SoundSource() = default;
////////////////////////////////////////////////////////////
/// \brief Set the pitch of the sound
@ -85,6 +106,21 @@ public:
////////////////////////////////////////////////////////////
void setPitch(float pitch);
////////////////////////////////////////////////////////////
/// \brief Set the pan of the sound
///
/// Using panning, a mono sound can be panned between
/// stereo channels. When the pan is set to -1, the sound
/// is played only on the left channel, when the pan is set
/// to +1, the sound is played only on the right channel.
///
/// \param pan New pan to apply to the sound [-1, +1]
///
/// \see getPan
///
////////////////////////////////////////////////////////////
void setPan(float pan);
////////////////////////////////////////////////////////////
/// \brief Set the volume of the sound
///
@ -98,6 +134,21 @@ public:
////////////////////////////////////////////////////////////
void setVolume(float volume);
////////////////////////////////////////////////////////////
/// \brief Set whether spatialization of the sound is enabled
///
/// Spatialization is the application of various effects to
/// simulate a sound being emitted at a virtual position in
/// 3D space and exhibiting various physical phenomena such as
/// directional attenuation and doppler shift.
///
/// \param enabled True to enable spatialization, false to disable
///
/// \see isSpatializationEnabled
///
////////////////////////////////////////////////////////////
void setSpatializationEnabled(bool enabled);
////////////////////////////////////////////////////////////
/// \brief Set the 3D position of the sound in the audio scene
///
@ -112,6 +163,79 @@ public:
////////////////////////////////////////////////////////////
void setPosition(const Vector3f& position);
////////////////////////////////////////////////////////////
/// \brief Set the 3D direction of the sound in the audio scene
///
/// The direction defines where the sound source is facing
/// in 3D space. It will affect how the sound is attenuated
/// if facing away from the listener.
/// The default direction of a sound is (0, 0, -1).
///
/// \param direction Direction of the sound in the scene
///
/// \see getDirection
///
////////////////////////////////////////////////////////////
void setDirection(const Vector3f& direction);
////////////////////////////////////////////////////////////
/// \brief Set the cone properties of the sound in the audio scene
///
/// The cone defines how directional attenuation is applied.
/// The default cone of a sound is {2 * PI, 2 * PI, 1}.
///
/// \param cone Cone properties of the sound in the scene
///
/// \see getCone
///
////////////////////////////////////////////////////////////
void setCone(const Cone& cone);
////////////////////////////////////////////////////////////
/// \brief Set the 3D velocity of the sound in the audio scene
///
/// The velocity is used to determine how to doppler shift
/// the sound. Sounds moving towards the listener will be
/// perceived to have a higher pitch and sounds moving away
/// from the listener will be perceived to have a lower pitch.
///
/// \param velocity Velocity of the sound in the scene
///
/// \see getVelocity
///
////////////////////////////////////////////////////////////
void setVelocity(const Vector3f& velocity);
////////////////////////////////////////////////////////////
/// \brief Set the doppler factor of the sound
///
/// The doppler factor determines how strong the doppler
/// shift will be.
///
/// \param factor New doppler factor to apply to the sound
///
/// \see getDopplerFactor
///
////////////////////////////////////////////////////////////
void setDopplerFactor(float factor);
////////////////////////////////////////////////////////////
/// \brief Set the directional attenuation factor of the sound
///
/// Depending on the virtual position of an output channel
/// relative to the listener (such as in surround sound
/// setups), sounds will be attenuated when emitting them
/// from certain channels. This factor determines how strong
/// the attenuation based on output channel position
/// relative to the listener is.
///
/// \param factor New directional attenuation factor to apply to the sound
///
/// \see getDirectionalAttenuationFactor
///
////////////////////////////////////////////////////////////
void setDirectionalAttenuationFactor(float factor);
////////////////////////////////////////////////////////////
/// \brief Make the sound's position relative to the listener or absolute
///
@ -145,6 +269,51 @@ public:
////////////////////////////////////////////////////////////
void setMinDistance(float distance);
////////////////////////////////////////////////////////////
/// \brief Set the maximum distance of the sound
///
/// The "maximum distance" of a sound is the minimum
/// distance at which it is heard at its minimum volume. Closer
/// than the maximum distance, it will start to fade in according
/// to its attenuation factor.
/// The default value of the maximum distance is the maximum
/// value a float can represent.
///
/// \param distance New maximum distance of the sound
///
/// \see getMaxDistance, setAttenuation
///
////////////////////////////////////////////////////////////
void setMaxDistance(float distance);
////////////////////////////////////////////////////////////
/// \brief Set the minimum gain of the sound
///
/// When the sound is further away from the listener than
/// the "maximum distance" the attenuated gain is clamped
/// so it cannot go below the minimum gain value.
///
/// \param distance New minimum gain of the sound
///
/// \see getMinGain, setAttenuation
///
////////////////////////////////////////////////////////////
void setMinGain(float gain);
////////////////////////////////////////////////////////////
/// \brief Set the maximum gain of the sound
///
/// When the sound is closer from the listener than
/// the "minimum distance" the attenuated gain is clamped
/// so it cannot go above the maximum gain value.
///
/// \param gain New maximum gain of the sound
///
/// \see getMaxGain, setAttenuation
///
////////////////////////////////////////////////////////////
void setMaxGain(float gain);
////////////////////////////////////////////////////////////
/// \brief Set the attenuation factor of the sound
///
@ -174,6 +343,16 @@ public:
////////////////////////////////////////////////////////////
float getPitch() const;
////////////////////////////////////////////////////////////
/// \brief Get the pan of the sound
///
/// \return Pan of the sound
///
/// \see setPan
///
////////////////////////////////////////////////////////////
float getPan() const;
////////////////////////////////////////////////////////////
/// \brief Get the volume of the sound
///
@ -184,6 +363,16 @@ public:
////////////////////////////////////////////////////////////
float getVolume() const;
////////////////////////////////////////////////////////////
/// \brief Tell whether spatialization of the sound is enabled
///
/// \return True if spatialization is enabled, false if it's disabled
///
/// \see setSpatializationEnabled
///
////////////////////////////////////////////////////////////
bool isSpatializationEnabled() const;
////////////////////////////////////////////////////////////
/// \brief Get the 3D position of the sound in the audio scene
///
@ -194,6 +383,56 @@ public:
////////////////////////////////////////////////////////////
Vector3f getPosition() const;
////////////////////////////////////////////////////////////
/// \brief Get the 3D direction of the sound in the audio scene
///
/// \return Direction of the sound
///
/// \see setDirection
///
////////////////////////////////////////////////////////////
Vector3f getDirection() const;
////////////////////////////////////////////////////////////
/// \brief Get the cone properties of the sound in the audio scene
///
/// \return Cone properties of the sound
///
/// \see setCone
///
////////////////////////////////////////////////////////////
Cone getCone() const;
////////////////////////////////////////////////////////////
/// \brief Get the 3D velocity of the sound in the audio scene
///
/// \return Velocity of the sound
///
/// \see setVelocity
///
////////////////////////////////////////////////////////////
Vector3f getVelocity() const;
////////////////////////////////////////////////////////////
/// \brief Get the doppler factor of the sound
///
/// \return Doppler factor of the sound
///
/// \see setDopplerFactor
///
////////////////////////////////////////////////////////////
float getDopplerFactor() const;
////////////////////////////////////////////////////////////
/// \brief Get the directional attenuation factor of the sound
///
/// \return Directional attenuation factor of the sound
///
/// \see setDirectionalAttenuationFactor
///
////////////////////////////////////////////////////////////
float getDirectionalAttenuationFactor() const;
////////////////////////////////////////////////////////////
/// \brief Tell whether the sound's position is relative to the
/// listener or is absolute
@ -215,6 +454,36 @@ public:
////////////////////////////////////////////////////////////
float getMinDistance() const;
////////////////////////////////////////////////////////////
/// \brief Get the maximum distance of the sound
///
/// \return Maximum distance of the sound
///
/// \see setMaxDistance, getAttenuation
///
////////////////////////////////////////////////////////////
float getMaxDistance() const;
////////////////////////////////////////////////////////////
/// \brief Get the minimum gain of the sound
///
/// \return Minimum gain of the sound
///
/// \see setMinGain, getAttenuation
///
////////////////////////////////////////////////////////////
float getMinGain() const;
////////////////////////////////////////////////////////////
/// \brief Get the maximum gain of the sound
///
/// \return Maximum gain of the sound
///
/// \see setMaxGain, getAttenuation
///
////////////////////////////////////////////////////////////
float getMaxGain() const;
////////////////////////////////////////////////////////////
/// \brief Get the attenuation factor of the sound
///
@ -285,12 +554,16 @@ protected:
/// This constructor is meant to be called by derived classes only.
///
////////////////////////////////////////////////////////////
SoundSource();
SoundSource() = default;
private:
////////////////////////////////////////////////////////////
// Member data
/// \brief Get the sound object
///
/// \return The sound object
///
////////////////////////////////////////////////////////////
unsigned int m_source; //!< OpenAL source identifier
virtual void* getSound() const = 0;
};
// NOLINTEND(readability-make-member-function-const)

112
include/SFML/Audio/SoundStream.hpp
View File

@ -29,12 +29,13 @@
////////////////////////////////////////////////////////////
#include <SFML/Audio/Export.hpp>
#include <SFML/Audio/SoundChannel.hpp>
#include <SFML/Audio/SoundSource.hpp>
#include <SFML/System/Time.hpp>
#include <mutex>
#include <thread>
#include <memory>
#include <vector>
#include <cstdlib>
@ -122,6 +123,17 @@ public:
////////////////////////////////////////////////////////////
unsigned int getSampleRate() const;
////////////////////////////////////////////////////////////
/// \brief Get the map of position in sample frame to sound channel
///
/// This is used to map a sample in the sample stream to a
/// position during spatialisation.
///
/// \return Map of position in sample frame to sound channel
///
////////////////////////////////////////////////////////////
std::vector<SoundChannel> getChannelMap() const;
////////////////////////////////////////////////////////////
/// \brief Get the current status of the stream (stopped, paused, playing)
///
@ -206,9 +218,10 @@ protected:
///
/// \param channelCount Number of channels of the stream
/// \param sampleRate Sample rate, in samples per second
/// \param channelMap Map of position in sample frame to sound channel
///
////////////////////////////////////////////////////////////
void initialize(unsigned int channelCount, unsigned int sampleRate);
void initialize(unsigned int channelCount, unsigned int sampleRate, const std::vector<SoundChannel>& channelMap);
////////////////////////////////////////////////////////////
/// \brief Request a new chunk of audio samples from the stream source
@ -252,103 +265,20 @@ protected:
////////////////////////////////////////////////////////////
virtual std::int64_t onLoop();
////////////////////////////////////////////////////////////
/// \brief Set the processing interval
///
/// The processing interval controls the period at which the
/// audio buffers are filled by calls to onGetData. A smaller
/// interval may be useful for low-latency streams. Note that
/// the given period is only a hint and the actual period may
/// vary. The default processing interval is 10 ms.
///
/// \param interval Processing interval
///
////////////////////////////////////////////////////////////
void setProcessingInterval(Time interval);
private:
////////////////////////////////////////////////////////////
/// \brief Function called as the entry point of the thread
/// \brief Get the sound object
///
/// This function starts the streaming loop, and returns
/// only when the sound is stopped.
/// \return The sound object
///
////////////////////////////////////////////////////////////
void streamData();
////////////////////////////////////////////////////////////
/// \brief Fill a new buffer with audio samples, and append
/// it to the playing queue
///
/// This function is called as soon as a buffer has been fully
/// consumed; it fills it again and inserts it back into the
/// playing queue.
///
/// \param bufferNum Number of the buffer to fill (in [0, BufferCount])
/// \param immediateLoop Treat empty buffers as spent, and act on loops immediately
///
/// \return True if the stream source has requested to stop, false otherwise
///
////////////////////////////////////////////////////////////
[[nodiscard]] bool fillAndPushBuffer(unsigned int bufferNum, bool immediateLoop = false);
////////////////////////////////////////////////////////////
/// \brief Fill the audio buffers and put them all into the playing queue
///
/// This function is called when playing starts and the
/// playing queue is empty.
///
/// \return True if the derived class has requested to stop, false otherwise
///
////////////////////////////////////////////////////////////
[[nodiscard]] bool fillQueue();
////////////////////////////////////////////////////////////
/// \brief Clear all the audio buffers and empty the playing queue
///
/// This function is called when the stream is stopped.
///
////////////////////////////////////////////////////////////
void clearQueue();
////////////////////////////////////////////////////////////
/// \brief Launch a new stream thread running 'streamData'
///
/// This function is called when the stream is played or
/// when the playing offset is changed.
///
////////////////////////////////////////////////////////////
void launchStreamingThread(Status threadStartState);
////////////////////////////////////////////////////////////
/// \brief Stop streaming and wait for 'm_thread' to join
///
/// This function is called when the playback is stopped or
/// when the sound stream is destroyed.
///
////////////////////////////////////////////////////////////
void awaitStreamingThread();
// NOLINTBEGIN(readability-identifier-naming)
static constexpr unsigned int BufferCount{3}; //!< Number of audio buffers used by the streaming loop
static constexpr unsigned int BufferRetries{2}; //!< Number of retries (excluding initial try) for onGetData()
// NOLINTEND(readability-identifier-naming)
void* getSound() const override;
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
std::thread m_thread; //!< Thread running the background tasks
mutable std::recursive_mutex m_threadMutex; //!< Thread mutex
Status m_threadStartState{Stopped}; //!< State the thread starts in (Playing, Paused, Stopped)
bool m_isStreaming{}; //!< Streaming state (true = playing, false = stopped)
unsigned int m_buffers[BufferCount]{}; //!< Sound buffers used to store temporary audio data
unsigned int m_channelCount{}; //!< Number of channels (1 = mono, 2 = stereo, ...)
unsigned int m_sampleRate{}; //!< Frequency (samples / second)
std::int32_t m_format{}; //!< Format of the internal sound buffers
bool m_loop{}; //!< Loop flag (true to loop, false to play once)
std::uint64_t m_samplesProcessed{}; //!< Number of samples processed since beginning of the stream
std::int64_t m_bufferSeeks[BufferCount]{}; //!< If buffer is an "end buffer", holds next seek position, else NoLoop. For play offset calculation.
Time m_processingInterval{milliseconds(10)}; //!< Interval for checking and filling the internal sound buffers.
struct Impl;
const std::unique_ptr<Impl> m_impl; //!< Implementation details
};
} // namespace sf

4
src/SFML/Android.mk
View File

@ -42,7 +42,7 @@ include $(CLEAR_VARS)
LOCAL_MODULE := sfml-audio
LOCAL_SRC_FILES := lib/$(TARGET_ARCH_ABI)/libsfml-audio.so
LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/include
LOCAL_SHARED_LIBRARIES := sfml-window sfml-system openal
LOCAL_SHARED_LIBRARIES := sfml-window sfml-system
prebuilt_path := $(call local-prebuilt-path,$(LOCAL_SRC_FILES))
prebuilt := $(strip $(wildcard $(prebuilt_path)))
@ -132,7 +132,7 @@ include $(CLEAR_VARS)
LOCAL_MODULE := sfml-audio-d
LOCAL_SRC_FILES := lib/$(TARGET_ARCH_ABI)/libsfml-audio-d.so
LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/include
LOCAL_SHARED_LIBRARIES := sfml-window-d sfml-system-d openal
LOCAL_SHARED_LIBRARIES := sfml-window-d sfml-system-d
prebuilt_path := $(call local-prebuilt-path,$(LOCAL_SRC_FILES))
prebuilt := $(strip $(wildcard $(prebuilt_path)))

117
src/SFML/Audio/ALCheck.cpp
View File

@ -1,117 +0,0 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
// you must not claim that you wrote the original software.
// If you use this software in a product, an acknowledgment
// in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
// and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Audio/ALCheck.hpp>
#include <SFML/System/Err.hpp>
#include <ostream>
#include <string>
#include <utility>
#if defined(__APPLE__)
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
namespace
{
// A nested named namespace is used here to allow unity builds of SFML.
namespace AlCheckImpl
{
thread_local ALenum lastError(AL_NO_ERROR);
} // namespace AlCheckImpl
} // namespace
namespace sf::priv
{
////////////////////////////////////////////////////////////
void alCheckError(const std::filesystem::path& file, unsigned int line, std::string_view expression)
{
// Get the last error
const ALenum errorCode = alGetError();
if (errorCode != AL_NO_ERROR)
{
AlCheckImpl::lastError = errorCode;
std::string error = "Unknown error";
std::string description = "No description";
// Decode the error code
switch (errorCode)
{
case AL_INVALID_NAME:
{
error = "AL_INVALID_NAME";
description = "A bad name (ID) has been specified.";
break;
}
case AL_INVALID_ENUM:
{
error = "AL_INVALID_ENUM";
description = "An unacceptable value has been specified for an enumerated argument.";
break;
}
case AL_INVALID_VALUE:
{
error = "AL_INVALID_VALUE";
description = "A numeric argument is out of range.";
break;
}
case AL_INVALID_OPERATION:
{
error = "AL_INVALID_OPERATION";
description = "The specified operation is not allowed in the current state.";
break;
}
case AL_OUT_OF_MEMORY:
{
error = "AL_OUT_OF_MEMORY";
description = "There is not enough memory left to execute the command.";
break;
}
}
// Log the error
err() << "An internal OpenAL call failed in " << file.filename() << "(" << line << ")."
<< "\nExpression:\n " << expression << "\nError description:\n " << error << "\n " << description << '\n'
<< std::endl;
}
}
////////////////////////////////////////////////////////////
ALenum alGetLastErrorImpl()
{
return std::exchange(AlCheckImpl::lastError, AL_NO_ERROR);
}
} // namespace sf::priv

93
src/SFML/Audio/ALCheck.hpp
View File

@ -1,93 +0,0 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
// you must not claim that you wrote the original software.
// If you use this software in a product, an acknowledgment
// in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
// and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
////////////////////////////////////////////////////////////
#pragma once
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Config.hpp>
#include <filesystem>
#include <string_view>
#if defined(__APPLE__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
#include <al.h>
#include <alc.h>
namespace sf::priv
{
////////////////////////////////////////////////////////////
/// Let's define a macro to quickly check every OpenAL API call
////////////////////////////////////////////////////////////
#ifdef SFML_DEBUG
// If in debug mode, perform a test on every call
// The do-while loop is needed so that alCheck can be used as a single statement in if/else branches
#define alCheck(expr) \
do \
{ \
expr; \
sf::priv::alCheckError(__FILE__, __LINE__, #expr); \
} while (false)
#define alGetLastError sf::priv::alGetLastErrorImpl
#else
// Else, we don't add any overhead
#define alCheck(expr) (expr)
#define alGetLastError alGetError
#endif
////////////////////////////////////////////////////////////
/// Check the last OpenAL error
///
/// \param file Source file where the call is located
/// \param line Line number of the source file where the call is located
/// \param expression The evaluated expression as a string
///
////////////////////////////////////////////////////////////
void alCheckError(const std::filesystem::path& file, unsigned int line, std::string_view expression);
////////////////////////////////////////////////////////////
/// Get the last OpenAL error on this thread
///
/// \return The last OpenAL error on this thread
///
////////////////////////////////////////////////////////////
ALenum alGetLastErrorImpl();
} // namespace sf::priv
#if defined(__APPLE__)
#pragma GCC diagnostic pop
#endif

379
src/SFML/Audio/AudioDevice.cpp
View File

@ -25,211 +25,348 @@
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Audio/ALCheck.hpp>
#include <SFML/Audio/AudioDevice.hpp>
#include <SFML/Audio/Listener.hpp>
#include <SFML/System/Err.hpp>
#include <algorithm>
#define MINIAUDIO_IMPLEMENTATION
#include <miniaudio.h>
#include <optional>
#include <ostream>
#if defined(__APPLE__)
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
namespace
{
ALCdevice* audioDevice = nullptr;
ALCcontext* audioContext = nullptr;
float listenerVolume = 100.f;
sf::Vector3f listenerPosition(0.f, 0.f, 0.f);
sf::Vector3f listenerDirection(0.f, 0.f, -1.f);
sf::Vector3f listenerUpVector(0.f, 1.f, 0.f);
} // namespace
namespace sf::priv
{
////////////////////////////////////////////////////////////
AudioDevice::AudioDevice()
struct AudioDevice::Impl
{
// Create the device
audioDevice = alcOpenDevice(nullptr);
if (audioDevice)
Impl()
{
// Create the context
audioContext = alcCreateContext(audioDevice, nullptr);
// Ensure we only ever have a single AudioDevice instance
assert(getInstance() == nullptr);
if (audioContext)
{
// Set the context as the current one (we'll only need one)
alcMakeContextCurrent(audioContext);
// Apply the listener properties the user might have set
float orientation[] = {listenerDirection.x,
listenerDirection.y,
listenerDirection.z,
listenerUpVector.x,
listenerUpVector.y,
listenerUpVector.z};
alCheck(alListenerf(AL_GAIN, listenerVolume * 0.01f));
alCheck(alListener3f(AL_POSITION, listenerPosition.x, listenerPosition.y, listenerPosition.z));
alCheck(alListenerfv(AL_ORIENTATION, orientation));
}
else
{
err() << "Failed to create the audio context" << std::endl;
}
getInstance() = this;
}
else
~Impl()
{
err() << "Failed to open the audio device" << std::endl;
// Ensure we only ever have a single AudioDevice instance
assert(getInstance() != nullptr);
getInstance() = nullptr;
}
// This function makes sure the instance pointer is initialized before using it
static Impl*& getInstance()
{
static Impl* instance{};
return instance;
}
struct ListenerProperties
{
float volume = 100.f;
sf::Vector3f position = sf::Vector3f(0.f, 0.f, 0.f);
sf::Vector3f direction = sf::Vector3f(0.f, 0.f, -1.f);
sf::Vector3f velocity = sf::Vector3f(0.f, 0.f, 0.f);
Listener::Cone cone = Listener::Cone{sf::degrees(360), sf::degrees(360), 1};
sf::Vector3f upVector = sf::Vector3f(0.f, 1.f, 0.f);
};
static ListenerProperties& getListenerProperties()
{
static ListenerProperties properties;
return properties;
}
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
std::optional<ma_log> m_log; //!< The miniaudio log
std::optional<ma_context> m_context; //!< The miniaudio context
std::optional<ma_device> m_playbackDevice; //!< The miniaudio playback device
std::optional<ma_engine> m_engine; //!< The miniaudio engine (used for effects and spatialisation)
};
////////////////////////////////////////////////////////////
AudioDevice::AudioDevice() : m_impl(std::make_unique<Impl>())
{
// Create the log
m_impl->m_log.emplace();
if (auto result = ma_log_init(nullptr, &*m_impl->m_log); result != MA_SUCCESS)
{
m_impl->m_log.reset();
err() << "Failed to initialize the audio log: " << ma_result_description(result) << std::endl;
return;
}
// Register our logging callback to output any warning/error messages
if (auto result = ma_log_register_callback(&*m_impl->m_log,
ma_log_callback_init(
[](void*, ma_uint32 level, const char* message)
{
if (level <= MA_LOG_LEVEL_WARNING)
err() << "miniaudio " << ma_log_level_to_string(level)
<< ": " << message << std::flush;
},
nullptr));
result != MA_SUCCESS)
err() << "Failed to register audio log callback: " << ma_result_description(result) << std::endl;
// Create the context
m_impl->m_context.emplace();
auto contextConfig = ma_context_config_init();
contextConfig.pLog = &*m_impl->m_log;
if (auto result = ma_context_init(nullptr, 0, &contextConfig, &*m_impl->m_context); result != MA_SUCCESS)
{
m_impl->m_context.reset();
err() << "Failed to initialize the audio context: " << ma_result_description(result) << std::endl;
return;
}
// Create the playback device
m_impl->m_playbackDevice.emplace();
auto playbackDeviceConfig = ma_device_config_init(ma_device_type_playback);
playbackDeviceConfig.dataCallback = [](ma_device* device, void* output, const void*, ma_uint32 frameCount)
{
auto& impl = *static_cast<Impl*>(device->pUserData);
if (impl.m_engine)
{
if (auto result = ma_engine_read_pcm_frames(&*impl.m_engine, output, frameCount, nullptr); result != MA_SUCCESS)
err() << "Failed to read PCM frames from audio engine: " << ma_result_description(result) << std::endl;
}
};
playbackDeviceConfig.pUserData = m_impl.get();
if (auto result = ma_device_init(&*m_impl->m_context, &playbackDeviceConfig, &*m_impl->m_playbackDevice);
result != MA_SUCCESS)
{
m_impl->m_playbackDevice.reset();
err() << "Failed to initialize the audio playback device: " << ma_result_description(result) << std::endl;
return;
}
// Create the engine
auto engineConfig = ma_engine_config_init();
engineConfig.pContext = &*m_impl->m_context;
engineConfig.pDevice = &*m_impl->m_playbackDevice;
engineConfig.listenerCount = 1;
m_impl->m_engine.emplace();
if (auto result = ma_engine_init(&engineConfig, &*m_impl->m_engine); result != MA_SUCCESS)
{
m_impl->m_engine.reset();
err() << "Failed to initialize the audio engine: " << ma_result_description(result) << std::endl;
return;
}
// Set master volume, position, velocity, cone and world up vector
if (auto result = ma_device_set_master_volume(ma_engine_get_device(&*m_impl->m_engine),
Impl::getListenerProperties().volume * 0.01f);
result != MA_SUCCESS)
err() << "Failed to set audio device master volume: " << ma_result_description(result) << std::endl;
ma_engine_listener_set_position(&*m_impl->m_engine,
0,
Impl::getListenerProperties().position.x,
Impl::getListenerProperties().position.y,
Impl::getListenerProperties().position.z);
ma_engine_listener_set_velocity(&*m_impl->m_engine,
0,
Impl::getListenerProperties().velocity.x,
Impl::getListenerProperties().velocity.y,
Impl::getListenerProperties().velocity.z);
ma_engine_listener_set_cone(&*m_impl->m_engine,
0,
Impl::getListenerProperties().cone.innerAngle.asRadians(),
Impl::getListenerProperties().cone.outerAngle.asRadians(),
Impl::getListenerProperties().cone.outerGain);
ma_engine_listener_set_world_up(&*m_impl->m_engine,
0,
Impl::getListenerProperties().upVector.x,
Impl::getListenerProperties().upVector.y,
Impl::getListenerProperties().upVector.z);
}
////////////////////////////////////////////////////////////
AudioDevice::~AudioDevice()
{
// Destroy the engine
if (m_impl->m_engine)
ma_engine_uninit(&*m_impl->m_engine);
// Destroy the playback device
if (m_impl->m_playbackDevice)
ma_device_uninit(&*m_impl->m_playbackDevice);
// Destroy the context
alcMakeContextCurrent(nullptr);
if (audioContext)
alcDestroyContext(audioContext);
if (m_impl->m_context)
ma_context_uninit(&*m_impl->m_context);
// Destroy the device
if (audioDevice)
alcCloseDevice(audioDevice);
// Destroy the log
if (m_impl->m_log)
ma_log_uninit(&*m_impl->m_log);
}
////////////////////////////////////////////////////////////
bool AudioDevice::isExtensionSupported(const std::string& extension)
void* AudioDevice::getEngine()
{
// Create a temporary audio device in case none exists yet.
// This device will not be used in this function and merely
// makes sure there is a valid OpenAL device for extension
// queries if none has been created yet.
std::optional<AudioDevice> device;
if (!audioDevice)
device.emplace();
auto* instance = Impl::getInstance();
if ((extension.length() > 2) && (extension.substr(0, 3) == "ALC"))
return alcIsExtensionPresent(audioDevice, extension.c_str()) != AL_FALSE;
else
return alIsExtensionPresent(extension.c_str()) != AL_FALSE;
}
if (instance && instance->m_engine)
return &*instance->m_engine;
////////////////////////////////////////////////////////////
int AudioDevice::getFormatFromChannelCount(unsigned int channelCount)
{
// Create a temporary audio device in case none exists yet.
// This device will not be used in this function and merely
// makes sure there is a valid OpenAL device for format
// queries if none has been created yet.
std::optional<AudioDevice> device;
if (!audioDevice)
device.emplace();
// Find the good format according to the number of channels
int format = 0;
// clang-format off
switch (channelCount)
{
case 1: format = AL_FORMAT_MONO16; break;
case 2: format = AL_FORMAT_STEREO16; break;
case 4: format = alGetEnumValue("AL_FORMAT_QUAD16"); break;
case 6: format = alGetEnumValue("AL_FORMAT_51CHN16"); break;
case 7: format = alGetEnumValue("AL_FORMAT_61CHN16"); break;
case 8: format = alGetEnumValue("AL_FORMAT_71CHN16"); break;
default: format = 0; break;
}
// clang-format on
// Fixes a bug on OS X
if (format == -1)
format = 0;
return format;
return nullptr;
}
////////////////////////////////////////////////////////////
void AudioDevice::setGlobalVolume(float volume)
{
if (audioContext)
alCheck(alListenerf(AL_GAIN, volume * 0.01f));
// Store the volume in case no audio device exists yet
Impl::getListenerProperties().volume = volume;
listenerVolume = volume;
auto* instance = Impl::getInstance();
if (!instance || !instance->m_engine)
return;
if (auto result = ma_device_set_master_volume(ma_engine_get_device(&*instance->m_engine), volume * 0.01f);
result != MA_SUCCESS)
err() << "Failed to set audio device master volume: " << ma_result_description(result) << std::endl;
}
////////////////////////////////////////////////////////////
float AudioDevice::getGlobalVolume()
{
return listenerVolume;
return Impl::getListenerProperties().volume;
}
////////////////////////////////////////////////////////////
void AudioDevice::setPosition(const Vector3f& position)
{
if (audioContext)
alCheck(alListener3f(AL_POSITION, position.x, position.y, position.z));
// Store the position in case no audio device exists yet
Impl::getListenerProperties().position = position;
listenerPosition = position;
auto* instance = Impl::getInstance();
if (!instance || !instance->m_engine)
return;
ma_engine_listener_set_position(&*instance->m_engine, 0, position.x, position.y, position.z);
}
////////////////////////////////////////////////////////////
Vector3f AudioDevice::getPosition()
{
return listenerPosition;
return Impl::getListenerProperties().position;
}
////////////////////////////////////////////////////////////
void AudioDevice::setDirection(const Vector3f& direction)
{
if (audioContext)
{
float orientation[] =
{direction.x, direction.y, direction.z, listenerUpVector.x, listenerUpVector.y, listenerUpVector.z};
alCheck(alListenerfv(AL_ORIENTATION, orientation));
}
// Store the direction in case no audio device exists yet
Impl::getListenerProperties().direction = direction;
listenerDirection = direction;
auto* instance = Impl::getInstance();
if (!instance || !instance->m_engine)
return;
ma_engine_listener_set_direction(&*instance->m_engine, 0, direction.x, direction.y, direction.z);
}
////////////////////////////////////////////////////////////
Vector3f AudioDevice::getDirection()
{
return listenerDirection;
return Impl::getListenerProperties().direction;
}
////////////////////////////////////////////////////////////
void AudioDevice::setVelocity(const Vector3f& velocity)
{
// Store the velocity in case no audio device exists yet
Impl::getListenerProperties().velocity = velocity;
auto* instance = Impl::getInstance();
if (!instance || !instance->m_engine)
return;
ma_engine_listener_set_velocity(&*instance->m_engine, 0, velocity.x, velocity.y, velocity.z);
}
////////////////////////////////////////////////////////////
Vector3f AudioDevice::getVelocity()
{
return Impl::getListenerProperties().velocity;
}
////////////////////////////////////////////////////////////
void AudioDevice::setCone(const Listener::Cone& cone)
{
// Store the cone in case no audio device exists yet
Impl::getListenerProperties().cone = cone;
auto* instance = Impl::getInstance();
if (!instance || !instance->m_engine)
return;
ma_engine_listener_set_cone(&*instance->m_engine,
0,
std::clamp(cone.innerAngle.asRadians(), 0.f, sf::degrees(360).asRadians()),
std::clamp(cone.outerAngle.asRadians(), 0.f, sf::degrees(360).asRadians()),
cone.outerGain);
}
////////////////////////////////////////////////////////////
Listener::Cone AudioDevice::getCone()
{
return Impl::getListenerProperties().cone;
}
////////////////////////////////////////////////////////////
void AudioDevice::setUpVector(const Vector3f& upVector)
{
if (audioContext)
{
float orientation[] =
{listenerDirection.x, listenerDirection.y, listenerDirection.z, upVector.x, upVector.y, upVector.z};
alCheck(alListenerfv(AL_ORIENTATION, orientation));
}
// Store the up vector in case no audio device exists yet
Impl::getListenerProperties().upVector = upVector;
listenerUpVector = upVector;
auto* instance = Impl::getInstance();
if (!instance || !instance->m_engine)
return;
ma_engine_listener_set_world_up(&*instance->m_engine, 0, upVector.x, upVector.y, upVector.z);
}
////////////////////////////////////////////////////////////
Vector3f AudioDevice::getUpVector()
{
return listenerUpVector;
return Impl::getListenerProperties().upVector;
}
} // namespace sf::priv

79
src/SFML/Audio/AudioDevice.hpp
View File

@ -27,9 +27,10 @@
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Audio/Listener.hpp>
#include <SFML/System/Vector3.hpp>
#include <string>
#include <memory>
namespace sf::priv
@ -56,28 +57,16 @@ public:
~AudioDevice();
////////////////////////////////////////////////////////////
/// \brief Check if an OpenAL extension is supported
/// \brief Get the audio engine
///
/// This functions automatically finds whether it
/// is an AL or ALC extension, and calls the corresponding
/// function.
/// There should only be a single instance of AudioDevice.
/// As long as an AudioResource exists, this function should
/// always return a valid pointer to the audio engine.
///
/// \param extension Name of the extension to test
///
/// \return True if the extension is supported, false if not
/// \return The audio engine
///
////////////////////////////////////////////////////////////
static bool isExtensionSupported(const std::string& extension);
////////////////////////////////////////////////////////////
/// \brief Get the OpenAL format that matches the given number of channels
///
/// \param channelCount Number of channels
///
/// \return Corresponding format
///
////////////////////////////////////////////////////////////
static int getFormatFromChannelCount(unsigned int channelCount);
static void* getEngine();
////////////////////////////////////////////////////////////
/// \brief Change the global volume of all the sounds and musics
@ -152,6 +141,51 @@ public:
////////////////////////////////////////////////////////////
static Vector3f getDirection();
////////////////////////////////////////////////////////////
/// \brief Set the velocity of the listener in the scene
///
/// The default listener's velocity is (0, 0, -1).
///
/// \param velocity New listener's velocity
///
/// \see getVelocity, getDirection, setUpVector, setPosition
///
////////////////////////////////////////////////////////////
static void setVelocity(const Vector3f& velocity);
////////////////////////////////////////////////////////////
/// \brief Get the current forward vector of the listener in the scene
///
/// \return Listener's velocity
///
/// \see setVelocity
///
////////////////////////////////////////////////////////////
static Vector3f getVelocity();
////////////////////////////////////////////////////////////
/// \brief Set the cone properties of the listener in the audio scene
///
/// The cone defines how directional attenuation is applied.
/// The default cone of a sound is {2 * PI, 2 * PI, 1}.
///
/// \param cone Cone properties of the listener in the scene
///
/// \see getCone
///
////////////////////////////////////////////////////////////
static void setCone(const Listener::Cone& cone);
////////////////////////////////////////////////////////////
/// \brief Get the cone properties of the listener in the audio scene
///
/// \return Cone properties of the listener
///
/// \see setCone
///
////////////////////////////////////////////////////////////
static Listener::Cone getCone();
////////////////////////////////////////////////////////////
/// \brief Set the upward vector of the listener in the scene
///
@ -178,6 +212,13 @@ public:
///
////////////////////////////////////////////////////////////
static Vector3f getUpVector();
private:
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
struct Impl;
const std::unique_ptr<Impl> m_impl; //!< Implementation details
};
} // namespace sf::priv

61
src/SFML/Audio/AlResource.cpp → src/SFML/Audio/AudioResource.cpp
View File

@ -25,55 +25,38 @@
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Audio/AlResource.hpp>
#include <SFML/Audio/AudioDevice.hpp>
#include <SFML/Audio/AudioResource.hpp>
#include <memory>
#include <mutex>
namespace
{
// OpenAL resources counter and its mutex
unsigned int count = 0;
std::recursive_mutex mutex;
// The audio device is instantiated on demand rather than at global startup,
// which solves a lot of weird crashes and errors.
// It is destroyed when it is no longer needed.
std::unique_ptr<sf::priv::AudioDevice> globalDevice;
} // namespace
namespace sf
{
////////////////////////////////////////////////////////////
AlResource::AlResource()
AudioResource::AudioResource() :
m_device(
[]()
{
// Ensure we only ever create a single instance of an
// AudioDevice that is shared between all AudioResources
static std::mutex mutex;
static std::weak_ptr<sf::priv::AudioDevice> weakAudioDevice;
std::lock_guard lock(mutex);
auto audioDevice = weakAudioDevice.lock();
if (audioDevice == nullptr)
{
audioDevice = std::make_shared<priv::AudioDevice>();
weakAudioDevice = audioDevice;
}
return audioDevice;
}())
{
// Protect from concurrent access
const std::lock_guard lock(mutex);
// If this is the very first resource, trigger the global device initialization
if (count == 0)
globalDevice = std::make_unique<priv::AudioDevice>();
// Increment the resources counter
++count;
}
////////////////////////////////////////////////////////////
AlResource::~AlResource()
{
// Protect from concurrent access
const std::lock_guard lock(mutex);
// Decrement the resources counter
--count;
// If there's no more resource alive, we can destroy the device
if (count == 0)
globalDevice.reset();
}
} // namespace sf

20
src/SFML/Audio/CMakeLists.txt
View File

@ -4,10 +4,8 @@ set(SRCROOT ${PROJECT_SOURCE_DIR}/src/SFML/Audio)
# all source files
set(SRC
${SRCROOT}/ALCheck.cpp
${SRCROOT}/ALCheck.hpp
${SRCROOT}/AlResource.cpp
${INCROOT}/AlResource.hpp
${SRCROOT}/AudioResource.cpp
${INCROOT}/AudioResource.hpp
${SRCROOT}/AudioDevice.cpp
${SRCROOT}/AudioDevice.hpp
${INCROOT}/Export.hpp
@ -21,6 +19,7 @@ set(SRC
${INCROOT}/SoundBuffer.hpp
${SRCROOT}/SoundBufferRecorder.cpp
${INCROOT}/SoundBufferRecorder.hpp
${INCROOT}/SoundChannel.hpp
${SRCROOT}/InputSoundFile.cpp
${INCROOT}/InputSoundFile.hpp
${SRCROOT}/OutputSoundFile.cpp
@ -57,18 +56,14 @@ set(CODECS_SRC
)
source_group("codecs" FILES ${CODECS_SRC})
# let CMake know about our additional audio libraries paths (on Windows and OSX)
if(SFML_OS_WINDOWS)
list(APPEND CMAKE_INCLUDE_PATH "${PROJECT_SOURCE_DIR}/extlibs/headers/AL")
elseif(SFML_OS_MACOSX)
# let CMake know about our additional audio libraries paths (on Android and OSX)
if(SFML_OS_MACOSX)
list(APPEND CMAKE_LIBRARY_PATH "${PROJECT_SOURCE_DIR}/extlibs/libs-osx/Frameworks")
elseif(SFML_OS_ANDROID)
list(APPEND CMAKE_INCLUDE_PATH "${PROJECT_SOURCE_DIR}/extlibs/headers/AL")
list(APPEND CMAKE_INCLUDE_PATH "${PROJECT_SOURCE_DIR}/extlibs/android")
endif()
# find external libraries
sfml_find_package(OpenAL INCLUDE "OPENAL_INCLUDE_DIR" LINK "OPENAL_LIBRARY")
sfml_find_package(VORBIS INCLUDE "VORBIS_INCLUDE_DIRS" LINK "VORBIS_LIBRARIES")
sfml_find_package(FLAC INCLUDE "FLAC_INCLUDE_DIR" LINK "FLAC_LIBRARY")
@ -83,7 +78,10 @@ sfml_add_library(Audio
# setup dependencies
target_link_libraries(sfml-audio
PUBLIC SFML::System
PRIVATE OpenAL VORBIS FLAC)
PRIVATE VORBIS FLAC)
# miniaudio sources
target_include_directories(sfml-audio SYSTEM PRIVATE "${PROJECT_SOURCE_DIR}/extlibs/headers/miniaudio")
# minimp3 sources
target_include_directories(sfml-audio SYSTEM PRIVATE "${PROJECT_SOURCE_DIR}/extlibs/headers/minimp3")

11
src/SFML/Audio/InputSoundFile.cpp
View File

@ -97,6 +97,7 @@ bool InputSoundFile::openFromFile(const std::filesystem::path& filename)
m_sampleCount = info.sampleCount;
m_channelCount = info.channelCount;
m_sampleRate = info.sampleRate;
m_channelMap = info.channelMap;
return true;
}
@ -132,6 +133,7 @@ bool InputSoundFile::openFromMemory(const void* data, std::size_t sizeInBytes)
m_sampleCount = info.sampleCount;
m_channelCount = info.channelCount;
m_sampleRate = info.sampleRate;
m_channelMap = info.channelMap;
return true;
}
@ -168,6 +170,7 @@ bool InputSoundFile::openFromStream(InputStream& stream)
m_sampleCount = info.sampleCount;
m_channelCount = info.channelCount;
m_sampleRate = info.sampleRate;
m_channelMap = info.channelMap;
return true;
}
@ -194,6 +197,13 @@ unsigned int InputSoundFile::getSampleRate() const
}
////////////////////////////////////////////////////////////
std::vector<SoundChannel> InputSoundFile::getChannelMap() const
{
return m_channelMap;
}
////////////////////////////////////////////////////////////
Time InputSoundFile::getDuration() const
{
@ -270,6 +280,7 @@ void InputSoundFile::close()
m_sampleCount = 0;
m_channelCount = 0;
m_sampleRate = 0;
m_channelMap.clear();
}
} // namespace sf

28
src/SFML/Audio/Listener.cpp
View File

@ -73,6 +73,34 @@ Vector3f Listener::getDirection()
}
////////////////////////////////////////////////////////////
void Listener::setVelocity(const Vector3f& velocity)
{
priv::AudioDevice::setVelocity(velocity);
}
////////////////////////////////////////////////////////////
Vector3f Listener::getVelocity()
{
return priv::AudioDevice::getVelocity();
}
////////////////////////////////////////////////////////////
void Listener::setCone(const Listener::Cone& cone)
{
priv::AudioDevice::setCone(cone);
}
////////////////////////////////////////////////////////////
Listener::Cone Listener::getCone()
{
return priv::AudioDevice::getCone();
}
////////////////////////////////////////////////////////////
void Listener::setUpVector(const Vector3f& upVector)
{

94
src/SFML/Audio/Music.cpp
View File

@ -25,9 +25,10 @@
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Audio/ALCheck.hpp>
#include <SFML/Audio/Music.hpp>
#include <SFML/Audio/InputSoundFile.hpp>
#include <SFML/System/Err.hpp>
#include <SFML/System/Time.hpp>
@ -35,13 +36,29 @@
#include <fstream>
#include <mutex>
#include <ostream>
#include <vector>
#if defined(__APPLE__)
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
namespace sf
{
struct Music::Impl
{
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
InputSoundFile m_file; //!< The streamed music file
std::vector<std::int16_t> m_samples; //!< Temporary buffer of samples
std::recursive_mutex m_mutex; //!< Mutex protecting the data
Span<std::uint64_t> m_loopSpan; //!< Loop Range Specifier
};
////////////////////////////////////////////////////////////
Music::Music() : m_impl(std::make_unique<Impl>())
{
}
////////////////////////////////////////////////////////////
Music::~Music()
{
@ -57,7 +74,7 @@ bool Music::openFromFile(const std::filesystem::path& filename)
stop();
// Open the underlying sound file
if (!m_file.openFromFile(filename))
if (!m_impl->m_file.openFromFile(filename))
return false;
// Perform common initializations
@ -74,7 +91,7 @@ bool Music::openFromMemory(const void* data, std::size_t sizeInBytes)
stop();
// Open the underlying sound file
if (!m_file.openFromMemory(data, sizeInBytes))
if (!m_impl->m_file.openFromMemory(data, sizeInBytes))
return false;
// Perform common initializations
@ -91,7 +108,7 @@ bool Music::openFromStream(InputStream& stream)
stop();
// Open the underlying sound file
if (!m_file.openFromStream(stream))
if (!m_impl->m_file.openFromStream(stream))
return false;
// Perform common initializations
@ -104,14 +121,14 @@ bool Music::openFromStream(InputStream& stream)
////////////////////////////////////////////////////////////
Time Music::getDuration() const
{
return m_file.getDuration();
return m_impl->m_file.getDuration();
}
////////////////////////////////////////////////////////////
Music::TimeSpan Music::getLoopPoints() const
{
return TimeSpan{samplesToTime(m_loopSpan.offset), samplesToTime(m_loopSpan.length)};
return TimeSpan{samplesToTime(m_impl->m_loopSpan.offset), samplesToTime(m_impl->m_loopSpan.length)};
}
@ -121,7 +138,7 @@ void Music::setLoopPoints(TimeSpan timePoints)
Span<std::uint64_t> samplePoints{timeToSamples(timePoints.offset), timeToSamples(timePoints.length)};
// Check our state. This averts a divide-by-zero. GetChannelCount() is cheap enough to use often
if (getChannelCount() == 0 || m_file.getSampleCount() == 0)
if (getChannelCount() == 0 || m_impl->m_file.getSampleCount() == 0)
{
err() << "Music is not in a valid state to assign Loop Points." << std::endl;
return;
@ -134,7 +151,7 @@ void Music::setLoopPoints(TimeSpan timePoints)
samplePoints.length -= (samplePoints.length % getChannelCount());
// Validate
if (samplePoints.offset >= m_file.getSampleCount())
if (samplePoints.offset >= m_impl->m_file.getSampleCount())
{
err() << "LoopPoints offset val must be in range [0, Duration)." << std::endl;
return;
@ -146,23 +163,23 @@ void Music::setLoopPoints(TimeSpan timePoints)
}
// Clamp End Point
samplePoints.length = std::min(samplePoints.length, m_file.getSampleCount() - samplePoints.offset);
samplePoints.length = std::min(samplePoints.length, m_impl->m_file.getSampleCount() - samplePoints.offset);
// If this change has no effect, we can return without touching anything
if (samplePoints.offset == m_loopSpan.offset && samplePoints.length == m_loopSpan.length)
if (samplePoints.offset == m_impl->m_loopSpan.offset && samplePoints.length == m_impl->m_loopSpan.length)
return;
// When we apply this change, we need to "reset" this instance and its buffer
// Get old playing status and position
const Status oldStatus = getStatus();
const Time oldPos = getPlayingOffset();
Status oldStatus = getStatus();
Time oldPos = getPlayingOffset();
// Unload
stop();
// Set
m_loopSpan = samplePoints;
m_impl->m_loopSpan = samplePoints;
// Restore
if (oldPos != Time::Zero)
@ -177,34 +194,34 @@ void Music::setLoopPoints(TimeSpan timePoints)
////////////////////////////////////////////////////////////
bool Music::onGetData(SoundStream::Chunk& data)
{
const std::lock_guard lock(m_mutex);
std::lock_guard lock(m_impl->m_mutex);
std::size_t toFill = m_samples.size();
std::uint64_t currentOffset = m_file.getSampleOffset();
const std::uint64_t loopEnd = m_loopSpan.offset + m_loopSpan.length;
std::size_t toFill = m_impl->m_samples.size();
std::uint64_t currentOffset = m_impl->m_file.getSampleOffset();
std::uint64_t loopEnd = m_impl->m_loopSpan.offset + m_impl->m_loopSpan.length;
// If the loop end is enabled and imminent, request less data.
// This will trip an "onLoop()" call from the underlying SoundStream,
// and we can then take action.
if (getLoop() && (m_loopSpan.length != 0) && (currentOffset <= loopEnd) && (currentOffset + toFill > loopEnd))
if (getLoop() && (m_impl->m_loopSpan.length != 0) && (currentOffset <= loopEnd) && (currentOffset + toFill > loopEnd))
toFill = static_cast<std::size_t>(loopEnd - currentOffset);
// Fill the chunk parameters
data.samples = m_samples.data();
data.sampleCount = static_cast<std::size_t>(m_file.read(m_samples.data(), toFill));
data.samples = m_impl->m_samples.data();
data.sampleCount = static_cast<std::size_t>(m_impl->m_file.read(m_impl->m_samples.data(), toFill));
currentOffset += data.sampleCount;
// Check if we have stopped obtaining samples or reached either the EOF or the loop end point
return (data.sampleCount != 0) && (currentOffset < m_file.getSampleCount()) &&
(currentOffset != loopEnd || m_loopSpan.length == 0);
return (data.sampleCount != 0) && (currentOffset < m_impl->m_file.getSampleCount()) &&
(currentOffset != loopEnd || m_impl->m_loopSpan.length == 0);
}
////////////////////////////////////////////////////////////
void Music::onSeek(Time timeOffset)
{
const std::lock_guard lock(m_mutex);
m_file.seek(timeOffset);
std::lock_guard lock(m_impl->m_mutex);
m_impl->m_file.seek(timeOffset);
}
@ -212,19 +229,20 @@ void Music::onSeek(Time timeOffset)
std::int64_t Music::onLoop()
{
// Called by underlying SoundStream so we can determine where to loop.
const std::lock_guard lock(m_mutex);
const std::uint64_t currentOffset = m_file.getSampleOffset();
if (getLoop() && (m_loopSpan.length != 0) && (currentOffset == m_loopSpan.offset + m_loopSpan.length))
std::lock_guard lock(m_impl->m_mutex);
std::uint64_t currentOffset = m_impl->m_file.getSampleOffset();
if (getLoop() && (m_impl->m_loopSpan.length != 0) &&
(currentOffset == m_impl->m_loopSpan.offset + m_impl->m_loopSpan.length))
{
// Looping is enabled, and either we're at the loop end, or we're at the EOF
// when it's equivalent to the loop end (loop end takes priority). Send us to loop begin
m_file.seek(m_loopSpan.offset);
return static_cast<std::int64_t>(m_file.getSampleOffset());
m_impl->m_file.seek(m_impl->m_loopSpan.offset);
return static_cast<std::int64_t>(m_impl->m_file.getSampleOffset());
}
else if (getLoop() && (currentOffset >= m_file.getSampleCount()))
else if (getLoop() && (currentOffset >= m_impl->m_file.getSampleCount()))
{
// If we're at the EOF, reset to 0
m_file.seek(0);
m_impl->m_file.seek(0);
return 0;
}
return NoLoop;
@ -235,14 +253,14 @@ std::int64_t Music::onLoop()
void Music::initialize()
{
// Compute the music positions
m_loopSpan.offset = 0;
m_loopSpan.length = m_file.getSampleCount();
m_impl->m_loopSpan.offset = 0;
m_impl->m_loopSpan.length = m_impl->m_file.getSampleCount();
// Resize the internal buffer so that it can contain 1 second of audio samples
m_samples.resize(m_file.getSampleRate() * m_file.getChannelCount());
m_impl->m_samples.resize(m_impl->m_file.getSampleRate() * m_impl->m_file.getChannelCount());
// Initialize the stream
SoundStream::initialize(m_file.getChannelCount(), m_file.getSampleRate());
SoundStream::initialize(m_impl->m_file.getChannelCount(), m_impl->m_file.getSampleRate(), m_impl->m_file.getChannelMap());
}
////////////////////////////////////////////////////////////

7
src/SFML/Audio/OutputSoundFile.cpp
View File

@ -37,7 +37,10 @@ OutputSoundFile::OutputSoundFile() = default;
////////////////////////////////////////////////////////////
bool OutputSoundFile::openFromFile(const std::filesystem::path& filename, unsigned int sampleRate, unsigned int channelCount)
bool OutputSoundFile::openFromFile(const std::filesystem::path& filename,
unsigned int sampleRate,
unsigned int channelCount,
const std::vector<SoundChannel>& channelMap)
{
// If the file is already open, first close it
close();
@ -48,7 +51,7 @@ bool OutputSoundFile::openFromFile(const std::filesystem::path& filename, unsign
return false;
// Pass the stream to the reader
if (!m_writer->open(filename, sampleRate, channelCount))
if (!m_writer->open(filename, sampleRate, channelCount, channelMap))
{
close();
return false;

422
src/SFML/Audio/Sound.cpp
View File

@ -25,32 +25,334 @@
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Audio/ALCheck.hpp>
#include <SFML/Audio/Sound.hpp>
#include <SFML/Audio/SoundBuffer.hpp>
#if defined(__APPLE__)
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
#include <SFML/Audio/AudioDevice.hpp>
#include <SFML/Audio/SoundBuffer.hpp>
#include <SFML/System/Err.hpp>
#include <algorithm>
#include <cassert>
#include <limits>
#include <miniaudio.h>
#include <ostream>
namespace sf
{
////////////////////////////////////////////////////////////
Sound::Sound() = default;
struct Sound::Impl
{
Impl()
{
// Set this object up as a miniaudio data source
ma_data_source_config config = ma_data_source_config_init();
static ma_data_source_vtable vtable{read, seek, getFormat, getCursor, getLength, setLooping, 0};
config.vtable = &vtable;
if (auto result = ma_data_source_init(&config, &m_dataSourceBase); result != MA_SUCCESS)
err() << "Failed to initialize audio data source: " << ma_result_description(result) << std::endl;
// Initialize sound structure and set default settings
initialize();
ma_sound_set_pitch(&m_sound, 1.f);
ma_sound_set_pan(&m_sound, 0.f);
ma_sound_set_volume(&m_sound, 1.f);
ma_sound_set_spatialization_enabled(&m_sound, MA_TRUE);
ma_sound_set_position(&m_sound, 0.f, 0.f, 0.f);
ma_sound_set_direction(&m_sound, 0.f, 0.f, -1.f);
ma_sound_set_cone(&m_sound, sf::degrees(360).asRadians(), sf::degrees(360).asRadians(), 0.f); // inner = 360 degrees, outer = 360 degrees, gain = 0
ma_sound_set_directional_attenuation_factor(&m_sound, 1.f);
ma_sound_set_velocity(&m_sound, 0.f, 0.f, 0.f);
ma_sound_set_doppler_factor(&m_sound, 1.f);
ma_sound_set_positioning(&m_sound, ma_positioning_absolute);
ma_sound_set_min_distance(&m_sound, 1.f);
ma_sound_set_max_distance(&m_sound, std::numeric_limits<float>::max());
ma_sound_set_min_gain(&m_sound, 0.f);
ma_sound_set_max_gain(&m_sound, 1.f);
ma_sound_set_rolloff(&m_sound, 1.f);
}
~Impl()
{
ma_sound_uninit(&m_sound);
ma_data_source_uninit(&m_dataSourceBase);
}
void initialize()
{
// Initialize the sound
auto* engine = static_cast<ma_engine*>(priv::AudioDevice::getEngine());
assert(engine != nullptr);
ma_sound_config soundConfig;
soundConfig = ma_sound_config_init();
soundConfig.pDataSource = this;
soundConfig.endCallback = [](void*, ma_sound* sound)
{
// Seek back to the start of the sound when it finishes playing
if (auto result = ma_sound_seek_to_pcm_frame(sound, 0); result != MA_SUCCESS)
err() << "Failed to seek sound to frame 0: " << ma_result_description(result) << std::endl;
};
if (auto result = ma_sound_init_ex(engine, &soundConfig, &m_sound); result != MA_SUCCESS)
err() << "Failed to initialize sound: " << ma_result_description(result) << std::endl;
// Because we are providing a custom data source, we have to provide the channel map ourselves
if (m_buffer && !m_buffer->getChannelMap().empty())
{
m_channelMap.clear();
for (auto channel : m_buffer->getChannelMap())
{
switch (channel)
{
case SoundChannel::Unspecified:
m_channelMap.push_back(MA_CHANNEL_NONE);
break;
case SoundChannel::Mono:
m_channelMap.push_back(MA_CHANNEL_MONO);
break;
case SoundChannel::FrontLeft:
m_channelMap.push_back(MA_CHANNEL_FRONT_LEFT);
break;
case SoundChannel::FrontRight:
m_channelMap.push_back(MA_CHANNEL_FRONT_RIGHT);
break;
case SoundChannel::FrontCenter:
m_channelMap.push_back(MA_CHANNEL_FRONT_CENTER);
break;
case SoundChannel::FrontLeftOfCenter:
m_channelMap.push_back(MA_CHANNEL_FRONT_LEFT_CENTER);
break;
case SoundChannel::FrontRightOfCenter:
m_channelMap.push_back(MA_CHANNEL_FRONT_RIGHT_CENTER);
break;
case SoundChannel::LowFrequencyEffects:
m_channelMap.push_back(MA_CHANNEL_LFE);
break;
case SoundChannel::BackLeft:
m_channelMap.push_back(MA_CHANNEL_BACK_LEFT);
break;
case SoundChannel::BackRight:
m_channelMap.push_back(MA_CHANNEL_BACK_RIGHT);
break;
case SoundChannel::BackCenter:
m_channelMap.push_back(MA_CHANNEL_BACK_CENTER);
break;
case SoundChannel::SideLeft:
m_channelMap.push_back(MA_CHANNEL_SIDE_LEFT);
break;
case SoundChannel::SideRight:
m_channelMap.push_back(MA_CHANNEL_SIDE_RIGHT);
break;
case SoundChannel::TopCenter:
m_channelMap.push_back(MA_CHANNEL_TOP_CENTER);
break;
case SoundChannel::TopFrontLeft:
m_channelMap.push_back(MA_CHANNEL_TOP_FRONT_LEFT);
break;
case SoundChannel::TopFrontRight:
m_channelMap.push_back(MA_CHANNEL_TOP_FRONT_RIGHT);
break;
case SoundChannel::TopFrontCenter:
m_channelMap.push_back(MA_CHANNEL_TOP_FRONT_CENTER);
break;
case SoundChannel::TopBackLeft:
m_channelMap.push_back(MA_CHANNEL_TOP_BACK_LEFT);
break;
case SoundChannel::TopBackRight:
m_channelMap.push_back(MA_CHANNEL_TOP_BACK_RIGHT);
break;
case SoundChannel::TopBackCenter:
m_channelMap.push_back(MA_CHANNEL_TOP_BACK_CENTER);
break;
default:
break;
}
}
m_sound.engineNode.spatializer.pChannelMapIn = m_channelMap.data();
}
else
{
m_sound.engineNode.spatializer.pChannelMapIn = nullptr;
}
}
void reinitialize()
{
// Save and re-apply settings
auto pitch = ma_sound_get_pitch(&m_sound);
auto pan = ma_sound_get_pan(&m_sound);
auto volume = ma_sound_get_volume(&m_sound);
auto spatializationEnabled = ma_sound_is_spatialization_enabled(&m_sound);
auto position = ma_sound_get_position(&m_sound);
auto direction = ma_sound_get_direction(&m_sound);
auto directionalAttenuationFactor = ma_sound_get_directional_attenuation_factor(&m_sound);
auto velocity = ma_sound_get_velocity(&m_sound);
auto dopplerFactor = ma_sound_get_doppler_factor(&m_sound);
auto positioning = ma_sound_get_positioning(&m_sound);
auto minDistance = ma_sound_get_min_distance(&m_sound);
auto maxDistance = ma_sound_get_max_distance(&m_sound);
auto minGain = ma_sound_get_min_gain(&m_sound);
auto maxGain = ma_sound_get_max_gain(&m_sound);
auto rollOff = ma_sound_get_rolloff(&m_sound);
float innerAngle;
float outerAngle;
float outerGain;
ma_sound_get_cone(&m_sound, &innerAngle, &outerAngle, &outerGain);
ma_sound_uninit(&m_sound);
initialize();
ma_sound_set_pitch(&m_sound, pitch);
ma_sound_set_pan(&m_sound, pan);
ma_sound_set_volume(&m_sound, volume);
ma_sound_set_spatialization_enabled(&m_sound, spatializationEnabled);
ma_sound_set_position(&m_sound, position.x, position.y, position.z);
ma_sound_set_direction(&m_sound, direction.x, direction.y, direction.z);
ma_sound_set_directional_attenuation_factor(&m_sound, directionalAttenuationFactor);
ma_sound_set_velocity(&m_sound, velocity.x, velocity.y, velocity.z);
ma_sound_set_doppler_factor(&m_sound, dopplerFactor);
ma_sound_set_positioning(&m_sound, positioning);
ma_sound_set_min_distance(&m_sound, minDistance);
ma_sound_set_max_distance(&m_sound, maxDistance);
ma_sound_set_min_gain(&m_sound, minGain);
ma_sound_set_max_gain(&m_sound, maxGain);
ma_sound_set_rolloff(&m_sound, rollOff);
ma_sound_set_cone(&m_sound, innerAngle, outerAngle, outerGain);
}
static ma_result read(ma_data_source* dataSource, void* framesOut, ma_uint64 frameCount, ma_uint64* framesRead)
{
auto& impl = *static_cast<Impl*>(dataSource);
const auto* buffer = impl.m_buffer;
if (buffer == nullptr)
return MA_NO_DATA_AVAILABLE;
// Determine how many frames we can read
*framesRead = std::min(frameCount, (buffer->getSampleCount() - impl.m_cursor) / buffer->getChannelCount());
// Copy the samples to the output
const auto sampleCount = *framesRead * buffer->getChannelCount();
std::memcpy(framesOut, buffer->getSamples() + impl.m_cursor, sampleCount * sizeof(buffer->getSamples()[0]));
impl.m_cursor += sampleCount;
// If we are looping and at the end of the sound, set the cursor back to the start
if (impl.m_looping && (impl.m_cursor >= buffer->getSampleCount()))
impl.m_cursor = 0;
return MA_SUCCESS;
}
static ma_result seek(ma_data_source* dataSource, ma_uint64 frameIndex)
{
auto& impl = *static_cast<Impl*>(dataSource);
const auto* buffer = impl.m_buffer;
if (buffer == nullptr)
return MA_NO_DATA_AVAILABLE;
impl.m_cursor = frameIndex * buffer->getChannelCount();
return MA_SUCCESS;
}
static ma_result getFormat(ma_data_source* dataSource,
ma_format* format,
ma_uint32* channels,
ma_uint32* sampleRate,
ma_channel*,
size_t)
{
const auto& impl = *static_cast<const Impl*>(dataSource);
const auto* buffer = impl.m_buffer;
// If we don't have valid values yet, initialize with defaults so sound creation doesn't fail
*format = ma_format_s16;
*channels = buffer && buffer->getChannelCount() ? buffer->getChannelCount() : 1;
*sampleRate = buffer && buffer->getSampleRate() ? buffer->getSampleRate() : 44100;
return MA_SUCCESS;
}
static ma_result getCursor(ma_data_source* dataSource, ma_uint64* cursor)
{
const auto& impl = *static_cast<const Impl*>(dataSource);
const auto* buffer = impl.m_buffer;
if (buffer == nullptr)
return MA_NO_DATA_AVAILABLE;
*cursor = impl.m_cursor / buffer->getChannelCount();
return MA_SUCCESS;
}
static ma_result getLength(ma_data_source* dataSource, ma_uint64* length)
{
const auto& impl = *static_cast<const Impl*>(dataSource);
const auto* buffer = impl.m_buffer;
if (buffer == nullptr)
return MA_NO_DATA_AVAILABLE;
*length = buffer->getSampleCount() / buffer->getChannelCount();
return MA_SUCCESS;
}
static ma_result setLooping(ma_data_source* dataSource, ma_bool32 looping)
{
auto& impl = *static_cast<Impl*>(dataSource);
impl.m_looping = (looping == MA_TRUE);
return MA_SUCCESS;
}
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
ma_data_source_base m_dataSourceBase{}; //!< The struct that makes this object a miniaudio data source (must be first member)
std::vector<ma_channel> m_channelMap; //!< The map of position in sample frame to sound channel (miniaudio channels)
ma_sound m_sound{}; //!< The sound
std::size_t m_cursor{}; //!< The current playing position
bool m_looping{}; //!< True if we are looping the sound
const SoundBuffer* m_buffer{}; //!< Sound buffer bound to the source
};
////////////////////////////////////////////////////////////
Sound::Sound(const SoundBuffer& buffer)
Sound::Sound() : m_impl(std::make_unique<Impl>())
{
}
////////////////////////////////////////////////////////////
Sound::Sound(const SoundBuffer& buffer) : m_impl(std::make_unique<Impl>())
{
setBuffer(buffer);
}
////////////////////////////////////////////////////////////
Sound::Sound(const Sound& copy) : SoundSource(copy)
Sound::Sound(const Sound& copy) : m_impl(std::make_unique<Impl>())
{
if (copy.m_buffer)
setBuffer(*copy.m_buffer);
if (copy.m_impl->m_buffer)
setBuffer(*copy.m_impl->m_buffer);
setLoop(copy.getLoop());
}
@ -59,29 +361,38 @@ Sound::Sound(const Sound& copy) : SoundSource(copy)
Sound::~Sound()
{
stop();
if (m_buffer)
m_buffer->detachSound(this);
if (m_impl->m_buffer)
m_impl->m_buffer->detachSound(this);
}
////////////////////////////////////////////////////////////
void Sound::play()
{
alCheck(alSourcePlay(m_source));
if (auto result = ma_sound_start(&m_impl->m_sound); result != MA_SUCCESS)
err() << "Failed to start playing sound: " << ma_result_description(result) << std::endl;
}
////////////////////////////////////////////////////////////
void Sound::pause()
{
alCheck(alSourcePause(m_source));
if (auto result = ma_sound_stop(&m_impl->m_sound); result != MA_SUCCESS)
err() << "Failed to stop playing sound: " << ma_result_description(result) << std::endl;
}
////////////////////////////////////////////////////////////
void Sound::stop()
{
alCheck(alSourceStop(m_source));
if (auto result = ma_sound_stop(&m_impl->m_sound); result != MA_SUCCESS)
{
err() << "Failed to stop playing sound: " << ma_result_description(result) << std::endl;
}
else
{
setPlayingOffset(Time::Zero);
}
}
@ -89,57 +400,78 @@ void Sound::stop()
void Sound::setBuffer(const SoundBuffer& buffer)
{
// First detach from the previous buffer
if (m_buffer)
if (m_impl->m_buffer)
{
stop();
m_buffer->detachSound(this);
// Reset cursor
m_impl->m_cursor = 0;
m_impl->m_buffer->detachSound(this);
}
// Assign and use the new buffer
m_buffer = &buffer;
m_buffer->attachSound(this);
alCheck(alSourcei(m_source, AL_BUFFER, static_cast<ALint>(m_buffer->m_buffer)));
m_impl->m_buffer = &buffer;
m_impl->m_buffer->attachSound(this);
m_impl->reinitialize();
}
////////////////////////////////////////////////////////////
void Sound::setLoop(bool loop)
{
alCheck(alSourcei(m_source, AL_LOOPING, loop));
ma_sound_set_looping(&m_impl->m_sound, loop ? MA_TRUE : MA_FALSE);
}
////////////////////////////////////////////////////////////
void Sound::setPlayingOffset(Time timeOffset)
{
alCheck(alSourcef(m_source, AL_SEC_OFFSET, timeOffset.asSeconds()));
ma_uint32 sampleRate{};
if (auto result = ma_sound_get_data_format(&m_impl->m_sound, nullptr, nullptr, &sampleRate, nullptr, 0);
result != MA_SUCCESS)
err() << "Failed to get sound data format: " << ma_result_description(result) << std::endl;
const auto frameIndex = static_cast<ma_uint64>(timeOffset.asSeconds() * static_cast<double>(sampleRate));
if (auto result = ma_sound_seek_to_pcm_frame(&m_impl->m_sound, frameIndex); result != MA_SUCCESS)
err() << "Failed to seek sound to pcm frame: " << ma_result_description(result) << std::endl;
if (m_impl->m_buffer)
m_impl->m_cursor = frameIndex * m_impl->m_buffer->getChannelCount();
}
////////////////////////////////////////////////////////////
const SoundBuffer* Sound::getBuffer() const
{
return m_buffer;
return m_impl->m_buffer;
}
////////////////////////////////////////////////////////////
bool Sound::getLoop() const
{
ALint loop;
alCheck(alGetSourcei(m_source, AL_LOOPING, &loop));
return loop != 0;
return ma_sound_is_looping(&m_impl->m_sound) == MA_TRUE;
}
////////////////////////////////////////////////////////////
Time Sound::getPlayingOffset() const
{
ALfloat secs = 0.f;
alCheck(alGetSourcef(m_source, AL_SEC_OFFSET, &secs));
if (!m_impl->m_buffer || m_impl->m_buffer->getChannelCount() == 0 || m_impl->m_buffer->getSampleRate() == 0)
return Time();
return seconds(secs);
auto cursor = 0.f;
if (auto result = ma_sound_get_cursor_in_seconds(&m_impl->m_sound, &cursor); result != MA_SUCCESS)
{
err() << "Failed to get sound cursor: " << ma_result_description(result) << std::endl;
return Time();
}
return seconds(cursor);
}
@ -154,8 +486,7 @@ Sound::Status Sound::getStatus() const
Sound& Sound::operator=(const Sound& right)
{
// Here we don't use the copy-and-swap idiom, because it would mess up
// the list of sound instances contained in the buffers and unnecessarily
// destroy/create OpenAL sound sources
// the list of sound instances contained in the buffers
// Handle self-assignment here, as no copy-and-swap idiom is being used
if (this == &right)
@ -165,16 +496,16 @@ Sound& Sound::operator=(const Sound& right)
SoundSource::operator=(right);
// Detach the sound instance from the previous buffer (if any)
if (m_buffer)
if (m_impl->m_buffer)
{
stop();
m_buffer->detachSound(this);
m_buffer = nullptr;
m_impl->m_buffer->detachSound(this);
m_impl->m_buffer = nullptr;
}
// Copy the remaining sound attributes
if (right.m_buffer)
setBuffer(*right.m_buffer);
if (right.m_impl->m_buffer)
setBuffer(*right.m_impl->m_buffer);
setLoop(right.getLoop());
return *this;
@ -188,12 +519,19 @@ void Sound::resetBuffer()
stop();
// Detach the buffer
if (m_buffer)
if (m_impl->m_buffer)
{
alCheck(alSourcei(m_source, AL_BUFFER, 0));
m_buffer->detachSound(this);
m_buffer = nullptr;
// alCheck(alSourcei(m_source, AL_BUFFER, 0));
m_impl->m_buffer->detachSound(this);
m_impl->m_buffer = nullptr;
}
}
////////////////////////////////////////////////////////////
void* Sound::getSound() const
{
return &m_impl->m_sound;
}
} // namespace sf

144
src/SFML/Audio/SoundBuffer.cpp
View File

@ -25,8 +25,6 @@
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Audio/ALCheck.hpp>
#include <SFML/Audio/AudioDevice.hpp>
#include <SFML/Audio/InputSoundFile.hpp>
#include <SFML/Audio/OutputSoundFile.hpp>
#include <SFML/Audio/Sound.hpp>
@ -37,30 +35,48 @@
#include <memory>
#include <ostream>
#include <string>
#include <unordered_set>
#include <vector>
#if defined(__APPLE__)
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
namespace sf
{
////////////////////////////////////////////////////////////
SoundBuffer::SoundBuffer()
struct SoundBuffer::Impl
{
////////////////////////////////////////////////////////////
// Types
////////////////////////////////////////////////////////////
using SoundList = std::unordered_set<Sound*>; //!< Set of unique sound instances
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
std::vector<std::int16_t> m_samples; //!< Samples buffer
unsigned int m_channelCount{1}; //!< Number of channels of the sound
unsigned int m_sampleRate{44100}; //!< Number of samples per second
std::vector<SoundChannel> m_channelMap{SoundChannel::Mono}; //!< The map of position in sample frame to sound channel
Time m_duration; //!< Sound duration
mutable SoundList m_sounds; //!< List of sounds that are using this buffer
};
////////////////////////////////////////////////////////////
SoundBuffer::SoundBuffer() : m_impl(std::make_unique<Impl>())
{
// Create the buffer
alCheck(alGenBuffers(1, &m_buffer));
}
////////////////////////////////////////////////////////////
SoundBuffer::SoundBuffer(const SoundBuffer& copy) : m_samples(copy.m_samples), m_duration(copy.m_duration)
// don't copy the attached sounds
SoundBuffer::SoundBuffer(const SoundBuffer& copy) : SoundBuffer()
{
// Create the buffer
alCheck(alGenBuffers(1, &m_buffer));
// don't copy the attached sounds
m_impl->m_samples = copy.m_impl->m_samples;
m_impl->m_duration = copy.m_impl->m_duration;
// Update the internal buffer with the new samples
if (!update(copy.getChannelCount(), copy.getSampleRate()))
if (!update(copy.getChannelCount(), copy.getSampleRate(), copy.getChannelMap()))
err() << "Failed to update copy-constructed sound buffer" << std::endl;
}
@ -71,16 +87,12 @@ SoundBuffer::~SoundBuffer()
// To prevent the iterator from becoming invalid, move the entire buffer to another
// container. Otherwise calling resetBuffer would result in detachSound being
// called which removes the sound from the internal list.
SoundList sounds;
sounds.swap(m_sounds);
Impl::SoundList sounds;
sounds.swap(m_impl->m_sounds);
// Detach the buffer from the sounds that use it (to avoid OpenAL errors)
// Detach the buffer from the sounds that use it
for (Sound* soundPtr : sounds)
soundPtr->resetBuffer();
// Destroy the buffer
if (m_buffer)
alCheck(alDeleteBuffers(1, &m_buffer));
}
@ -118,18 +130,19 @@ bool SoundBuffer::loadFromStream(InputStream& stream)
////////////////////////////////////////////////////////////
bool SoundBuffer::loadFromSamples(const std::int16_t* samples,
std::uint64_t sampleCount,
unsigned int channelCount,
unsigned int sampleRate)
bool SoundBuffer::loadFromSamples(const std::int16_t* samples,
std::uint64_t sampleCount,
unsigned int channelCount,
unsigned int sampleRate,
const std::vector<SoundChannel>& channelMap)
{
if (samples && sampleCount && channelCount && sampleRate)
if (samples && sampleCount && channelCount && sampleRate && !channelMap.empty())
{
// Copy the new audio samples
m_samples.assign(samples, samples + sampleCount);
m_impl->m_samples.assign(samples, samples + sampleCount);
// Update the internal buffer with the new samples
return update(channelCount, sampleRate);
return update(channelCount, sampleRate, channelMap);
}
else
{
@ -150,10 +163,10 @@ bool SoundBuffer::saveToFile(const std::filesystem::path& filename) const
{
// Create the sound file in write mode
OutputSoundFile file;
if (file.openFromFile(filename, getSampleRate(), getChannelCount()))
if (file.openFromFile(filename, getSampleRate(), getChannelCount(), getChannelMap()))
{
// Write the samples to the opened file
file.write(m_samples.data(), m_samples.size());
file.write(m_impl->m_samples.data(), m_impl->m_samples.size());
return true;
}
@ -167,41 +180,42 @@ bool SoundBuffer::saveToFile(const std::filesystem::path& filename) const
////////////////////////////////////////////////////////////
const std::int16_t* SoundBuffer::getSamples() const
{
return m_samples.empty() ? nullptr : m_samples.data();
return m_impl->m_samples.empty() ? nullptr : m_impl->m_samples.data();
}
////////////////////////////////////////////////////////////
std::uint64_t SoundBuffer::getSampleCount() const
{
return m_samples.size();
return m_impl->m_samples.size();
}
////////////////////////////////////////////////////////////
unsigned int SoundBuffer::getSampleRate() const
{
ALint sampleRate;
alCheck(alGetBufferi(m_buffer, AL_FREQUENCY, &sampleRate));
return static_cast<unsigned int>(sampleRate);
return m_impl->m_sampleRate;
}
////////////////////////////////////////////////////////////
unsigned int SoundBuffer::getChannelCount() const
{
ALint channelCount;
alCheck(alGetBufferi(m_buffer, AL_CHANNELS, &channelCount));
return m_impl->m_channelCount;
}
return static_cast<unsigned int>(channelCount);
////////////////////////////////////////////////////////////
std::vector<SoundChannel> SoundBuffer::getChannelMap() const
{
return m_impl->m_channelMap;
}
////////////////////////////////////////////////////////////
Time SoundBuffer::getDuration() const
{
return m_duration;
return m_impl->m_duration;
}
@ -210,10 +224,12 @@ SoundBuffer& SoundBuffer::operator=(const SoundBuffer& right)
{
SoundBuffer temp(right);
std::swap(m_samples, temp.m_samples);
std::swap(m_buffer, temp.m_buffer);
std::swap(m_duration, temp.m_duration);
std::swap(m_sounds, temp.m_sounds); // swap sounds too, so that they are detached when temp is destroyed
std::swap(m_impl->m_samples, temp.m_impl->m_samples);
std::swap(m_impl->m_channelCount, temp.m_impl->m_channelCount);
std::swap(m_impl->m_sampleRate, temp.m_impl->m_sampleRate);
std::swap(m_impl->m_channelMap, temp.m_impl->m_channelMap);
std::swap(m_impl->m_duration, temp.m_impl->m_duration);
std::swap(m_impl->m_sounds, temp.m_impl->m_sounds); // swap sounds too, so that they are detached when temp is destroyed
return *this;
}
@ -223,16 +239,14 @@ SoundBuffer& SoundBuffer::operator=(const SoundBuffer& right)
bool SoundBuffer::initialize(InputSoundFile& file)
{
// Retrieve the sound parameters
const std::uint64_t sampleCount = file.getSampleCount();
const unsigned int channelCount = file.getChannelCount();
const unsigned int sampleRate = file.getSampleRate();
std::uint64_t sampleCount = file.getSampleCount();
// Read the samples from the provided file
m_samples.resize(static_cast<std::size_t>(sampleCount));
if (file.read(m_samples.data(), sampleCount) == sampleCount)
m_impl->m_samples.resize(static_cast<std::size_t>(sampleCount));
if (file.read(m_impl->m_samples.data(), sampleCount) == sampleCount)
{
// Update the internal buffer with the new samples
return update(channelCount, sampleRate);
return update(file.getChannelCount(), file.getSampleRate(), file.getChannelMap());
}
else
{
@ -242,36 +256,26 @@ bool SoundBuffer::initialize(InputSoundFile& file)
////////////////////////////////////////////////////////////
bool SoundBuffer::update(unsigned int channelCount, unsigned int sampleRate)
bool SoundBuffer::update(unsigned int channelCount, unsigned int sampleRate, const std::vector<SoundChannel>& channelMap)
{
// Check parameters
if (!channelCount || !sampleRate || m_samples.empty())
if (!channelCount || !sampleRate || (channelMap.size() != channelCount))
return false;
// Find the good format according to the number of channels
const ALenum format = priv::AudioDevice::getFormatFromChannelCount(channelCount);
// Check if the format is valid
if (format == 0)
{
err() << "Failed to load sound buffer (unsupported number of channels: " << channelCount << ")" << std::endl;
return false;
}
m_impl->m_channelCount = channelCount;
m_impl->m_sampleRate = sampleRate;
m_impl->m_channelMap = channelMap;
// First make a copy of the list of sounds so we can reattach later
const SoundList sounds(m_sounds);
Impl::SoundList sounds(m_impl->m_sounds);
// Detach the buffer from the sounds that use it (to avoid OpenAL errors)
// Detach the buffer from the sounds that use it
for (Sound* soundPtr : sounds)
soundPtr->resetBuffer();
// Fill the buffer
const auto size = static_cast<ALsizei>(m_samples.size() * sizeof(std::int16_t));
alCheck(alBufferData(m_buffer, format, m_samples.data(), size, static_cast<ALsizei>(sampleRate)));
// Compute the duration
m_duration = seconds(
static_cast<float>(m_samples.size()) / static_cast<float>(sampleRate) / static_cast<float>(channelCount));
m_impl->m_duration = seconds(
static_cast<float>(m_impl->m_samples.size()) / static_cast<float>(sampleRate) / static_cast<float>(channelCount));
// Now reattach the buffer to the sounds that use it
for (Sound* soundPtr : sounds)
@ -284,14 +288,14 @@ bool SoundBuffer::update(unsigned int channelCount, unsigned int sampleRate)
////////////////////////////////////////////////////////////
void SoundBuffer::attachSound(Sound* sound) const
{
m_sounds.insert(sound);
m_impl->m_sounds.insert(sound);
}
////////////////////////////////////////////////////////////
void SoundBuffer::detachSound(Sound* sound) const
{
m_sounds.erase(sound);
m_impl->m_sounds.erase(sound);
}
} // namespace sf

35
src/SFML/Audio/SoundBufferRecorder.cpp
View File

@ -27,15 +27,34 @@
////////////////////////////////////////////////////////////
#include <SFML/Audio/SoundBufferRecorder.hpp>
#include <SFML/Audio/SoundBuffer.hpp>
#include <SFML/System/Err.hpp>
#include <algorithm>
#include <iterator>
#include <ostream>
#include <vector>
namespace sf
{
struct SoundBufferRecorder::Impl
{
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
std::vector<std::int16_t> m_samples; //!< Temporary sample buffer to hold the recorded data
SoundBuffer m_buffer; //!< Sound buffer that will contain the recorded data
};
////////////////////////////////////////////////////////////
SoundBufferRecorder::SoundBufferRecorder() : m_impl(std::make_unique<Impl>())
{
}
////////////////////////////////////////////////////////////
SoundBufferRecorder::~SoundBufferRecorder()
{
@ -47,8 +66,8 @@ SoundBufferRecorder::~SoundBufferRecorder()
////////////////////////////////////////////////////////////
bool SoundBufferRecorder::onStart()
{
m_samples.clear();
m_buffer = SoundBuffer();
m_impl->m_samples.clear();
m_impl->m_buffer = SoundBuffer();
return true;
}
@ -57,7 +76,7 @@ bool SoundBufferRecorder::onStart()
////////////////////////////////////////////////////////////
bool SoundBufferRecorder::onProcessSamples(const std::int16_t* samples, std::size_t sampleCount)
{
std::copy(samples, samples + sampleCount, std::back_inserter(m_samples));
std::copy(samples, samples + sampleCount, std::back_inserter(m_impl->m_samples));
return true;
}
@ -66,10 +85,14 @@ bool SoundBufferRecorder::onProcessSamples(const std::int16_t* samples, std::siz
////////////////////////////////////////////////////////////
void SoundBufferRecorder::onStop()
{
if (m_samples.empty())
if (m_impl->m_samples.empty())
return;
if (!m_buffer.loadFromSamples(m_samples.data(), m_samples.size(), getChannelCount(), getSampleRate()))
if (!m_impl->m_buffer.loadFromSamples(m_impl->m_samples.data(),
m_impl->m_samples.size(),
getChannelCount(),
getSampleRate(),
getChannelMap()))
err() << "Failed to stop capturing audio data" << std::endl;
}
@ -77,7 +100,7 @@ void SoundBufferRecorder::onStop()
////////////////////////////////////////////////////////////
const SoundBuffer& SoundBufferRecorder::getBuffer() const
{
return m_buffer;
return m_impl->m_buffer;
}
} // namespace sf

63
src/SFML/Audio/SoundFileReaderFlac.cpp
View File

@ -172,6 +172,69 @@ void streamMetadata(const FLAC__StreamDecoder*, const FLAC__StreamMetadata* meta
data->info.sampleCount = meta->data.stream_info.total_samples * meta->data.stream_info.channels;
data->info.sampleRate = meta->data.stream_info.sample_rate;
data->info.channelCount = meta->data.stream_info.channels;
// For FLAC channel mapping refer to: https://xiph.org/flac/format.html#frame_header
switch (data->info.channelCount)
{
case 0:
sf::err() << "No channels in FLAC file" << std::endl;
break;
case 1:
data->info.channelMap = {sf::SoundChannel::Mono};
break;
case 2:
data->info.channelMap = {sf::SoundChannel::FrontLeft, sf::SoundChannel::FrontRight};
break;
case 3:
data->info.channelMap = {sf::SoundChannel::FrontLeft,
sf::SoundChannel::FrontRight,
sf::SoundChannel::FrontCenter};
break;
case 4:
data->info.channelMap = {sf::SoundChannel::FrontLeft,
sf::SoundChannel::FrontRight,
sf::SoundChannel::BackLeft,
sf::SoundChannel::BackRight};
break;
case 5:
data->info.channelMap = {sf::SoundChannel::FrontLeft,
sf::SoundChannel::FrontRight,
sf::SoundChannel::FrontCenter,
sf::SoundChannel::BackLeft,
sf::SoundChannel::BackRight};
break;
case 6:
data->info.channelMap = {sf::SoundChannel::FrontLeft,
sf::SoundChannel::FrontRight,
sf::SoundChannel::FrontCenter,
sf::SoundChannel::LowFrequencyEffects,
sf::SoundChannel::BackLeft,
sf::SoundChannel::BackRight};
break;
case 7:
data->info.channelMap = {sf::SoundChannel::FrontLeft,
sf::SoundChannel::FrontRight,
sf::SoundChannel::FrontCenter,
sf::SoundChannel::LowFrequencyEffects,
sf::SoundChannel::BackCenter,
sf::SoundChannel::SideLeft,
sf::SoundChannel::SideRight};
break;
case 8:
data->info.channelMap = {sf::SoundChannel::FrontLeft,
sf::SoundChannel::FrontRight,
sf::SoundChannel::FrontCenter,
sf::SoundChannel::LowFrequencyEffects,
sf::SoundChannel::BackLeft,
sf::SoundChannel::BackRight,
sf::SoundChannel::SideLeft,
sf::SoundChannel::SideRight};
break;
default:
sf::err() << "FLAC files with more than 8 channels not supported" << std::endl;
assert(false);
break;
}
}
}

21
src/SFML/Audio/SoundFileReaderMp3.cpp
View File

@ -52,11 +52,14 @@
#include <SFML/Audio/SoundFileReaderMp3.hpp>
#include <SFML/System/Err.hpp>
#include <SFML/System/InputStream.hpp>
#include <algorithm>
#include <ostream>
#include <cstdint>
#include <cassert>
#include <cstring>
@ -134,6 +137,24 @@ bool SoundFileReaderMp3::open(InputStream& stream, Info& info)
info.sampleRate = static_cast<unsigned int>(m_decoder.info.hz);
info.sampleCount = m_decoder.samples;
// MP3 only supports mono/stereo channels
switch (info.channelCount)
{
case 0:
sf::err() << "No channels in MP3 file" << std::endl;
break;
case 1:
info.channelMap = {sf::SoundChannel::Mono};
break;
case 2:
info.channelMap = {sf::SoundChannel::SideLeft, sf::SoundChannel::SideRight};
break;
default:
sf::err() << "MP3 files with more than 2 channels not supported" << std::endl;
assert(false);
break;
}
m_numSamples = info.sampleCount;
return true;
}

58
src/SFML/Audio/SoundFileReaderOgg.cpp
View File

@ -118,6 +118,64 @@ bool SoundFileReaderOgg::open(InputStream& stream, Info& info)
info.sampleRate = static_cast<unsigned int>(vorbisInfo->rate);
info.sampleCount = static_cast<std::size_t>(ov_pcm_total(&m_vorbis, -1) * vorbisInfo->channels);
// For Vorbis channel mapping refer to: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-810004.3.9
switch (info.channelCount)
{
case 0:
err() << "No channels in Vorbis file" << std::endl;
break;
case 1:
info.channelMap = {SoundChannel::Mono};
break;
case 2:
info.channelMap = {SoundChannel::FrontLeft, SoundChannel::FrontRight};
break;
case 3:
info.channelMap = {SoundChannel::FrontLeft, SoundChannel::FrontCenter, SoundChannel::FrontRight};
break;
case 4:
info.channelMap = {SoundChannel::FrontLeft, SoundChannel::FrontRight, SoundChannel::BackLeft, SoundChannel::BackRight};
break;
case 5:
info.channelMap = {SoundChannel::FrontLeft,
SoundChannel::FrontCenter,
SoundChannel::FrontRight,
SoundChannel::BackLeft,
SoundChannel::BackRight};
break;
case 6:
info.channelMap = {SoundChannel::FrontLeft,
SoundChannel::FrontCenter,
SoundChannel::FrontRight,
SoundChannel::BackLeft,
SoundChannel::BackRight,
SoundChannel::LowFrequencyEffects};
break;
case 7:
info.channelMap = {SoundChannel::FrontLeft,
SoundChannel::FrontCenter,
SoundChannel::FrontRight,
SoundChannel::SideLeft,
SoundChannel::SideRight,
SoundChannel::BackCenter,
SoundChannel::LowFrequencyEffects};
break;
case 8:
info.channelMap = {SoundChannel::FrontLeft,
SoundChannel::FrontCenter,
SoundChannel::FrontRight,
SoundChannel::SideLeft,
SoundChannel::SideRight,
SoundChannel::BackLeft,
SoundChannel::BackRight,
SoundChannel::LowFrequencyEffects};
break;
default:
err() << "Vorbis files with more than 8 channels not supported" << std::endl;
assert(false);
break;
}
// We must keep the channel count for the seek function
m_channelCount = info.channelCount;

83
src/SFML/Audio/SoundFileReaderWav.cpp
View File

@ -307,6 +307,61 @@ bool SoundFileReaderWav::parseHeader(Info& info)
if (!decode(*m_stream, channelMask))
return false;
// For WAVE channel mapping refer to: https://learn.microsoft.com/en-us/previous-versions/windows/hardware/design/dn653308(v=vs.85)#default-channel-ordering
static constexpr auto SPEAKER_FRONT_LEFT = 0x1u;
static constexpr auto SPEAKER_FRONT_RIGHT = 0x2u;
static constexpr auto SPEAKER_FRONT_CENTER = 0x4u;
static constexpr auto SPEAKER_LOW_FREQUENCY = 0x8u;
static constexpr auto SPEAKER_BACK_LEFT = 0x10u;
static constexpr auto SPEAKER_BACK_RIGHT = 0x20u;
static constexpr auto SPEAKER_FRONT_LEFT_OF_CENTER = 0x40u;
static constexpr auto SPEAKER_FRONT_RIGHT_OF_CENTER = 0x80u;
static constexpr auto SPEAKER_BACK_CENTER = 0x100u;
static constexpr auto SPEAKER_SIDE_LEFT = 0x200u;
static constexpr auto SPEAKER_SIDE_RIGHT = 0x400u;
static constexpr auto SPEAKER_TOP_CENTER = 0x800u;
static constexpr auto SPEAKER_TOP_FRONT_LEFT = 0x1000u;
static constexpr auto SPEAKER_TOP_FRONT_CENTER = 0x2000u;
static constexpr auto SPEAKER_TOP_FRONT_RIGHT = 0x4000u;
static constexpr auto SPEAKER_TOP_BACK_LEFT = 0x8000u;
static constexpr auto SPEAKER_TOP_BACK_CENTER = 0x10000u;
static constexpr auto SPEAKER_TOP_BACK_RIGHT = 0x20000u;
info.channelMap.clear();
auto checkChannel = [&](auto bit, auto soundChannel)
{
if ((channelMask & bit) != 0)
info.channelMap.push_back(soundChannel);
};
checkChannel(SPEAKER_FRONT_LEFT, SoundChannel::FrontLeft);
checkChannel(SPEAKER_FRONT_RIGHT, SoundChannel::FrontRight);
checkChannel(SPEAKER_FRONT_CENTER, SoundChannel::FrontCenter);
checkChannel(SPEAKER_LOW_FREQUENCY, SoundChannel::LowFrequencyEffects);
checkChannel(SPEAKER_BACK_LEFT, SoundChannel::BackLeft);
checkChannel(SPEAKER_BACK_RIGHT, SoundChannel::BackRight);
checkChannel(SPEAKER_FRONT_LEFT_OF_CENTER, SoundChannel::FrontLeftOfCenter);
checkChannel(SPEAKER_FRONT_RIGHT_OF_CENTER, SoundChannel::FrontRightOfCenter);
checkChannel(SPEAKER_BACK_CENTER, SoundChannel::BackCenter);
checkChannel(SPEAKER_SIDE_LEFT, SoundChannel::SideLeft);
checkChannel(SPEAKER_SIDE_RIGHT, SoundChannel::SideRight);
checkChannel(SPEAKER_TOP_CENTER, SoundChannel::TopCenter);
checkChannel(SPEAKER_TOP_FRONT_LEFT, SoundChannel::TopFrontLeft);
checkChannel(SPEAKER_TOP_FRONT_CENTER, SoundChannel::TopFrontCenter);
checkChannel(SPEAKER_TOP_FRONT_RIGHT, SoundChannel::TopFrontRight);
checkChannel(SPEAKER_TOP_BACK_LEFT, SoundChannel::TopBackLeft);
checkChannel(SPEAKER_TOP_BACK_CENTER, SoundChannel::TopBackCenter);
checkChannel(SPEAKER_TOP_BACK_RIGHT, SoundChannel::TopBackRight);
assert(info.channelCount == info.channelMap.size());
if (info.channelCount != info.channelMap.size())
{
err() << "WAV sound file channel count does not match number of set bits in channel mask" << std::endl;
return false;
}
// Subformat
char subformat[16];
if (static_cast<std::size_t>(m_stream->read(subformat, static_cast<std::int64_t>(sizeof(subformat)))) !=
@ -328,6 +383,34 @@ bool SoundFileReaderWav::parseHeader(Info& info)
return false;
}
}
else
{
// If we don't have a waveFormatExtensible header, fill the channel map based on a best guess for mono/stereo
info.channelMap.clear();
if (info.channelCount == 0)
{
err() << "WAV sound file channel count 0" << std::endl;
return false;
}
else if (info.channelCount == 1)
{
info.channelMap.push_back(SoundChannel::Mono);
}
else if (info.channelCount == 2)
{
info.channelMap.push_back(SoundChannel::FrontLeft);
info.channelMap.push_back(SoundChannel::FrontRight);
}
else
{
info.channelMap.push_back(SoundChannel::FrontLeft);
info.channelMap.push_back(SoundChannel::FrontRight);
for (auto i = 2u; i < info.channelCount; ++i)
info.channelMap.push_back(SoundChannel::Unspecified);
}
}
// Skip potential extra information
if (m_stream->seek(subChunkStart + subChunkSize) == -1)

86
src/SFML/Audio/SoundFileWriterFlac.cpp
View File

@ -58,8 +58,81 @@ SoundFileWriterFlac::~SoundFileWriterFlac()
////////////////////////////////////////////////////////////
bool SoundFileWriterFlac::open(const std::filesystem::path& filename, unsigned int sampleRate, unsigned int channelCount)
bool SoundFileWriterFlac::open(const std::filesystem::path& filename,
unsigned int sampleRate,
unsigned int channelCount,
const std::vector<SoundChannel>& channelMap)
{
std::vector<SoundChannel> targetChannelMap;
// For FLAC channel mapping refer to: https://xiph.org/flac/format.html#frame_header
switch (channelCount)
{
case 0:
err() << "No channels to write to FLAC file" << std::endl;
return false;
case 1:
targetChannelMap = {SoundChannel::Mono};
break;
case 2:
targetChannelMap = {SoundChannel::FrontLeft, SoundChannel::FrontRight};
break;
case 3:
targetChannelMap = {SoundChannel::FrontLeft, SoundChannel::FrontRight, SoundChannel::FrontCenter};
break;
case 4:
targetChannelMap = {SoundChannel::FrontLeft, SoundChannel::FrontRight, SoundChannel::BackLeft, SoundChannel::BackRight};
break;
case 5:
targetChannelMap = {SoundChannel::FrontLeft,
SoundChannel::FrontRight,
SoundChannel::FrontCenter,
SoundChannel::BackLeft,
SoundChannel::BackRight};
break;
case 6:
targetChannelMap = {SoundChannel::FrontLeft,
SoundChannel::FrontRight,
SoundChannel::FrontCenter,
SoundChannel::LowFrequencyEffects,
SoundChannel::BackLeft,
SoundChannel::BackRight};
break;
case 7:
targetChannelMap = {SoundChannel::FrontLeft,
SoundChannel::FrontRight,
SoundChannel::FrontCenter,
SoundChannel::LowFrequencyEffects,
SoundChannel::BackCenter,
SoundChannel::SideLeft,
SoundChannel::SideRight};
break;
case 8:
targetChannelMap = {SoundChannel::FrontLeft,
SoundChannel::FrontRight,
SoundChannel::FrontCenter,
SoundChannel::LowFrequencyEffects,
SoundChannel::BackLeft,
SoundChannel::BackRight,
SoundChannel::SideLeft,
SoundChannel::SideRight};
break;
default:
err() << "FLAC files with more than 8 channels not supported" << std::endl;
return false;
}
// Check if the channel map contains channels that we cannot remap to a mapping supported by FLAC
if (!std::is_permutation(channelMap.begin(), channelMap.end(), targetChannelMap.begin()))
{
err() << "Provided channel map cannot be reordered to a channel map supported by FLAC" << std::endl;
return false;
}
// Build the remap rable
for (auto i = 0u; i < channelCount; ++i)
m_remapTable[i] = std::find(channelMap.begin(), channelMap.end(), targetChannelMap[i]) - channelMap.begin();
// Create the encoder
m_encoder = FLAC__stream_encoder_new();
if (!m_encoder)
@ -98,8 +171,15 @@ void SoundFileWriterFlac::write(const std::int16_t* samples, std::uint64_t count
// Make sure that we don't process too many samples at once
const unsigned int frames = std::min(static_cast<unsigned int>(count / m_channelCount), 10000u);
// Convert the samples to 32-bits
m_samples32.assign(samples, samples + frames * m_channelCount);
// Convert the samples to 32-bits and remap the channels
m_samples32.clear();
m_samples32.reserve(frames * m_channelCount);
for (auto frame = 0u; frame < frames; ++frame)
{
for (auto channel = 0u; channel < m_channelCount; ++channel)
m_samples32.push_back(samples[frame * m_channelCount + m_remapTable[channel]]);
}
// Write them to the FLAC stream
FLAC__stream_encoder_process_interleaved(m_encoder, m_samples32.data(), frames);

13
src/SFML/Audio/SoundFileWriterFlac.hpp
View File

@ -71,11 +71,15 @@ public:
/// \param filename Path of the file to open
/// \param sampleRate Sample rate of the sound
/// \param channelCount Number of channels of the sound
/// \param channelMap Map of position in sample frame to sound channel
///
/// \return True if the file was successfully opened
///
////////////////////////////////////////////////////////////
[[nodiscard]] bool open(const std::filesystem::path& filename, unsigned int sampleRate, unsigned int channelCount) override;
[[nodiscard]] bool open(const std::filesystem::path& filename,
unsigned int sampleRate,
unsigned int channelCount,
const std::vector<SoundChannel>& channelMap) override;
////////////////////////////////////////////////////////////
/// \brief Write audio samples to the open file
@ -96,9 +100,10 @@ private:
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
FLAC__StreamEncoder* m_encoder{}; //!< FLAC stream encoder
unsigned int m_channelCount{}; //!< Number of channels
std::vector<std::int32_t> m_samples32; //!< Conversion buffer
FLAC__StreamEncoder* m_encoder{}; //!< FLAC stream encoder
unsigned int m_channelCount{}; //!< Number of channels
std::size_t m_remapTable[8]{}; //!< Table we use to remap source to target channel order
std::vector<std::int32_t> m_samples32; //!< Conversion buffer
};
} // namespace sf::priv

83
src/SFML/Audio/SoundFileWriterOgg.cpp
View File

@ -59,8 +59,81 @@ SoundFileWriterOgg::~SoundFileWriterOgg()
////////////////////////////////////////////////////////////
bool SoundFileWriterOgg::open(const std::filesystem::path& filename, unsigned int sampleRate, unsigned int channelCount)
bool SoundFileWriterOgg::open(const std::filesystem::path& filename,
unsigned int sampleRate,
unsigned int channelCount,
const std::vector<SoundChannel>& channelMap)
{
std::vector<SoundChannel> targetChannelMap;
// For Vorbis channel mapping refer to: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-810004.3.9
switch (channelCount)
{
case 0:
err() << "No channels to write to Vorbis file" << std::endl;
return false;
case 1:
targetChannelMap = {SoundChannel::Mono};
break;
case 2:
targetChannelMap = {SoundChannel::FrontLeft, SoundChannel::FrontRight};
break;
case 3:
targetChannelMap = {SoundChannel::FrontLeft, SoundChannel::FrontCenter, SoundChannel::FrontRight};
break;
case 4:
targetChannelMap = {SoundChannel::FrontLeft, SoundChannel::FrontRight, SoundChannel::BackLeft, SoundChannel::BackRight};
break;
case 5:
targetChannelMap = {SoundChannel::FrontLeft,
SoundChannel::FrontCenter,
SoundChannel::FrontRight,
SoundChannel::BackLeft,
SoundChannel::BackRight};
break;
case 6:
targetChannelMap = {SoundChannel::FrontLeft,
SoundChannel::FrontCenter,
SoundChannel::FrontRight,
SoundChannel::BackLeft,
SoundChannel::BackRight,
SoundChannel::LowFrequencyEffects};
break;
case 7:
targetChannelMap = {SoundChannel::FrontLeft,
SoundChannel::FrontCenter,
SoundChannel::FrontRight,
SoundChannel::SideLeft,
SoundChannel::SideRight,
SoundChannel::BackCenter,
SoundChannel::LowFrequencyEffects};
break;
case 8:
targetChannelMap = {SoundChannel::FrontLeft,
SoundChannel::FrontCenter,
SoundChannel::FrontRight,
SoundChannel::SideLeft,
SoundChannel::SideRight,
SoundChannel::BackLeft,
SoundChannel::BackRight,
SoundChannel::LowFrequencyEffects};
break;
default:
err() << "Vorbis files with more than 8 channels not supported" << std::endl;
return false;
}
// Check if the channel map contains channels that we cannot remap to a mapping supported by FLAC
if (!std::is_permutation(channelMap.begin(), channelMap.end(), targetChannelMap.begin()))
{
err() << "Provided channel map cannot be reordered to a channel map supported by Vorbis" << std::endl;
return false;
}
// Build the remap table
for (auto i = 0u; i < channelCount; ++i)
m_remapTable[i] = std::find(channelMap.begin(), channelMap.end(), targetChannelMap[i]) - channelMap.begin();
// Save the channel count
m_channelCount = channelCount;
@ -140,10 +213,14 @@ void SoundFileWriterOgg::write(const std::int16_t* samples, std::uint64_t count)
float** buffer = vorbis_analysis_buffer(&m_state, bufferSize);
assert(buffer);
// Write the samples to the buffer, converted to float
// Write the samples to the buffer, converted to float and remapped to target channels
for (int i = 0; i < std::min(frameCount, bufferSize); ++i)
{
for (unsigned int j = 0; j < m_channelCount; ++j)
buffer[j][i] = *samples++ / 32767.0f;
buffer[j][i] = samples[m_remapTable[j]] / 32767.0f;
samples += m_channelCount;
}
// Tell the library how many samples we've written
vorbis_analysis_wrote(&m_state, std::min(frameCount, bufferSize));

17
src/SFML/Audio/SoundFileWriterOgg.hpp
View File

@ -72,11 +72,15 @@ public:
/// \param filename Path of the file to open
/// \param sampleRate Sample rate of the sound
/// \param channelCount Number of channels of the sound
/// \param channelMap Map of position in sample frame to sound channel
///
/// \return True if the file was successfully opened
///
////////////////////////////////////////////////////////////
[[nodiscard]] bool open(const std::filesystem::path& filename, unsigned int sampleRate, unsigned int channelCount) override;
[[nodiscard]] bool open(const std::filesystem::path& filename,
unsigned int sampleRate,
unsigned int channelCount,
const std::vector<SoundChannel>& channelMap) override;
////////////////////////////////////////////////////////////
/// \brief Write audio samples to the open file
@ -103,11 +107,12 @@ private:
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
unsigned int m_channelCount{}; // channel count of the sound being written
std::ofstream m_file; // output file
ogg_stream_state m_ogg{}; // ogg stream
vorbis_info m_vorbis{}; // vorbis handle
vorbis_dsp_state m_state{}; // current encoding state
unsigned int m_channelCount{}; //!< Channel count of the sound being written
std::size_t m_remapTable[8]{}; //!< Table we use to remap source to target channel order
std::ofstream m_file; //!< Output file
ogg_stream_state m_ogg{}; //!< OGG stream
vorbis_info m_vorbis{}; //!< Vorbis handle
vorbis_dsp_state m_state{}; //!< Current encoding state
};
} // namespace sf::priv

186
src/SFML/Audio/SoundFileWriterWav.cpp
View File

@ -30,8 +30,10 @@
#include <SFML/System/Err.hpp>
#include <SFML/System/Utils.hpp>
#include <algorithm>
#include <ostream>
#include <cstdint>
#include <cassert>
#include <cstddef>
@ -86,8 +88,127 @@ SoundFileWriterWav::~SoundFileWriterWav()
////////////////////////////////////////////////////////////
bool SoundFileWriterWav::open(const std::filesystem::path& filename, unsigned int sampleRate, unsigned int channelCount)
bool SoundFileWriterWav::open(const std::filesystem::path& filename,
unsigned int sampleRate,
unsigned int channelCount,
const std::vector<SoundChannel>& channelMap)
{
auto channelMask = 0u;
if (channelCount == 0)
{
err() << "WAV sound file channel count 0" << std::endl;
return false;
}
else if (channelCount == 1)
{
m_remapTable[0] = 0;
}
else if (channelCount == 2)
{
m_remapTable[0] = 0;
m_remapTable[1] = 1;
}
else
{
// For WAVE channel mapping refer to: https://learn.microsoft.com/en-us/previous-versions/windows/hardware/design/dn653308(v=vs.85)#default-channel-ordering
static constexpr auto SPEAKER_FRONT_LEFT = 0x1u;
static constexpr auto SPEAKER_FRONT_RIGHT = 0x2u;
static constexpr auto SPEAKER_FRONT_CENTER = 0x4u;
static constexpr auto SPEAKER_LOW_FREQUENCY = 0x8u;
static constexpr auto SPEAKER_BACK_LEFT = 0x10u;
static constexpr auto SPEAKER_BACK_RIGHT = 0x20u;
static constexpr auto SPEAKER_FRONT_LEFT_OF_CENTER = 0x40u;
static constexpr auto SPEAKER_FRONT_RIGHT_OF_CENTER = 0x80u;
static constexpr auto SPEAKER_BACK_CENTER = 0x100u;
static constexpr auto SPEAKER_SIDE_LEFT = 0x200u;
static constexpr auto SPEAKER_SIDE_RIGHT = 0x400u;
static constexpr auto SPEAKER_TOP_CENTER = 0x800u;
static constexpr auto SPEAKER_TOP_FRONT_LEFT = 0x1000u;
static constexpr auto SPEAKER_TOP_FRONT_CENTER = 0x2000u;
static constexpr auto SPEAKER_TOP_FRONT_RIGHT = 0x4000u;
static constexpr auto SPEAKER_TOP_BACK_LEFT = 0x8000u;
static constexpr auto SPEAKER_TOP_BACK_CENTER = 0x10000u;
static constexpr auto SPEAKER_TOP_BACK_RIGHT = 0x20000u;
struct SupportedChannel
{
std::uint32_t bit;
SoundChannel channel;
};
std::vector<SupportedChannel> targetChannelMap;
targetChannelMap.push_back(SupportedChannel{SPEAKER_FRONT_LEFT, SoundChannel::FrontLeft});
targetChannelMap.push_back(SupportedChannel{SPEAKER_FRONT_RIGHT, SoundChannel::FrontRight});
targetChannelMap.push_back(SupportedChannel{SPEAKER_FRONT_CENTER, SoundChannel::FrontCenter});
targetChannelMap.push_back(SupportedChannel{SPEAKER_LOW_FREQUENCY, SoundChannel::LowFrequencyEffects});
targetChannelMap.push_back(SupportedChannel{SPEAKER_BACK_LEFT, SoundChannel::BackLeft});
targetChannelMap.push_back(SupportedChannel{SPEAKER_BACK_RIGHT, SoundChannel::BackRight});
targetChannelMap.push_back(SupportedChannel{SPEAKER_FRONT_LEFT_OF_CENTER, SoundChannel::FrontLeftOfCenter});
targetChannelMap.push_back(SupportedChannel{SPEAKER_FRONT_RIGHT_OF_CENTER, SoundChannel::FrontRightOfCenter});
targetChannelMap.push_back(SupportedChannel{SPEAKER_BACK_CENTER, SoundChannel::BackCenter});
targetChannelMap.push_back(SupportedChannel{SPEAKER_SIDE_LEFT, SoundChannel::SideLeft});
targetChannelMap.push_back(SupportedChannel{SPEAKER_SIDE_RIGHT, SoundChannel::SideRight});
targetChannelMap.push_back(SupportedChannel{SPEAKER_TOP_CENTER, SoundChannel::TopCenter});
targetChannelMap.push_back(SupportedChannel{SPEAKER_TOP_FRONT_LEFT, SoundChannel::TopFrontLeft});
targetChannelMap.push_back(SupportedChannel{SPEAKER_TOP_FRONT_CENTER, SoundChannel::TopFrontCenter});
targetChannelMap.push_back(SupportedChannel{SPEAKER_TOP_FRONT_RIGHT, SoundChannel::TopFrontRight});
targetChannelMap.push_back(SupportedChannel{SPEAKER_TOP_BACK_LEFT, SoundChannel::TopBackLeft});
targetChannelMap.push_back(SupportedChannel{SPEAKER_TOP_BACK_CENTER, SoundChannel::TopBackCenter});
targetChannelMap.push_back(SupportedChannel{SPEAKER_TOP_BACK_RIGHT, SoundChannel::TopBackRight});
// Check for duplicate channel entries
{
auto sortedChannelMap = channelMap;
std::sort(sortedChannelMap.begin(), sortedChannelMap.end());
if (std::adjacent_find(sortedChannelMap.begin(), sortedChannelMap.end()) != sortedChannelMap.end())
{
err() << "Duplicate channels in channel map" << std::endl;
return false;
}
}
// Construct the target channel map by removing unused channels
for (auto iter = targetChannelMap.begin(); iter != targetChannelMap.end();)
{
if (std::find(channelMap.begin(), channelMap.end(), iter->channel) == channelMap.end())
{
iter = targetChannelMap.erase(iter);
}
else
{
++iter;
}
}
// Verify that all the input channels exist in the target channel map
for (auto channel : channelMap)
{
if (std::find_if(targetChannelMap.begin(),
targetChannelMap.end(),
[channel](const SupportedChannel& c) { return c.channel == channel; }) ==
targetChannelMap.end())
{
err() << "Could not map all input channels to a channel supported by WAV" << std::endl;
return false;
}
}
// Build the remap table
for (auto i = 0u; i < channelCount; ++i)
m_remapTable[i] = std::find(channelMap.begin(), channelMap.end(), targetChannelMap[i].channel) -
channelMap.begin();
// Generate the channel mask
for (const auto& channel : targetChannelMap)
channelMask |= channel.bit;
}
// Save the channel count
m_channelCount = channelCount;
// Open the file
m_file.open(filename, std::ios::binary);
if (!m_file)
@ -97,7 +218,7 @@ bool SoundFileWriterWav::open(const std::filesystem::path& filename, unsigned in
}
// Write the header
if (!writeHeader(sampleRate, channelCount))
if (!writeHeader(sampleRate, channelCount, channelMask))
{
err() << "Failed to write header of WAV sound file\n" << formatDebugPathInfo(filename) << std::endl;
return false;
@ -111,14 +232,24 @@ bool SoundFileWriterWav::open(const std::filesystem::path& filename, unsigned in
void SoundFileWriterWav::write(const std::int16_t* samples, std::uint64_t count)
{
assert(m_file.good());
assert(count % m_channelCount == 0);
while (count--)
encode(m_file, *samples++);
if (count % m_channelCount != 0)
err() << "Writing samples to WAV sound file requires writing full frames at a time" << std::endl;
while (count >= m_channelCount)
{
for (auto i = 0u; i < m_channelCount; ++i)
encode(m_file, samples[m_remapTable[i]]);
samples += m_channelCount;
count -= m_channelCount;
}
}
////////////////////////////////////////////////////////////
bool SoundFileWriterWav::writeHeader(unsigned int sampleRate, unsigned int channelCount)
bool SoundFileWriterWav::writeHeader(unsigned int sampleRate, unsigned int channelCount, unsigned int channelMask)
{
assert(m_file.good());
@ -134,27 +265,52 @@ bool SoundFileWriterWav::writeHeader(unsigned int sampleRate, unsigned int chann
// Write the sub-chunk 1 ("format") id and size
char fmtChunkId[4] = {'f', 'm', 't', ' '};
m_file.write(fmtChunkId, sizeof(fmtChunkId));
const std::uint32_t fmtChunkSize = 16;
encode(m_file, fmtChunkSize);
// Write the format (PCM)
const std::uint16_t format = 1;
encode(m_file, format);
if (channelCount > 2)
{
std::uint32_t fmtChunkSize = 40;
encode(m_file, fmtChunkSize);
// Write the format (Extensible)
std::uint16_t format = 65534;
encode(m_file, format);
}
else
{
std::uint32_t fmtChunkSize = 16;
encode(m_file, fmtChunkSize);
// Write the format (PCM)
std::uint16_t format = 1;
encode(m_file, format);
}
// Write the sound attributes
encode(m_file, static_cast<std::uint16_t>(channelCount));
encode(m_file, sampleRate);
const std::uint32_t byteRate = sampleRate * channelCount * 2;
std::uint32_t byteRate = sampleRate * channelCount * 2;
encode(m_file, byteRate);
const auto blockAlign = static_cast<std::uint16_t>(channelCount * 2);
auto blockAlign = static_cast<std::uint16_t>(channelCount * 2);
encode(m_file, blockAlign);
const std::uint16_t bitsPerSample = 16;
std::uint16_t bitsPerSample = 16;
encode(m_file, bitsPerSample);
if (channelCount > 2)
{
std::uint16_t extensionSize = 16;
encode(m_file, extensionSize);
encode(m_file, bitsPerSample);
encode(m_file, channelMask);
// Write the subformat (PCM)
char subformat[16] =
{'\x01', '\x00', '\x00', '\x00', '\x00', '\x00', '\x10', '\x00', '\x80', '\x00', '\x00', '\xAA', '\x00', '\x38', '\x9B', '\x71'};
m_file.write(subformat, sizeof(subformat));
}
// Write the sub-chunk 2 ("data") id and size
char dataChunkId[4] = {'d', 'a', 't', 'a'};
m_file.write(dataChunkId, sizeof(dataChunkId));
const std::uint32_t dataChunkSize = 0; // placeholder, will be written later
std::uint32_t dataChunkSize = 0; // placeholder, will be written later
encode(m_file, dataChunkSize);
return true;
@ -170,7 +326,7 @@ void SoundFileWriterWav::close()
m_file.flush();
// Update the main chunk size and data sub-chunk size
const std::uint32_t fileSize = static_cast<std::uint32_t>(m_file.tellp());
std::uint32_t fileSize = static_cast<std::uint32_t>(m_file.tellp());
m_file.seekp(4);
encode(m_file, fileSize - 8); // 8 bytes RIFF header
m_file.seekp(40);

13
src/SFML/Audio/SoundFileWriterWav.hpp
View File

@ -70,11 +70,15 @@ public:
/// \param filename Path of the file to open
/// \param sampleRate Sample rate of the sound
/// \param channelCount Number of channels of the sound
/// \param channelMap Map of position in sample frame to sound channel
///
/// \return True if the file was successfully opened
///
////////////////////////////////////////////////////////////
[[nodiscard]] bool open(const std::filesystem::path& filename, unsigned int sampleRate, unsigned int channelCount) override;
[[nodiscard]] bool open(const std::filesystem::path& filename,
unsigned int sampleRate,
unsigned int channelCount,
const std::vector<SoundChannel>& channelMap) override;
////////////////////////////////////////////////////////////
/// \brief Write audio samples to the open file
@ -91,11 +95,12 @@ private:
///
/// \param sampleRate Sample rate of the sound
/// \param channelCount Number of channels of the sound
/// \param channelMask Channel mask bits if we are writing extensible header
///
/// \return True on success, false on error
///
////////////////////////////////////////////////////////////
[[nodiscard]] bool writeHeader(unsigned int sampleRate, unsigned int channelCount);
[[nodiscard]] bool writeHeader(unsigned int sampleRate, unsigned int channelCount, unsigned int channelMask);
////////////////////////////////////////////////////////////
/// \brief Close the file
@ -106,7 +111,9 @@ private:
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
std::ofstream m_file; //!< File stream to write to
std::ofstream m_file; //!< File stream to write to
unsigned int m_channelCount{}; //!< Channel count of the sound being written
std::size_t m_remapTable[18]{}; //!< Table we use to remap source to target channel order
};
} // namespace sf::priv

437
src/SFML/Audio/SoundRecorder.cpp
View File

@ -25,35 +25,181 @@
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Audio/ALCheck.hpp>
#include <SFML/Audio/AudioDevice.hpp>
#include <SFML/Audio/SoundRecorder.hpp>
#include <SFML/System/Err.hpp>
#include <SFML/System/Sleep.hpp>
#include <miniaudio.h>
#include <algorithm>
#include <optional>
#include <ostream>
#include <cassert>
#include <cstring>
#ifdef _MSC_VER
#pragma warning(disable : 4355) // 'this' used in base member initializer list
#endif
#if defined(__APPLE__)
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
namespace
{
ALCdevice* captureDevice = nullptr;
}
namespace sf
{
struct SoundRecorder::Impl
{
Impl(SoundRecorder* owner) : m_owner(owner)
{
}
bool initialize()
{
if (!m_context)
return false;
// Find the device by its name
auto devices = getAvailableDevices();
auto iter = std::find_if(devices.begin(),
devices.end(),
[this](const ma_device_info& info) { return info.name == m_deviceName; });
if (iter == devices.end())
return false;
// (Re-)create the capture device
if (m_captureDevice)
{
ma_device_uninit(&*m_captureDevice);
}
else
{
m_captureDevice.emplace();
}
auto captureDeviceConfig = ma_device_config_init(ma_device_type_capture);
captureDeviceConfig.capture.pDeviceID = &iter->id;
captureDeviceConfig.capture.channels = m_channelCount;
captureDeviceConfig.capture.format = ma_format_s16;
captureDeviceConfig.sampleRate = m_sampleRate;
captureDeviceConfig.pUserData = this;
captureDeviceConfig.dataCallback = [](ma_device* device, void*, const void* input, ma_uint32 frameCount)
{
auto& impl = *static_cast<Impl*>(device->pUserData);
// Copy the new samples into our temporary buffer
impl.m_samples.resize(frameCount * impl.m_channelCount);
std::memcpy(impl.m_samples.data(), input, frameCount * impl.m_channelCount * sizeof(std::int16_t));
// Notify the derived class of the availability of new samples
if (!impl.m_owner->onProcessSamples(impl.m_samples.data(), impl.m_samples.size()))
{
// If the derived class wants to stop, stop the capture
if (auto result = ma_device_stop(device); result != MA_SUCCESS)
{
err() << "Failed to stop audio capture device: " << ma_result_description(result) << std::endl;
return;
}
}
};
if (auto result = ma_device_init(&*m_context, &captureDeviceConfig, &*m_captureDevice); result != MA_SUCCESS)
{
m_captureDevice.reset();
err() << "Failed to initialize the audio capture device: " << ma_result_description(result) << std::endl;
return false;
}
return true;
}
static std::vector<ma_device_info> getAvailableDevices()
{
std::vector<ma_device_info> deviceList;
// Create the context
ma_context context;
auto contextConfig = ma_context_config_init();
if (auto result = ma_context_init(nullptr, 0, &contextConfig, &context); result != MA_SUCCESS)
{
err() << "Failed to initialize the audio context: " << ma_result_description(result) << std::endl;
return deviceList;
}
// Enumerate the capture devices
ma_device_info* deviceInfos;
ma_uint32 deviceCount;
if (auto result = ma_context_get_devices(&context, nullptr, nullptr, &deviceInfos, &deviceCount);
result != MA_SUCCESS)
{
err() << "Failed to get audio capture devices: " << ma_result_description(result) << std::endl;
ma_context_uninit(&context);
return deviceList;
}
for (auto i = 0u; i < deviceCount; ++i)
deviceList.push_back(deviceInfos[i]);
ma_context_uninit(&context);
return deviceList;
}
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
SoundRecorder* const m_owner; //!< Owning SoundRecorder object
std::optional<ma_log> m_log; //!< The miniaudio log
std::optional<ma_context> m_context; //!< The miniaudio context
std::optional<ma_device> m_captureDevice; //!< The miniaudio capture device
std::string m_deviceName{getDefaultDevice()}; //!< Name of the audio capture device
unsigned int m_channelCount{1}; //!< Number of recording channels
unsigned int m_sampleRate{44100}; //!< Sample rate
std::vector<std::int16_t> m_samples; //!< Buffer to store captured samples
};
////////////////////////////////////////////////////////////
SoundRecorder::SoundRecorder() = default;
SoundRecorder::SoundRecorder() : m_impl(std::make_unique<Impl>(this))
{
// Create the log
m_impl->m_log.emplace();
if (auto result = ma_log_init(nullptr, &*m_impl->m_log); result != MA_SUCCESS)
{
m_impl->m_log.reset();
err() << "Failed to initialize the audio log: " << ma_result_description(result) << std::endl;
return;
}
// Register our logging callback to output any warning/error messages
if (auto result = ma_log_register_callback(&*m_impl->m_log,
ma_log_callback_init(
[](void*, ma_uint32 level, const char* message)
{
if (level <= MA_LOG_LEVEL_WARNING)
err() << "miniaudio " << ma_log_level_to_string(level)
<< ": " << message << std::flush;
},
nullptr));
result != MA_SUCCESS)
err() << "Failed to register audio log callback: " << ma_result_description(result) << std::endl;
// Create the context
m_impl->m_context.emplace();
auto contextConfig = ma_context_config_init();
contextConfig.pLog = &*m_impl->m_log;
if (auto result = ma_context_init(nullptr, 0, &contextConfig, &*m_impl->m_context); result != MA_SUCCESS)
{
m_impl->m_context.reset();
err() << "Failed to initialize the audio context: " << ma_result_description(result) << std::endl;
return;
}
// Create the capture device
m_impl->initialize();
}
////////////////////////////////////////////////////////////
@ -61,12 +207,24 @@ SoundRecorder::~SoundRecorder()
{
// This assertion is triggered if the recording is still running while
// the object is destroyed. It ensures that stop() is called in the
// destructor of the derived class, which makes sure that the recording
// thread finishes before the derived object is destroyed. Otherwise a
// destructor of the derived class, which makes sure that the capture
// device is stopped before the derived object is destroyed. Otherwise a
// "pure virtual method called" exception is triggered.
assert(!m_isCapturing &&
"You must call stop() in the destructor of your derived class, so that the recording thread finishes before "
"your object is destroyed.");
assert(!(m_impl->m_captureDevice && ma_device_is_started(&*m_impl->m_captureDevice)) &&
"You must call stop() in the destructor of your derived class, so that the "
"capture device is stopped before your object is destroyed.");
// Destroy the capture device
if (m_impl->m_captureDevice)
ma_device_uninit(&*m_impl->m_captureDevice);
// Destroy the context
if (m_impl->m_context)
ma_context_uninit(&*m_impl->m_context);
// Destroy the log
if (m_impl->m_log)
ma_log_uninit(&*m_impl->m_log);
}
@ -82,38 +240,41 @@ bool SoundRecorder::start(unsigned int sampleRate)
return false;
}
// Store the sample rate and re-initialize if necessary
if (m_impl->m_sampleRate != sampleRate)
{
m_impl->m_sampleRate = sampleRate;
if (!m_impl->initialize())
{
err() << "Failed to set audio capture device sample rate to " << sampleRate << std::endl;
return false;
}
}
// Ensure we have a capture device
if (!m_impl->m_captureDevice)
{
err() << "Trying to start audio capture, but no device available" << std::endl;
return false;
}
// Check that another capture is not already running
if (captureDevice)
if (ma_device_is_started(&*m_impl->m_captureDevice))
{
err() << "Trying to start audio capture, but another capture is already running" << std::endl;
return false;
}
// Determine the recording format
const ALCenum format = (m_channelCount == 1) ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16;
// Open the capture device for capturing 16 bits samples
captureDevice = alcCaptureOpenDevice(m_deviceName.c_str(), sampleRate, format, static_cast<ALCsizei>(sampleRate));
if (!captureDevice)
{
err() << "Failed to open the audio capture device with the name: " << m_deviceName << std::endl;
return false;
}
// Clear the array of samples
m_samples.clear();
// Store the sample rate
m_sampleRate = sampleRate;
// Notify derived class
if (onStart())
{
// Start the capture
alcCaptureStart(captureDevice);
// Start the capture in a new thread, to avoid blocking the main thread
launchCapturingThread();
if (auto result = ma_device_start(&*m_impl->m_captureDevice); result != MA_SUCCESS)
{
err() << "Failed to start audio capture device: " << ma_result_description(result) << std::endl;
return false;
}
return true;
}
@ -125,10 +286,15 @@ bool SoundRecorder::start(unsigned int sampleRate)
////////////////////////////////////////////////////////////
void SoundRecorder::stop()
{
// Stop the capturing thread if there is one
if (m_isCapturing)
// Stop the capturing device if one is started
if (m_impl->m_captureDevice && ma_device_is_started(&*m_impl->m_captureDevice))
{
awaitCapturingThread();
// Stop the capture
if (auto result = ma_device_stop(&*m_impl->m_captureDevice); result != MA_SUCCESS)
{
err() << "Failed to stop audio capture device: " << ma_result_description(result) << std::endl;
return;
}
// Notify derived class
onStop();
@ -139,24 +305,19 @@ void SoundRecorder::stop()
////////////////////////////////////////////////////////////
unsigned int SoundRecorder::getSampleRate() const
{
return m_sampleRate;
return m_impl->m_sampleRate;
}
////////////////////////////////////////////////////////////
std::vector<std::string> SoundRecorder::getAvailableDevices()
{
// Convert the internal miniaudio device list into a name-only list
std::vector<std::string> deviceNameList;
const auto devices = Impl::getAvailableDevices();
const ALchar* deviceList = alcGetString(nullptr, ALC_CAPTURE_DEVICE_SPECIFIER);
if (deviceList)
{
while (*deviceList)
{
deviceNameList.emplace_back(deviceList);
deviceList += std::strlen(deviceList) + 1;
}
}
for (const auto& device : devices)
deviceNameList.push_back(device.name);
return deviceNameList;
}
@ -165,43 +326,28 @@ std::vector<std::string> SoundRecorder::getAvailableDevices()
////////////////////////////////////////////////////////////
std::string SoundRecorder::getDefaultDevice()
{
return alcGetString(nullptr, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
const auto devices = Impl::getAvailableDevices();
for (const auto& device : devices)
{
if (device.isDefault)
return device.name;
}
return "";
}
////////////////////////////////////////////////////////////
bool SoundRecorder::setDevice(const std::string& name)
{
// Store the device name
if (name.empty())
m_deviceName = getDefaultDevice();
else
m_deviceName = name;
if (m_isCapturing)
// Store the device name and re-initialize if necessary
if (m_impl->m_deviceName != name)
{
// Stop the capturing thread
awaitCapturingThread();
m_impl->m_deviceName = name;
// Determine the recording format
const ALCenum format = (m_channelCount == 1) ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16;
// Open the requested capture device for capturing 16 bits samples
captureDevice = alcCaptureOpenDevice(m_deviceName.c_str(), m_sampleRate, format, static_cast<ALCsizei>(m_sampleRate));
if (!captureDevice)
{
// Notify derived class
onStop();
err() << "Failed to open the audio capture device with the name: " << m_deviceName << std::endl;
if (!m_impl->initialize())
return false;
}
// Start the capture
alcCaptureStart(captureDevice);
// Start the capture in a new thread, to avoid blocking the main thread
launchCapturingThread();
}
return true;
@ -211,19 +357,14 @@ bool SoundRecorder::setDevice(const std::string& name)
////////////////////////////////////////////////////////////
const std::string& SoundRecorder::getDevice() const
{
return m_deviceName;
return m_impl->m_deviceName;
}
////////////////////////////////////////////////////////////
void SoundRecorder::setChannelCount(unsigned int channelCount)
{
if (m_isCapturing)
{
err() << "It's not possible to change the channels while recording." << std::endl;
return;
}
// We only bother supporting mono/stereo recording for now
if (channelCount < 1 || channelCount > 2)
{
err() << "Unsupported channel count: " << channelCount
@ -231,29 +372,54 @@ void SoundRecorder::setChannelCount(unsigned int channelCount)
return;
}
m_channelCount = channelCount;
// Store the channel count and re-initialize if necessary
if (m_impl->m_channelCount != channelCount)
{
m_impl->m_channelCount = channelCount;
m_impl->initialize();
}
}
////////////////////////////////////////////////////////////
unsigned int SoundRecorder::getChannelCount() const
{
return m_channelCount;
return m_impl->m_channelCount;
}
////////////////////////////////////////////////////////////
std::vector<SoundChannel> SoundRecorder::getChannelMap() const
{
// We only bother supporting mono/stereo recording for now
if (m_impl->m_channelCount == 1)
{
return {SoundChannel::Mono};
}
else if (m_impl->m_channelCount == 2)
{
return {SoundChannel::FrontLeft, SoundChannel::FrontRight};
}
else
{
return {};
}
}
////////////////////////////////////////////////////////////
bool SoundRecorder::isAvailable()
{
return (priv::AudioDevice::isExtensionSupported("ALC_EXT_CAPTURE") != AL_FALSE) ||
(priv::AudioDevice::isExtensionSupported("ALC_EXT_capture") != AL_FALSE); // "bug" in Mac OS X 10.5 and 10.6
}
// Try to open a device for capture to see if recording is available
auto config = ma_device_config_init(ma_device_type_capture);
ma_device device;
if (ma_device_init(nullptr, &config, &device) != MA_SUCCESS)
return false;
////////////////////////////////////////////////////////////
void SoundRecorder::setProcessingInterval(Time interval)
{
m_processingInterval = interval;
ma_device_uninit(&device);
return true;
}
@ -271,79 +437,4 @@ void SoundRecorder::onStop()
// Nothing to do
}
////////////////////////////////////////////////////////////
void SoundRecorder::record()
{
while (m_isCapturing)
{
// Process available samples
processCapturedSamples();
// Don't bother the CPU while waiting for more captured data
sleep(m_processingInterval);
}
// Capture is finished: clean up everything
cleanup();
}
////////////////////////////////////////////////////////////
void SoundRecorder::processCapturedSamples()
{
// Get the number of samples available
ALCint samplesAvailable;
alcGetIntegerv(captureDevice, ALC_CAPTURE_SAMPLES, 1, &samplesAvailable);
if (samplesAvailable > 0)
{
// Get the recorded samples
m_samples.resize(static_cast<std::size_t>(samplesAvailable) * getChannelCount());
alcCaptureSamples(captureDevice, m_samples.data(), samplesAvailable);
// Forward them to the derived class
if (!onProcessSamples(m_samples.data(), m_samples.size()))
{
// The user wants to stop the capture
m_isCapturing = false;
}
}
}
////////////////////////////////////////////////////////////
void SoundRecorder::cleanup()
{
// Stop the capture
alcCaptureStop(captureDevice);
// Get the samples left in the buffer
processCapturedSamples();
// Close the device
alcCaptureCloseDevice(captureDevice);
captureDevice = nullptr;
}
////////////////////////////////////////////////////////////
void SoundRecorder::launchCapturingThread()
{
m_isCapturing = true;
assert(!m_thread.joinable());
m_thread = std::thread(&SoundRecorder::record, this);
}
////////////////////////////////////////////////////////////
void SoundRecorder::awaitCapturingThread()
{
m_isCapturing = false;
if (m_thread.joinable())
m_thread.join();
}
} // namespace sf

307
src/SFML/Audio/SoundSource.cpp
View File

@ -25,155 +25,347 @@
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Audio/ALCheck.hpp>
#include <SFML/Audio/SoundSource.hpp>
#if defined(__APPLE__)
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
#include <algorithm>
#include <miniaudio.h>
namespace sf
{
// NOLINTBEGIN(readability-make-member-function-const)
////////////////////////////////////////////////////////////
SoundSource::SoundSource()
{
alCheck(alGenSources(1, &m_source));
alCheck(alSourcei(m_source, AL_BUFFER, 0));
}
////////////////////////////////////////////////////////////
SoundSource::SoundSource(const SoundSource& copy)
{
alCheck(alGenSources(1, &m_source));
alCheck(alSourcei(m_source, AL_BUFFER, 0));
setPitch(copy.getPitch());
setPan(copy.getPan());
setVolume(copy.getVolume());
setSpatializationEnabled(copy.isSpatializationEnabled());
setPosition(copy.getPosition());
setDirection(copy.getDirection());
setCone(copy.getCone());
setVelocity(copy.getVelocity());
setDopplerFactor(copy.getDopplerFactor());
setRelativeToListener(copy.isRelativeToListener());
setMinDistance(copy.getMinDistance());
setMaxDistance(copy.getMaxDistance());
setMinGain(copy.getMinGain());
setMaxGain(copy.getMaxGain());
setAttenuation(copy.getAttenuation());
}
////////////////////////////////////////////////////////////
SoundSource::~SoundSource()
{
alCheck(alSourcei(m_source, AL_BUFFER, 0));
alCheck(alDeleteSources(1, &m_source));
}
////////////////////////////////////////////////////////////
void SoundSource::setPitch(float pitch)
{
alCheck(alSourcef(m_source, AL_PITCH, pitch));
if (auto* sound = static_cast<ma_sound*>(getSound()); sound)
ma_sound_set_pitch(sound, pitch);
}
////////////////////////////////////////////////////////////
void SoundSource::setPan(float pan)
{
if (auto* sound = static_cast<ma_sound*>(getSound()); sound)
ma_sound_set_pan(sound, pan);
}
////////////////////////////////////////////////////////////
void SoundSource::setVolume(float volume)
{
alCheck(alSourcef(m_source, AL_GAIN, volume * 0.01f));
if (auto* sound = static_cast<ma_sound*>(getSound()); sound)
ma_sound_set_volume(sound, volume * 0.01f);
}
////////////////////////////////////////////////////////////
void SoundSource::setSpatializationEnabled(bool enabled)
{
if (auto* sound = static_cast<ma_sound*>(getSound()); sound)
ma_sound_set_spatialization_enabled(sound, enabled ? MA_TRUE : MA_FALSE);
}
////////////////////////////////////////////////////////////
void SoundSource::setPosition(const Vector3f& position)
{
alCheck(alSource3f(m_source, AL_POSITION, position.x, position.y, position.z));
if (auto* sound = static_cast<ma_sound*>(getSound()); sound)
ma_sound_set_position(sound, position.x, position.y, position.z);
}
////////////////////////////////////////////////////////////
void SoundSource::setDirection(const Vector3f& direction)
{
if (auto* sound = static_cast<ma_sound*>(getSound()); sound)
ma_sound_set_direction(sound, direction.x, direction.y, direction.z);
}
////////////////////////////////////////////////////////////
void SoundSource::setCone(const Cone& cone)
{
if (auto* sound = static_cast<ma_sound*>(getSound()); sound)
ma_sound_set_cone(sound,
std::clamp(cone.innerAngle.asRadians(), 0.f, sf::degrees(360).asRadians()),
std::clamp(cone.outerAngle.asRadians(), 0.f, sf::degrees(360).asRadians()),
cone.outerGain);
}
////////////////////////////////////////////////////////////
void SoundSource::setVelocity(const Vector3f& velocity)
{
if (auto* sound = static_cast<ma_sound*>(getSound()); sound)
ma_sound_set_velocity(sound, velocity.x, velocity.y, velocity.z);
}
////////////////////////////////////////////////////////////
void SoundSource::setDopplerFactor(float factor)
{
if (auto* sound = static_cast<ma_sound*>(getSound()); sound)
ma_sound_set_doppler_factor(sound, factor);
}
////////////////////////////////////////////////////////////
void SoundSource::setDirectionalAttenuationFactor(float factor)
{
if (auto* sound = static_cast<ma_sound*>(getSound()); sound)
ma_sound_set_directional_attenuation_factor(sound, factor);
}
////////////////////////////////////////////////////////////
void SoundSource::setRelativeToListener(bool relative)
{
alCheck(alSourcei(m_source, AL_SOURCE_RELATIVE, relative));
if (auto* sound = static_cast<ma_sound*>(getSound()); sound)
ma_sound_set_positioning(sound, relative ? ma_positioning_relative : ma_positioning_absolute);
}
////////////////////////////////////////////////////////////
void SoundSource::setMinDistance(float distance)
{
alCheck(alSourcef(m_source, AL_REFERENCE_DISTANCE, distance));
if (auto* sound = static_cast<ma_sound*>(getSound()); sound)
ma_sound_set_min_distance(sound, distance);
}
////////////////////////////////////////////////////////////
void SoundSource::setMaxDistance(float distance)
{
if (auto* sound = static_cast<ma_sound*>(getSound()); sound)
ma_sound_set_max_distance(sound, distance);
}
////////////////////////////////////////////////////////////
void SoundSource::setMinGain(float gain)
{
if (auto* sound = static_cast<ma_sound*>(getSound()); sound)
ma_sound_set_min_gain(sound, gain);
}
////////////////////////////////////////////////////////////
void SoundSource::setMaxGain(float gain)
{
if (auto* sound = static_cast<ma_sound*>(getSound()); sound)
ma_sound_set_max_gain(sound, gain);
}
////////////////////////////////////////////////////////////
void SoundSource::setAttenuation(float attenuation)
{
alCheck(alSourcef(m_source, AL_ROLLOFF_FACTOR, attenuation));
if (auto* sound = static_cast<ma_sound*>(getSound()); sound)
ma_sound_set_rolloff(sound, attenuation);
}
////////////////////////////////////////////////////////////
float SoundSource::getPitch() const
{
ALfloat pitch;
alCheck(alGetSourcef(m_source, AL_PITCH, &pitch));
if (const auto* sound = static_cast<const ma_sound*>(getSound()); sound)
return ma_sound_get_pitch(sound);
return pitch;
return 0.f;
}
////////////////////////////////////////////////////////////
float SoundSource::getPan() const
{
if (const auto* sound = static_cast<const ma_sound*>(getSound()); sound)
return ma_sound_get_pan(sound);
return 0.f;
}
////////////////////////////////////////////////////////////
float SoundSource::getVolume() const
{
ALfloat gain;
alCheck(alGetSourcef(m_source, AL_GAIN, &gain));
if (const auto* sound = static_cast<const ma_sound*>(getSound()); sound)
return ma_sound_get_volume(sound) * 100.f;
return gain * 100.f;
return 0.f;
}
////////////////////////////////////////////////////////////
bool SoundSource::isSpatializationEnabled() const
{
if (const auto* sound = static_cast<const ma_sound*>(getSound()); sound)
return ma_sound_is_spatialization_enabled(sound) == MA_TRUE;
return false;
}
////////////////////////////////////////////////////////////
Vector3f SoundSource::getPosition() const
{
Vector3f position;
alCheck(alGetSource3f(m_source, AL_POSITION, &position.x, &position.y, &position.z));
if (const auto* sound = static_cast<const ma_sound*>(getSound()); sound)
{
auto position = ma_sound_get_position(sound);
return Vector3f(position.x, position.y, position.z);
}
return position;
return Vector3f();
}
////////////////////////////////////////////////////////////
Vector3f SoundSource::getDirection() const
{
if (const auto* sound = static_cast<const ma_sound*>(getSound()); sound)
{
auto direction = ma_sound_get_direction(sound);
return Vector3f(direction.x, direction.y, direction.z);
}
return Vector3f();
}
////////////////////////////////////////////////////////////
SoundSource::Cone SoundSource::getCone() const
{
if (const auto* sound = static_cast<const ma_sound*>(getSound()); sound)
{
float innerAngle = 0.f;
float outerAngle = 0.f;
Cone cone;
ma_sound_get_cone(sound, &innerAngle, &outerAngle, &cone.outerGain);
cone.innerAngle = sf::radians(innerAngle);
cone.outerAngle = sf::radians(outerAngle);
return cone;
}
return Cone{sf::Angle(), sf::Angle(), 0.f};
}
////////////////////////////////////////////////////////////
Vector3f SoundSource::getVelocity() const
{
if (const auto* sound = static_cast<const ma_sound*>(getSound()); sound)
{
auto velocity = ma_sound_get_velocity(sound);
return Vector3f(velocity.x, velocity.y, velocity.z);
}
return Vector3f();
}
////////////////////////////////////////////////////////////
float SoundSource::getDopplerFactor() const
{
if (const auto* sound = static_cast<const ma_sound*>(getSound()); sound)
return ma_sound_get_doppler_factor(sound);
return 0.f;
}
////////////////////////////////////////////////////////////
float SoundSource::getDirectionalAttenuationFactor() const
{
if (const auto* sound = static_cast<const ma_sound*>(getSound()); sound)
return ma_sound_get_directional_attenuation_factor(sound);
return 0.f;
}
////////////////////////////////////////////////////////////
bool SoundSource::isRelativeToListener() const
{
ALint relative;
alCheck(alGetSourcei(m_source, AL_SOURCE_RELATIVE, &relative));
if (const auto* sound = static_cast<const ma_sound*>(getSound()); sound)
return ma_sound_get_positioning(sound) == ma_positioning_relative;
return relative != 0;
return false;
}
////////////////////////////////////////////////////////////
float SoundSource::getMinDistance() const
{
ALfloat distance;
alCheck(alGetSourcef(m_source, AL_REFERENCE_DISTANCE, &distance));
if (const auto* sound = static_cast<const ma_sound*>(getSound()); sound)
return ma_sound_get_min_distance(sound);
return distance;
return 0.f;
}
////////////////////////////////////////////////////////////
float SoundSource::getMaxDistance() const
{
if (const auto* sound = static_cast<const ma_sound*>(getSound()); sound)
return ma_sound_get_max_distance(sound);
return 0.f;
}
////////////////////////////////////////////////////////////
float SoundSource::getMinGain() const
{
if (const auto* sound = static_cast<const ma_sound*>(getSound()); sound)
return ma_sound_get_min_gain(sound);
return 0.f;
}
////////////////////////////////////////////////////////////
float SoundSource::getMaxGain() const
{
if (const auto* sound = static_cast<const ma_sound*>(getSound()); sound)
return ma_sound_get_max_gain(sound);
return 0.f;
}
////////////////////////////////////////////////////////////
float SoundSource::getAttenuation() const
{
ALfloat attenuation;
alCheck(alGetSourcef(m_source, AL_ROLLOFF_FACTOR, &attenuation));
if (const auto* sound = static_cast<const ma_sound*>(getSound()); sound)
return ma_sound_get_rolloff(sound);
return attenuation;
return 0.f;
}
////////////////////////////////////////////////////////////
SoundSource& SoundSource::operator=(const SoundSource& right)
{
// Leave m_source untouched -- it's not necessary to destroy and
// recreate the OpenAL sound source, hence no copy-and-swap idiom
// Assign the sound attributes
setPitch(right.getPitch());
setVolume(right.getVolume());
@ -189,19 +381,8 @@ SoundSource& SoundSource::operator=(const SoundSource& right)
////////////////////////////////////////////////////////////
SoundSource::Status SoundSource::getStatus() const
{
ALint status;
alCheck(alGetSourcei(m_source, AL_SOURCE_STATE, &status));
switch (status)
{
case AL_INITIAL:
case AL_STOPPED:
return Stopped;
case AL_PAUSED:
return Paused;
case AL_PLAYING:
return Playing;
}
if (const auto* sound = static_cast<const ma_sound*>(getSound()); sound && (ma_sound_is_playing(sound) == MA_TRUE))
return Playing;
return Stopped;
}

804
src/SFML/Audio/SoundStream.cpp
View File

@ -25,226 +25,494 @@
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Audio/ALCheck.hpp>
#include <SFML/Audio/AudioDevice.hpp>
#include <SFML/Audio/SoundStream.hpp>
#include <SFML/System/Err.hpp>
#include <SFML/System/Sleep.hpp>
#include <mutex>
#include <miniaudio.h>
#include <algorithm>
#include <limits>
#include <ostream>
#include <vector>
#include <cassert>
#ifdef _MSC_VER
#pragma warning(disable : 4355) // 'this' used in base member initializer list
#endif
#if defined(__APPLE__)
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
namespace sf
{
////////////////////////////////////////////////////////////
SoundStream::SoundStream() = default;
////////////////////////////////////////////////////////////
SoundStream::~SoundStream()
struct SoundStream::Impl
{
// Stop the sound if it was playing
Impl(SoundStream* owner) : m_owner(owner)
{
// Set this object up as a miniaudio data source
ma_data_source_config config = ma_data_source_config_init();
// Wait for the thread to join
awaitStreamingThread();
static ma_data_source_vtable vtable{read, seek, getFormat, getCursor, getLength, setLooping, 0};
config.vtable = &vtable;
if (auto result = ma_data_source_init(&config, &m_dataSourceBase); result != MA_SUCCESS)
err() << "Failed to initialize audio data source: " << ma_result_description(result) << std::endl;
// Initialize sound structure and set default settings
initialize();
ma_sound_set_pitch(&m_sound, 1.f);
ma_sound_set_pan(&m_sound, 0.f);
ma_sound_set_volume(&m_sound, 1.f);
ma_sound_set_spatialization_enabled(&m_sound, MA_TRUE);
ma_sound_set_position(&m_sound, 0.f, 0.f, 0.f);
ma_sound_set_direction(&m_sound, 0.f, 0.f, -1.f);
ma_sound_set_cone(&m_sound, sf::degrees(360).asRadians(), sf::degrees(360).asRadians(), 0.f); // inner = 360 degrees, outer = 360 degrees, gain = 0
ma_sound_set_directional_attenuation_factor(&m_sound, 1.f);
ma_sound_set_velocity(&m_sound, 0.f, 0.f, 0.f);
ma_sound_set_doppler_factor(&m_sound, 1.f);
ma_sound_set_positioning(&m_sound, ma_positioning_absolute);
ma_sound_set_min_distance(&m_sound, 1.f);
ma_sound_set_max_distance(&m_sound, std::numeric_limits<float>::max());
ma_sound_set_min_gain(&m_sound, 0.f);
ma_sound_set_max_gain(&m_sound, 1.f);
ma_sound_set_rolloff(&m_sound, 1.f);
}
~Impl()
{
ma_sound_uninit(&m_sound);
ma_data_source_uninit(&m_dataSourceBase);
}
void initialize()
{
// Initialize the sound
auto* engine = static_cast<ma_engine*>(priv::AudioDevice::getEngine());
assert(engine != nullptr);
ma_sound_config soundConfig;
soundConfig = ma_sound_config_init();
soundConfig.pDataSource = this;
soundConfig.pEndCallbackUserData = this;
soundConfig.endCallback = [](void* userData, ma_sound* sound)
{
// Seek back to the start of the sound when it finishes playing
auto& impl = *static_cast<Impl*>(userData);
impl.m_streaming = true;
if (auto result = ma_sound_seek_to_pcm_frame(sound, 0); result != MA_SUCCESS)
err() << "Failed to seek sound to frame 0: " << ma_result_description(result) << std::endl;
};
if (auto result = ma_sound_init_ex(engine, &soundConfig, &m_sound); result != MA_SUCCESS)
err() << "Failed to initialize sound: " << ma_result_description(result) << std::endl;
// Because we are providing a custom data source, we have to provide the channel map ourselves
if (!m_channelMap.empty())
{
m_soundChannelMap.clear();
for (auto channel : m_channelMap)
{
switch (channel)
{
case SoundChannel::Unspecified:
m_soundChannelMap.push_back(MA_CHANNEL_NONE);
break;
case SoundChannel::Mono:
m_soundChannelMap.push_back(MA_CHANNEL_MONO);
break;
case SoundChannel::FrontLeft:
m_soundChannelMap.push_back(MA_CHANNEL_FRONT_LEFT);
break;
case SoundChannel::FrontRight:
m_soundChannelMap.push_back(MA_CHANNEL_FRONT_RIGHT);
break;
case SoundChannel::FrontCenter:
m_soundChannelMap.push_back(MA_CHANNEL_FRONT_CENTER);
break;
case SoundChannel::FrontLeftOfCenter:
m_soundChannelMap.push_back(MA_CHANNEL_FRONT_LEFT_CENTER);
break;
case SoundChannel::FrontRightOfCenter:
m_soundChannelMap.push_back(MA_CHANNEL_FRONT_RIGHT_CENTER);
break;
case SoundChannel::LowFrequencyEffects:
m_soundChannelMap.push_back(MA_CHANNEL_LFE);
break;
case SoundChannel::BackLeft:
m_soundChannelMap.push_back(MA_CHANNEL_BACK_LEFT);
break;
case SoundChannel::BackRight:
m_soundChannelMap.push_back(MA_CHANNEL_BACK_RIGHT);
break;
case SoundChannel::BackCenter:
m_soundChannelMap.push_back(MA_CHANNEL_BACK_CENTER);
break;
case SoundChannel::SideLeft:
m_soundChannelMap.push_back(MA_CHANNEL_SIDE_LEFT);
break;
case SoundChannel::SideRight:
m_soundChannelMap.push_back(MA_CHANNEL_SIDE_RIGHT);
break;
case SoundChannel::TopCenter:
m_soundChannelMap.push_back(MA_CHANNEL_TOP_CENTER);
break;
case SoundChannel::TopFrontLeft:
m_soundChannelMap.push_back(MA_CHANNEL_TOP_FRONT_LEFT);
break;
case SoundChannel::TopFrontRight:
m_soundChannelMap.push_back(MA_CHANNEL_TOP_FRONT_RIGHT);
break;
case SoundChannel::TopFrontCenter:
m_soundChannelMap.push_back(MA_CHANNEL_TOP_FRONT_CENTER);
break;
case SoundChannel::TopBackLeft:
m_soundChannelMap.push_back(MA_CHANNEL_TOP_BACK_LEFT);
break;
case SoundChannel::TopBackRight:
m_soundChannelMap.push_back(MA_CHANNEL_TOP_BACK_RIGHT);
break;
case SoundChannel::TopBackCenter:
m_soundChannelMap.push_back(MA_CHANNEL_TOP_BACK_CENTER);
break;
default:
break;
}
}
m_sound.engineNode.spatializer.pChannelMapIn = m_soundChannelMap.data();
}
else
{
m_sound.engineNode.spatializer.pChannelMapIn = nullptr;
}
}
void reinitialize()
{
// Save and re-apply settings
auto pitch = ma_sound_get_pitch(&m_sound);
auto pan = ma_sound_get_pan(&m_sound);
auto volume = ma_sound_get_volume(&m_sound);
auto spatializationEnabled = ma_sound_is_spatialization_enabled(&m_sound);
auto position = ma_sound_get_position(&m_sound);
auto direction = ma_sound_get_direction(&m_sound);
auto directionalAttenuationFactor = ma_sound_get_directional_attenuation_factor(&m_sound);
auto velocity = ma_sound_get_velocity(&m_sound);
auto dopplerFactor = ma_sound_get_doppler_factor(&m_sound);
auto positioning = ma_sound_get_positioning(&m_sound);
auto minDistance = ma_sound_get_min_distance(&m_sound);
auto maxDistance = ma_sound_get_max_distance(&m_sound);
auto minGain = ma_sound_get_min_gain(&m_sound);
auto maxGain = ma_sound_get_max_gain(&m_sound);
auto rollOff = ma_sound_get_rolloff(&m_sound);
float innerAngle;
float outerAngle;
float outerGain;
ma_sound_get_cone(&m_sound, &innerAngle, &outerAngle, &outerGain);
ma_sound_uninit(&m_sound);
initialize();
ma_sound_set_pitch(&m_sound, pitch);
ma_sound_set_pan(&m_sound, pan);
ma_sound_set_volume(&m_sound, volume);
ma_sound_set_spatialization_enabled(&m_sound, spatializationEnabled);
ma_sound_set_position(&m_sound, position.x, position.y, position.z);
ma_sound_set_direction(&m_sound, direction.x, direction.y, direction.z);
ma_sound_set_directional_attenuation_factor(&m_sound, directionalAttenuationFactor);
ma_sound_set_velocity(&m_sound, velocity.x, velocity.y, velocity.z);
ma_sound_set_doppler_factor(&m_sound, dopplerFactor);
ma_sound_set_positioning(&m_sound, positioning);
ma_sound_set_min_distance(&m_sound, minDistance);
ma_sound_set_max_distance(&m_sound, maxDistance);
ma_sound_set_min_gain(&m_sound, minGain);
ma_sound_set_max_gain(&m_sound, maxGain);
ma_sound_set_rolloff(&m_sound, rollOff);
ma_sound_set_cone(&m_sound, innerAngle, outerAngle, outerGain);
}
static ma_result read(ma_data_source* dataSource, void* framesOut, ma_uint64 frameCount, ma_uint64* framesRead)
{
auto& impl = *static_cast<Impl*>(dataSource);
auto* owner = impl.m_owner;
// Try to fill our buffer with new samples if the source is still willing to stream data
if (impl.m_sampleBuffer.empty() && impl.m_streaming)
{
Chunk chunk;
impl.m_streaming = owner->onGetData(chunk);
if (chunk.samples && chunk.sampleCount)
{
impl.m_sampleBuffer.assign(chunk.samples, chunk.samples + chunk.sampleCount);
impl.m_sampleBufferCursor = 0;
}
}
// Push the samples to miniaudio
if (!impl.m_sampleBuffer.empty())
{
// Determine how many frames we can read
*framesRead = std::min(frameCount,
(impl.m_sampleBuffer.size() - impl.m_sampleBufferCursor) / impl.m_channelCount);
const auto sampleCount = *framesRead * impl.m_channelCount;
// Copy the samples to the output
std::memcpy(framesOut,
impl.m_sampleBuffer.data() + impl.m_sampleBufferCursor,
sampleCount * sizeof(impl.m_sampleBuffer[0]));
impl.m_sampleBufferCursor += sampleCount;
impl.m_samplesProcessed += sampleCount;
if (impl.m_sampleBufferCursor >= impl.m_sampleBuffer.size())
{
impl.m_sampleBuffer.clear();
impl.m_sampleBufferCursor = 0;
// If we are looping and at the end of the loop, set the cursor back to the beginning of the loop
if (!impl.m_streaming && impl.m_loop)
{
if (auto seekPositionAfterLoop = owner->onLoop(); seekPositionAfterLoop != NoLoop)
{
impl.m_streaming = true;
impl.m_samplesProcessed = seekPositionAfterLoop;
}
}
}
}
else
{
*framesRead = 0;
}
return MA_SUCCESS;
}
static ma_result seek(ma_data_source* dataSource, ma_uint64 frameIndex)
{
auto& impl = *static_cast<Impl*>(dataSource);
auto* owner = impl.m_owner;
impl.m_streaming = true;
impl.m_sampleBuffer.clear();
impl.m_sampleBufferCursor = 0;
impl.m_samplesProcessed = frameIndex * impl.m_channelCount;
if (impl.m_sampleRate != 0)
{
owner->onSeek(seconds(static_cast<float>(frameIndex / impl.m_sampleRate)));
}
else
{
owner->onSeek(Time::Zero);
}
return MA_SUCCESS;
}
static ma_result getFormat(ma_data_source* dataSource,
ma_format* format,
ma_uint32* channels,
ma_uint32* sampleRate,
ma_channel*,
size_t)
{
const auto& impl = *static_cast<const Impl*>(dataSource);
// If we don't have valid values yet, initialize with defaults so sound creation doesn't fail
*format = ma_format_s16;
*channels = impl.m_channelCount ? impl.m_channelCount : 1;
*sampleRate = impl.m_sampleRate ? impl.m_sampleRate : 44100;
return MA_SUCCESS;
}
static ma_result getCursor(ma_data_source* dataSource, ma_uint64* cursor)
{
auto& impl = *static_cast<Impl*>(dataSource);
*cursor = impl.m_channelCount ? impl.m_samplesProcessed / impl.m_channelCount : 0;
return MA_SUCCESS;
}
static ma_result getLength(ma_data_source*, ma_uint64* length)
{
*length = 0;
return MA_NOT_IMPLEMENTED;
}
static ma_result setLooping(ma_data_source* dataSource, ma_bool32 looping)
{
static_cast<Impl*>(dataSource)->m_loop = (looping == MA_TRUE);
return MA_SUCCESS;
}
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
ma_data_source_base m_dataSourceBase{}; //!< The struct that makes this object a miniaudio data source (must be first member)
SoundStream* const m_owner; //!< Owning SoundStream object
std::vector<ma_channel> m_soundChannelMap; //!< The map of position in sample frame to sound channel (miniaudio channels)
ma_sound m_sound{}; //!< The sound
std::vector<std::int16_t> m_sampleBuffer; //!< Our temporary sample buffer
std::size_t m_sampleBufferCursor{}; //!< The current read position in the temporary sample buffer
std::uint64_t m_samplesProcessed{}; //!< Number of samples processed since beginning of the stream
unsigned int m_channelCount{}; //!< Number of channels (1 = mono, 2 = stereo, ...)
unsigned int m_sampleRate{}; //!< Frequency (samples / second)
std::vector<SoundChannel> m_channelMap{}; //!< The map of position in sample frame to sound channel
bool m_loop{}; //!< Loop flag (true to loop, false to play once)
bool m_streaming{true}; //!< True if we are still streaming samples from the source
};
////////////////////////////////////////////////////////////
SoundStream::SoundStream() : m_impl(std::make_unique<Impl>(this))
{
}
////////////////////////////////////////////////////////////
void SoundStream::initialize(unsigned int channelCount, unsigned int sampleRate)
SoundStream::~SoundStream() = default;
////////////////////////////////////////////////////////////
void SoundStream::initialize(unsigned int channelCount, unsigned int sampleRate, const std::vector<SoundChannel>& channelMap)
{
m_channelCount = channelCount;
m_sampleRate = sampleRate;
m_samplesProcessed = 0;
m_impl->m_channelCount = channelCount;
m_impl->m_sampleRate = sampleRate;
m_impl->m_channelMap = channelMap;
m_impl->m_samplesProcessed = 0;
{
const std::lock_guard lock(m_threadMutex);
m_isStreaming = false;
}
// Deduce the format from the number of channels
m_format = priv::AudioDevice::getFormatFromChannelCount(channelCount);
// Check if the format is valid
if (m_format == 0)
{
m_channelCount = 0;
m_sampleRate = 0;
err() << "Unsupported number of channels (" << m_channelCount << ")" << std::endl;
}
m_impl->reinitialize();
}
////////////////////////////////////////////////////////////
void SoundStream::play()
{
// Check if the sound parameters have been set
if (m_format == 0)
{
err() << "Failed to play audio stream: sound parameters have not been initialized (call initialize() first)"
<< std::endl;
return;
}
bool isStreaming = false;
Status threadStartState = Stopped;
{
const std::lock_guard lock(m_threadMutex);
isStreaming = m_isStreaming;
threadStartState = m_threadStartState;
}
if (isStreaming && (threadStartState == Paused))
{
// If the sound is paused, resume it
const std::lock_guard lock(m_threadMutex);
m_threadStartState = Playing;
alCheck(alSourcePlay(m_source));
return;
}
else if (isStreaming && (threadStartState == Playing))
{
// If the sound is playing, stop it and continue as if it was stopped
stop();
}
else if (!isStreaming && m_thread.joinable())
{
// If the streaming thread reached its end, let it join so it can be restarted.
// Also reset the playing offset at the beginning.
stop();
}
// Start updating the stream in a separate thread to avoid blocking the application
launchStreamingThread(Playing);
if (auto result = ma_sound_start(&m_impl->m_sound); result != MA_SUCCESS)
err() << "Failed to start playing sound: " << ma_result_description(result) << std::endl;
}
////////////////////////////////////////////////////////////
void SoundStream::pause()
{
// Handle pause() being called before the thread has started
{
const std::lock_guard lock(m_threadMutex);
if (!m_isStreaming)
return;
m_threadStartState = Paused;
}
alCheck(alSourcePause(m_source));
if (auto result = ma_sound_stop(&m_impl->m_sound); result != MA_SUCCESS)
err() << "Failed to stop playing sound: " << ma_result_description(result) << std::endl;
}
////////////////////////////////////////////////////////////
void SoundStream::stop()
{
// Wait for the thread to join
awaitStreamingThread();
// Move to the beginning
onSeek(Time::Zero);
if (auto result = ma_sound_stop(&m_impl->m_sound); result != MA_SUCCESS)
{
err() << "Failed to stop playing sound: " << ma_result_description(result) << std::endl;
}
else
{
setPlayingOffset(Time::Zero);
}
}
////////////////////////////////////////////////////////////
unsigned int SoundStream::getChannelCount() const
{
return m_channelCount;
return m_impl->m_channelCount;
}
////////////////////////////////////////////////////////////
unsigned int SoundStream::getSampleRate() const
{
return m_sampleRate;
return m_impl->m_sampleRate;
}
////////////////////////////////////////////////////////////
std::vector<SoundChannel> SoundStream::getChannelMap() const
{
return m_impl->m_channelMap;
}
////////////////////////////////////////////////////////////
SoundStream::Status SoundStream::getStatus() const
{
Status status = SoundSource::getStatus();
// To compensate for the lag between play() and alSourceplay()
if (status == Stopped)
{
const std::lock_guard lock(m_threadMutex);
if (m_isStreaming)
status = m_threadStartState;
}
return status;
return SoundSource::getStatus();
}
////////////////////////////////////////////////////////////
void SoundStream::setPlayingOffset(Time timeOffset)
{
// Get old playing status
const Status oldStatus = getStatus();
// Stop the stream
stop();
// Let the derived class update the current position
onSeek(timeOffset);
// Restart streaming
m_samplesProcessed = static_cast<std::uint64_t>(timeOffset.asSeconds() * static_cast<float>(m_sampleRate)) *
m_channelCount;
if (oldStatus == Stopped)
if (m_impl->m_sampleRate == 0)
return;
launchStreamingThread(oldStatus);
ma_uint32 sampleRate{};
if (auto result = ma_sound_get_data_format(&m_impl->m_sound, nullptr, nullptr, &sampleRate, nullptr, 0);
result != MA_SUCCESS)
err() << "Failed to get sound data format: " << ma_result_description(result) << std::endl;
const auto frameIndex = static_cast<ma_uint64>(timeOffset.asSeconds() * static_cast<double>(sampleRate));
if (auto result = ma_sound_seek_to_pcm_frame(&m_impl->m_sound, frameIndex); result != MA_SUCCESS)
err() << "Failed to seek sound to pcm frame: " << ma_result_description(result) << std::endl;
m_impl->m_streaming = true;
m_impl->m_sampleBuffer.clear();
m_impl->m_sampleBufferCursor = 0;
m_impl->m_samplesProcessed = frameIndex * m_impl->m_channelCount;
onSeek(seconds(static_cast<float>(frameIndex / m_impl->m_sampleRate)));
}
////////////////////////////////////////////////////////////
Time SoundStream::getPlayingOffset() const
{
if (m_sampleRate && m_channelCount)
{
ALfloat secs = 0.f;
alCheck(alGetSourcef(m_source, AL_SEC_OFFSET, &secs));
if (m_impl->m_channelCount == 0 || m_impl->m_sampleRate == 0)
return Time();
return seconds(secs + static_cast<float>(m_samplesProcessed) / static_cast<float>(m_sampleRate) /
static_cast<float>(m_channelCount));
}
else
auto cursor = 0.f;
if (auto result = ma_sound_get_cursor_in_seconds(&m_impl->m_sound, &cursor); result != MA_SUCCESS)
{
return Time::Zero;
err() << "Failed to get sound cursor: " << ma_result_description(result) << std::endl;
return Time();
}
return seconds(cursor);
}
////////////////////////////////////////////////////////////
void SoundStream::setLoop(bool loop)
{
m_loop = loop;
ma_sound_set_looping(&m_impl->m_sound, loop ? MA_TRUE : MA_FALSE);
}
////////////////////////////////////////////////////////////
bool SoundStream::getLoop() const
{
return m_loop;
return ma_sound_is_looping(&m_impl->m_sound) == MA_TRUE;
}
@ -255,275 +523,11 @@ std::int64_t SoundStream::onLoop()
return 0;
}
////////////////////////////////////////////////////////////
void SoundStream::setProcessingInterval(Time interval)
{
m_processingInterval = interval;
}
////////////////////////////////////////////////////////////
void SoundStream::streamData()
void* SoundStream::getSound() const
{
bool requestStop = false;
{
const std::lock_guard lock(m_threadMutex);
// Check if the thread was launched Stopped
if (m_threadStartState == Stopped)
{
m_isStreaming = false;
return;
}
}
// Create the buffers
alCheck(alGenBuffers(BufferCount, m_buffers));
for (std::int64_t& bufferSeek : m_bufferSeeks)
bufferSeek = NoLoop;
// Fill the queue
requestStop = fillQueue();
// Play the sound
alCheck(alSourcePlay(m_source));
{
const std::lock_guard lock(m_threadMutex);
// Check if the thread was launched Paused
if (m_threadStartState == Paused)
alCheck(alSourcePause(m_source));
}
for (;;)
{
{
const std::lock_guard lock(m_threadMutex);
if (!m_isStreaming)
break;
}
// The stream has been interrupted!
if (SoundSource::getStatus() == Stopped)
{
if (!requestStop)
{
// Just continue
alCheck(alSourcePlay(m_source));
}
else
{
// End streaming
const std::lock_guard lock(m_threadMutex);
m_isStreaming = false;
}
}
// Get the number of buffers that have been processed (i.e. ready for reuse)
ALint nbProcessed = 0;
alCheck(alGetSourcei(m_source, AL_BUFFERS_PROCESSED, &nbProcessed));
while (nbProcessed--)
{
// Pop the first unused buffer from the queue
ALuint buffer;
alCheck(alSourceUnqueueBuffers(m_source, 1, &buffer));
// Find its number
unsigned int bufferNum = 0;
for (unsigned int i = 0; i < BufferCount; ++i)
if (m_buffers[i] == buffer)
{
bufferNum = i;
break;
}
// Retrieve its size and add it to the samples count
if (m_bufferSeeks[bufferNum] != NoLoop)
{
// This was the last buffer before EOF or Loop End: reset the sample count
m_samplesProcessed = static_cast<std::uint64_t>(m_bufferSeeks[bufferNum]);
m_bufferSeeks[bufferNum] = NoLoop;
}
else
{
ALint size;
ALint bits;
alCheck(alGetBufferi(buffer, AL_SIZE, &size));
alCheck(alGetBufferi(buffer, AL_BITS, &bits));
// Bits can be 0 if the format or parameters are corrupt, avoid division by zero
if (bits == 0)
{
err() << "Bits in sound stream are 0: make sure that the audio format is not corrupt "
<< "and initialize() has been called correctly" << std::endl;
// Abort streaming (exit main loop)
const std::lock_guard lock(m_threadMutex);
m_isStreaming = false;
requestStop = true;
break;
}
else
{
m_samplesProcessed += static_cast<std::uint64_t>(size / (bits / 8));
}
}
// Fill it and push it back into the playing queue
if (!requestStop)
{
if (fillAndPushBuffer(bufferNum))
requestStop = true;
}
}
// Check if any error has occurred
if (alGetLastError() != AL_NO_ERROR)
{
// Abort streaming (exit main loop)
const std::lock_guard lock(m_threadMutex);
m_isStreaming = false;
break;
}
// Leave some time for the other threads if the stream is still playing
if (SoundSource::getStatus() != Stopped)
sleep(m_processingInterval);
}
// Stop the playback
alCheck(alSourceStop(m_source));
// Dequeue any buffer left in the queue
clearQueue();
// Reset the playing position
m_samplesProcessed = 0;
// Delete the buffers
alCheck(alSourcei(m_source, AL_BUFFER, 0));
alCheck(alDeleteBuffers(BufferCount, m_buffers));
}
////////////////////////////////////////////////////////////
bool SoundStream::fillAndPushBuffer(unsigned int bufferNum, bool immediateLoop)
{
bool requestStop = false;
// Acquire audio data, also address EOF and error cases if they occur
Chunk data = {nullptr, 0};
for (std::uint32_t retryCount = 0; !onGetData(data) && (retryCount < BufferRetries); ++retryCount)
{
// Check if the stream must loop or stop
if (!m_loop)
{
// Not looping: Mark this buffer as ending with 0 and request stop
if (data.samples != nullptr && data.sampleCount != 0)
m_bufferSeeks[bufferNum] = 0;
requestStop = true;
break;
}
// Return to the beginning or loop-start of the stream source using onLoop(), and store the result in the buffer seek array
// This marks the buffer as the "last" one (so that we know where to reset the playing position)
m_bufferSeeks[bufferNum] = onLoop();
// If we got data, break and process it, else try to fill the buffer once again
if (data.samples != nullptr && data.sampleCount != 0)
break;
// If immediateLoop is specified, we have to immediately adjust the sample count
if (immediateLoop && (m_bufferSeeks[bufferNum] != NoLoop))
{
// We just tried to begin preloading at EOF or Loop End: reset the sample count
m_samplesProcessed = static_cast<std::uint64_t>(m_bufferSeeks[bufferNum]);
m_bufferSeeks[bufferNum] = NoLoop;
}
// We're a looping sound that got no data, so we retry onGetData()
}
// Fill the buffer if some data was returned
if (data.samples && data.sampleCount)
{
const unsigned int buffer = m_buffers[bufferNum];
// Fill the buffer
const auto size = static_cast<ALsizei>(data.sampleCount * sizeof(std::int16_t));
alCheck(alBufferData(buffer, m_format, data.samples, size, static_cast<ALsizei>(m_sampleRate)));
// Push it into the sound queue
alCheck(alSourceQueueBuffers(m_source, 1, &buffer));
}
else
{
// If we get here, we most likely ran out of retries
requestStop = true;
}
return requestStop;
}
////////////////////////////////////////////////////////////
bool SoundStream::fillQueue()
{
// Fill and enqueue all the available buffers
bool requestStop = false;
for (unsigned int i = 0; (i < BufferCount) && !requestStop; ++i)
{
// Since no sound has been loaded yet, we can't schedule loop seeks preemptively,
// So if we start on EOF or Loop End, we let fillAndPushBuffer() adjust the sample count
if (fillAndPushBuffer(i, (i == 0)))
requestStop = true;
}
return requestStop;
}
////////////////////////////////////////////////////////////
void SoundStream::clearQueue()
{
// Get the number of buffers still in the queue
ALint nbQueued;
alCheck(alGetSourcei(m_source, AL_BUFFERS_QUEUED, &nbQueued));
// Dequeue them all
ALuint buffer;
for (ALint i = 0; i < nbQueued; ++i)
alCheck(alSourceUnqueueBuffers(m_source, 1, &buffer));
}
////////////////////////////////////////////////////////////
void SoundStream::launchStreamingThread(Status threadStartState)
{
{
const std::lock_guard lock(m_threadMutex);
m_isStreaming = true;
m_threadStartState = threadStartState;
}
assert(!m_thread.joinable());
m_thread = std::thread(&SoundStream::streamData, this);
}
////////////////////////////////////////////////////////////
void SoundStream::awaitStreamingThread()
{
// Request the thread to join
{
const std::lock_guard lock(m_threadMutex);
m_isStreaming = false;
}
if (m_thread.joinable())
m_thread.join();
return &m_impl->m_sound;
}
} // namespace sf

1
src/SFML/Main/SFMLActivity.cpp
View File

@ -193,7 +193,6 @@ JNIEXPORT void ANativeActivity_onCreate(ANativeActivity* activity, void* savedSt
#undef _SFML_S
#undef _SFML_QS
#endif
loadLibrary("openal", lJNIEnv, ObjectActivityInfo);
#if !defined(SFML_DEBUG)
loadLibrary("sfml-system", lJNIEnv, ObjectActivityInfo);

9
test/Audio/AlResource.test.cpp
View File

@ -1,9 +0,0 @@
#include <SFML/Audio/AlResource.hpp>
#include <type_traits>
static_assert(!std::is_constructible_v<sf::AlResource>);
static_assert(!std::is_copy_constructible_v<sf::AlResource>);
static_assert(std::is_copy_assignable_v<sf::AlResource>);
static_assert(!std::is_nothrow_move_constructible_v<sf::AlResource>);
static_assert(std::is_nothrow_move_assignable_v<sf::AlResource>);

9
test/Audio/AudioResource.test.cpp Normal file
View File

@ -0,0 +1,9 @@
#include <SFML/Audio/AudioResource.hpp>
#include <type_traits>
static_assert(!std::is_constructible_v<sf::AudioResource>);
static_assert(std::is_copy_constructible_v<sf::AudioResource>);
static_assert(!std::is_copy_assignable_v<sf::AudioResource>);
static_assert(std::is_nothrow_move_constructible_v<sf::AudioResource>);
static_assert(!std::is_nothrow_move_assignable_v<sf::AudioResource>);

10
test/CMakeLists.txt
View File

@ -114,7 +114,7 @@ set(NETWORK_SRC
sfml_add_test(test-sfml-network "${NETWORK_SRC}" SFML::Network)
set(AUDIO_SRC
Audio/AlResource.test.cpp
Audio/AudioResource.test.cpp
Audio/InputSoundFile.test.cpp
Audio/Music.test.cpp
Audio/OutputSoundFile.test.cpp
@ -127,14 +127,6 @@ set(AUDIO_SRC
)
sfml_add_test(test-sfml-audio "${AUDIO_SRC}" SFML::Audio)
if(SFML_OS_WINDOWS AND NOT SFML_USE_SYSTEM_DEPS)
add_custom_command(
TARGET test-sfml-audio
COMMENT "Copy OpenAL DLL"
PRE_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${PROJECT_SOURCE_DIR}/extlibs/bin/$<IF:$<BOOL:${ARCH_64BITS}>,x64,x86>/openal32.dll $<TARGET_FILE_DIR:test-sfml-audio>
VERBATIM)
endif()
if(SFML_ENABLE_COVERAGE AND SFML_OS_WINDOWS)
# Try to find and use OpenCppCoverage for coverage reporting when building with MSVC
find_program(OpenCppCoverage_BINARY "OpenCppCoverage.exe")

3
tools/android/compile_libs.sh
View File

@ -51,7 +51,4 @@ rm $DESTDIR/$1/usr/lib/libvorbis*.so*
# Compile freetype
cd $LOCALDIR/build/freetype-* && sed -i 's/-version-info/-avoid-version/g' builds/unix/unix-cc.in && ./configure $HOST $PREFIX && make && make install
# Compile OpenAL-Soft
cd $LOCALDIR/build/openal-soft-android-master && cd build && cmake -DCMAKE_TOOLCHAIN_FILE=$ANDROID_CMAKE_TOOLCHAIN -DANDROID_ABI=$ANDROID_ABI -DANDROID_NATIVE_API_LEVEL=android-9 -DANDROID_USE_STLPORT=1 .. && make openal && mv libopenal.so $DESTDIR/$1/usr/lib
export PATH=$OPATH

8
tools/android/download_sources.sh
View File

@ -39,11 +39,3 @@ if [ ! -d "$PWD/tmp/$FREETYPE" ]
then
tar -C build -xf src/$FREETYPE.tar.gz
fi
wget -nc -P src https://github.com/AerialX/openal-soft-android/archive/master.tar.gz
if [ ! -d "$PWD/tmp/openal-soft-android-master" ]
then
tar -C build -xf src/master.tar.gz
fi
patch build/openal-soft-android-master/CMakeLists.txt patches/remove-so-version-suffix.diff

13
tools/android/patches/remove-so-version-suffix.diff
View File

@ -1,13 +0,0 @@
--- CMakeLists.txt.orig 2013-09-21 15:23:49.305453804 +0200
+++ CMakeLists.txt 2013-09-21 15:24:08.621454210 +0200
@@ -717,9 +717,7 @@
# Build a library
ADD_LIBRARY(${LIBNAME} ${LIBTYPE} ${OPENAL_OBJS} ${ALC_OBJS})
SET_TARGET_PROPERTIES(${LIBNAME} PROPERTIES DEFINE_SYMBOL AL_BUILD_LIBRARY
- COMPILE_FLAGS -DAL_ALEXT_PROTOTYPES
- VERSION ${LIB_VERSION}.0
- SOVERSION ${LIB_MAJOR_VERSION})
+ COMPILE_FLAGS -DAL_ALEXT_PROTOTYPES)
IF(WIN32 AND NOT LIBTYPE STREQUAL "STATIC")
SET_TARGET_PROPERTIES(${LIBNAME} PROPERTIES PREFIX "")
ENDIF()

4
tools/pkg-config/sfml-audio.pc.in
View File

@ -8,8 +8,6 @@ Description: The Simple and Fast Multimedia Library, audio module.
URL: http://www.sfml-dev.org
Version: @PROJECT_VERSION@
Requires: sfml-system
Requires.private: openal, vorbisenc, vorbisfile, vorbis, ogg, flac
Requires.private: vorbisenc, vorbisfile, vorbis, ogg, flac
Libs: -L${libdir} -lsfml-audio
# openal may be a system framework
Libs.private: @OPENAL_LIBRARY@
Cflags: -I${includedir}

4
tools/xcode/templates/SFML/SFML App.xctemplate/TemplateInfo.plist.in vendored
View File

@ -229,8 +229,8 @@ require () # $1 is a SFML module like 'system' or 'audio'
# copy extra dependencies
if [ "$1" = "audio" ]
then
# copy "FLAC" "ogg" "vorbis" "vorbisenc" "vorbisfile" "OpenAL" frameworks too
for f in "FLAC" "ogg" "vorbis" "vorbisenc" "vorbisfile" "OpenAL"
# copy "FLAC" "ogg" "vorbis" "vorbisenc" "vorbisfile" frameworks too
for f in "FLAC" "ogg" "vorbis" "vorbisenc" "vorbisfile"
do
copy "$SFML_DEPENDENCIES_INSTALL_PREFIX/$f.framework" "$dest/$f.framework"
done