From 983e5332a6eefb3c294f9be1f4db5a5ecdbb176a Mon Sep 17 00:00:00 2001 From: Neal Gompa Date: Thu, 13 May 2010 19:05:44 -0500 Subject: [PATCH] Something screwy with internal headers, replaced them with headers from OpenAL-Soft --- Dependencies/OpenAL/include/AL/al.h | 1007 +++++++++++++++----------- Dependencies/OpenAL/include/AL/alc.h | 313 ++++++-- 2 files changed, 810 insertions(+), 510 deletions(-) diff --git a/Dependencies/OpenAL/include/AL/al.h b/Dependencies/OpenAL/include/AL/al.h index 522cc5f..c409701 100644 --- a/Dependencies/OpenAL/include/AL/al.h +++ b/Dependencies/OpenAL/include/AL/al.h @@ -1,587 +1,722 @@ -#ifndef __al_h_ -#define __al_h_ +#ifndef AL_AL_H +#define AL_AL_H -/** - * OpenAL cross platform audio library - * Copyright (C) 1999-2000 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 - */ -#include "altypes.h" - -#ifdef __cplusplus +#if defined(__cplusplus) extern "C" { #endif -#ifdef _WIN32 -#define ALAPI __declspec(dllexport) -#define ALAPIENTRY __cdecl -#define AL_CALLBACK -#else /* _WIN32 */ - -#ifdef TARGET_OS_MAC -#if TARGET_OS_MAC -#pragma export on -#endif /* TARGET_OS_MAC */ -#endif /* TARGET_OS_MAC */ - -#ifndef ALAPI -#define ALAPI +#if defined(_WIN32) && !defined(_XBOX) + #if defined(AL_BUILD_LIBRARY) + #define AL_API __declspec(dllexport) + #else + #define AL_API __declspec(dllimport) + #endif +#else + #if defined(AL_BUILD_LIBRARY) && defined(HAVE_GCC_VISIBILITY) + #define AL_API __attribute__((visibility("protected"))) + #else + #define AL_API extern + #endif #endif -#ifndef ALAPIENTRY -#define ALAPIENTRY +#if defined(_WIN32) + #define AL_APIENTRY __cdecl +#else + #define AL_APIENTRY #endif -#ifndef CALLBACK -#define AL_CALLBACK +#if defined(TARGET_OS_MAC) && TARGET_OS_MAC + #pragma export on #endif -#endif /* _WIN32 */ +/* + * The OPENAL, ALAPI, ALAPIENTRY, AL_INVALID, AL_ILLEGAL_ENUM, and + * AL_ILLEGAL_COMMAND macros are deprecated, but are included for + * applications porting code from AL 1.0 + */ +#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 -#ifndef AL_NO_PROTOTYPES +#define AL_VERSION_1_0 +#define AL_VERSION_1_1 -/** - * OpenAL Maintenance Functions - * State Management and Query. - * Error Handling. - * Extension Support. - */ +/** 8-bit boolean */ +typedef char ALboolean; -/** Renderer State management. */ -ALAPI void ALAPIENTRY alEnable( ALenum capability ); +/** character */ +typedef char ALchar; -ALAPI void ALAPIENTRY alDisable( ALenum capability ); +/** signed 8-bit 2's complement integer */ +typedef signed char ALbyte; -ALAPI ALboolean ALAPIENTRY alIsEnabled( ALenum capability ); +/** unsigned 8-bit integer */ +typedef unsigned char ALubyte; -/** Application preferences for driver performance choices. */ -ALAPI void ALAPIENTRY alHint( ALenum target, ALenum mode ); +/** signed 16-bit 2's complement integer */ +typedef short ALshort; -/** State retrieval. */ -ALAPI void ALAPIENTRY alGetBooleanv( ALenum param, ALboolean* data ); +/** unsigned 16-bit integer */ +typedef unsigned short ALushort; -/** State retrieval. */ -ALAPI void ALAPIENTRY alGetIntegerv( ALenum param, ALint* data ); +/** signed 32-bit 2's complement integer */ +typedef int ALint; -/** State retrieval. */ -ALAPI void ALAPIENTRY alGetFloatv( ALenum param, ALfloat* data ); +/** unsigned 32-bit integer */ +typedef unsigned int ALuint; -/** State retrieval. */ -ALAPI void ALAPIENTRY alGetDoublev( ALenum param, ALdouble* data ); +/** non-negative 32-bit binary integer size */ +typedef int ALsizei; -/** State retrieval. */ -ALAPI const ALubyte* ALAPIENTRY alGetString( ALenum param ); +/** 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 + +/** Indicate Source has relative coordinates. */ +#define AL_SOURCE_RELATIVE 0x202 -/** State retrieval.through return value ( for compatibility ) */ -ALAPI ALboolean ALAPIENTRY alGetBoolean( ALenum param ); -ALAPI ALint ALAPIENTRY alGetInteger( ALenum param ); -ALAPI ALfloat ALAPIENTRY alGetFloat( ALenum param ); -ALAPI ALdouble ALAPIENTRY alGetDouble( ALenum param ); /** - * Error support. - * Obtain the most recent error generated in the AL state machine. + * Directional source, inner cone angle, in degrees. + * Range: [0-360] + * Default: 360 */ -ALAPI ALenum ALAPIENTRY alGetError( ALvoid ); +#define AL_CONE_INNER_ANGLE 0x1001 -/** - * Extension support. - * Obtain the address of a function (usually an extension) - * with the name fname. All addresses are context-independent. +/** + * Directional source, outer cone angle, in degrees. + * Range: [0-360] + * Default: 360 */ -ALAPI ALboolean ALAPIENTRY alIsExtensionPresent( const ALubyte* fname ); - +#define AL_CONE_OUTER_ANGLE 0x1002 -/** - * Extension support. - * Obtain the address of a function (usually an extension) - * with the name fname. All addresses are context-independent. +/** + * Specify the pitch to be applied at source. + * Range: [0.5-2.0] + * Default: 1.0 */ -ALAPI void* ALAPIENTRY alGetProcAddress( const ALubyte* fname ); +#define AL_PITCH 0x1003 + +/** + * Specify the current 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. + * Listener position is always in the world coordinate system. + */ +#define AL_POSITION 0x1004 + +/** Specify the current direction. */ +#define AL_DIRECTION 0x1005 + +/** Specify the current velocity in three dimensional space. */ +#define AL_VELOCITY 0x1006 +/** + * Indicate whether source is looping. + * Type: ALboolean? + * Range: [AL_TRUE, AL_FALSE] + * Default: FALSE. + */ +#define AL_LOOPING 0x1007 /** - * Extension support. - * Obtain the integer value of an enumeration (usually an extension) with the name ename. + * Indicate the buffer to provide sound samples. + * Type: ALuint. + * Range: any valid Buffer id. + */ +#define AL_BUFFER 0x1009 + +/** + * Indicate the gain (volume amplification) applied. + * Type: ALfloat. + * Range: ]0.0- ] + * A value of 1.0 means un-attenuated/unchanged. + * Each division by 2 equals an attenuation of -6dB. + * Each multiplicaton with 2 equals an amplification of +6dB. + * A value of 0.0 is meaningless with respect to a logarithmic + * scale; it is interpreted as zero volume - the channel + * is effectively disabled. */ -ALAPI ALenum ALAPIENTRY alGetEnumValue( const ALubyte* ename ); +#define AL_GAIN 0x100A +/* + * Indicate minimum source attenuation + * Type: ALfloat + * Range: [0.0 - 1.0] + * + * Logarthmic + */ +#define AL_MIN_GAIN 0x100D +/** + * Indicate maximum source attenuation + * Type: ALfloat + * Range: [0.0 - 1.0] + * + * Logarthmic + */ +#define AL_MAX_GAIN 0x100E +/** + * Indicate listener orientation. + * + * at/up + */ +#define AL_ORIENTATION 0x100F +/** + * Source state information. + */ +#define AL_SOURCE_STATE 0x1010 +#define AL_INITIAL 0x1011 +#define AL_PLAYING 0x1012 +#define AL_PAUSED 0x1013 +#define AL_STOPPED 0x1014 +/** + * Buffer Queue params + */ +#define AL_BUFFERS_QUEUED 0x1015 +#define AL_BUFFERS_PROCESSED 0x1016 /** - * LISTENER - * Listener is the sample position for a given context. - * The multi-channel (usually stereo) output stream generated - * by the mixer is parametrized by this Listener object: - * its position and velocity relative to Sources, within - * occluder and reflector geometry. + * Source buffer position information */ +#define AL_SEC_OFFSET 0x1024 +#define AL_SAMPLE_OFFSET 0x1025 +#define AL_BYTE_OFFSET 0x1026 +/* + * Source type (Static, Streaming or undetermined) + * Source is Static if a Buffer has been attached using AL_BUFFER + * Source is Streaming if one or more Buffers have been attached using alSourceQueueBuffers + * Source is undetermined when it has the NULL buffer attached + */ +#define AL_SOURCE_TYPE 0x1027 +#define AL_STATIC 0x1028 +#define AL_STREAMING 0x1029 +#define AL_UNDETERMINED 0x1030 +/** Sound samples: format specifier. */ +#define AL_FORMAT_MONO8 0x1100 +#define AL_FORMAT_MONO16 0x1101 +#define AL_FORMAT_STEREO8 0x1102 +#define AL_FORMAT_STEREO16 0x1103 /** + * source specific reference distance + * Type: ALfloat + * Range: 0.0 - +inf * - * Listener Gain: default 1.0f. + * At 0.0, no distance attenuation occurs. Default is + * 1.0. */ -ALAPI void ALAPIENTRY alListenerf( ALenum pname, ALfloat param ); - -ALAPI void ALAPIENTRY alListeneri( ALenum pname, ALint param ); +#define AL_REFERENCE_DISTANCE 0x1020 /** + * source specific rolloff factor + * Type: ALfloat + * Range: 0.0 - +inf * - * Listener Position: ALfloat[3] - * Listener Velocity: ALfloat[3] */ -ALAPI void ALAPIENTRY alListener3f( ALenum pname, - ALfloat f1, ALfloat f2, ALfloat f3 ); +#define AL_ROLLOFF_FACTOR 0x1021 /** + * Directional source, outer cone gain. * - * Listener Position: ALfloat[3] - * Listener Velocity: ALfloat[3] - * Listener Orientation: ALfloat[6] (forward and up vector). + * Default: 0.0 + * Range: [0.0 - 1.0] + * Logarithmic */ -ALAPI void ALAPIENTRY alListenerfv( ALenum pname, ALfloat* param ); +#define AL_CONE_OUTER_GAIN 0x1022 -/* - * Retrieve listener information. +/** + * Indicate distance above which sources are not + * attenuated using the inverse clamped distance model. + * + * Default: +inf + * Type: ALfloat + * Range: 0.0 - +inf */ -ALAPI void ALAPIENTRY alGetListeneri( ALenum pname, ALint* value ); -ALAPI void ALAPIENTRY alGetListenerf( ALenum pname, ALfloat* value ); - -ALAPI void ALAPIENTRY alGetListeneriv( ALenum pname, ALint* value ); -ALAPI void ALAPIENTRY alGetListenerfv( ALenum pname, ALfloat* values ); +#define AL_MAX_DISTANCE 0x1023 -ALAPI void ALAPIENTRY alGetListener3f( ALenum pname, - ALfloat *f1, ALfloat *f2, ALfloat *f3 ); +/** + * Sound samples: frequency, in units of Hertz [Hz]. + * This is the number of samples per second. Half of the + * sample frequency marks the maximum significant + * frequency component. + */ +#define AL_FREQUENCY 0x2001 +#define AL_BITS 0x2002 +#define AL_CHANNELS 0x2003 +#define AL_SIZE 0x2004 /** - * SOURCE - * Source objects are by default localized. Sources - * take the PCM data provided in the specified Buffer, - * apply Source-specific modifications, and then - * submit them to be mixed according to spatial - * arrangement etc. + * Buffer state. + * + * Not supported for public use (yet). */ +#define AL_UNUSED 0x2010 +#define AL_PENDING 0x2011 +#define AL_PROCESSED 0x2012 +/** Errors: No Error. */ +#define AL_NO_ERROR AL_FALSE -/** Create Source objects. */ -ALAPI void ALAPIENTRY alGenSources( ALsizei n, ALuint* sources ); - -/** Delete Source objects. */ -ALAPI void ALAPIENTRY alDeleteSources( ALsizei n, ALuint* sources ); +/** + * Invalid Name paramater passed to AL call. + */ +#define AL_INVALID_NAME 0xA001 -/** Verify a handle is a valid Source. */ -ALAPI ALboolean ALAPIENTRY alIsSource( ALuint sid ); +/** + * Invalid parameter passed to AL call. + */ +#define AL_INVALID_ENUM 0xA002 +/** + * Invalid enum parameter value. + */ +#define AL_INVALID_VALUE 0xA003 -/** Set an integer parameter for a Source object. */ -ALAPI void ALAPIENTRY alSourcei( ALuint sid, ALenum param, ALint value ); -ALAPI void ALAPIENTRY alSourcef( ALuint sid, ALenum param, ALfloat value ); -ALAPI void ALAPIENTRY alSource3f( ALuint sid, ALenum param, - ALfloat f1, ALfloat f2, ALfloat f3 ); -ALAPI void ALAPIENTRY alSourcefv( ALuint sid, ALenum param, ALfloat* values ); +/** + * Illegal call. + */ +#define AL_INVALID_OPERATION 0xA004 -/** Get an integer parameter for a Source object. */ -ALAPI void ALAPIENTRY alGetSourcei( ALuint sid, ALenum pname, ALint* value ); -ALAPI void ALAPIENTRY alGetSourceiv( ALuint sid, ALenum pname, ALint* values ); -ALAPI void ALAPIENTRY alGetSourcef( ALuint sid, ALenum pname, ALfloat* value ); -ALAPI void ALAPIENTRY alGetSourcefv( ALuint sid, ALenum pname, ALfloat* values ); + +/** + * No mojo. + */ +#define AL_OUT_OF_MEMORY 0xA005 -/* deprecated, included for Win compatibility */ -ALAPI void ALAPIENTRY alGetSource3f( ALuint sid, ALenum pname, ALfloat* value1, - ALfloat* value2, ALfloat* value3); -ALAPI void ALAPIENTRY alSourcePlayv( ALsizei ns, ALuint *ids ); -ALAPI void ALAPIENTRY alSourceStopv( ALsizei ns, ALuint *ids ); -ALAPI void ALAPIENTRY alSourceRewindv( ALsizei ns, ALuint *ids ); -ALAPI void ALAPIENTRY alSourcePausev( ALsizei ns, ALuint *ids ); +/** Context strings: Vendor Name. */ +#define AL_VENDOR 0xB001 +#define AL_VERSION 0xB002 +#define AL_RENDERER 0xB003 +#define AL_EXTENSIONS 0xB004 -/** Activate a source, start replay. */ -ALAPI void ALAPIENTRY alSourcePlay( ALuint sid ); +/** Global tweakage. */ /** - * Pause a source, - * temporarily remove it from the mixer list. + * Doppler scale. Default 1.0 */ -ALAPI void ALAPIENTRY alSourcePause( ALuint sid ); +#define AL_DOPPLER_FACTOR 0xC000 /** - * Rewind a source, - * set the source to play at the beginning. + * Tweaks speed of propagation. */ -ALAPI void ALAPIENTRY alSourceRewind( ALuint sid ); +#define AL_DOPPLER_VELOCITY 0xC001 /** - * Stop a source, - * temporarily remove it from the mixer list, - * and reset its internal state to pre-Play. - * To remove a Source completely, it has to be - * deleted following Stop, or before Play. + * Speed of Sound in units per second */ -ALAPI void ALAPIENTRY alSourceStop( ALuint sid ); +#define AL_SPEED_OF_SOUND 0xC003 /** - * BUFFER - * Buffer objects are storage space for sample data. - * Buffers are referred to by Sources. There can be more than - * one Source using the same Buffer data. If Buffers have - * to be duplicated on a per-Source basis, the driver has to - * take care of allocation, copying, and deallocation as well - * as propagating buffer data changes. + * Distance models + * + * used in conjunction with DistanceModel + * + * implicit: NONE, which disances distance attenuation. */ +#define AL_DISTANCE_MODEL 0xD000 +#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 ); -/** Buffer object generation. */ -ALAPI void ALAPIENTRY alGenBuffers( ALsizei n, ALuint* buffers ); -ALAPI void ALAPIENTRY alDeleteBuffers( ALsizei n, ALuint* buffers ); +/* + * State retrieval + */ +AL_API const ALchar* AL_APIENTRY alGetString( ALenum param ); +AL_API void AL_APIENTRY alGetBooleanv( ALenum param, ALboolean* data ); -ALAPI ALboolean ALAPIENTRY alIsBuffer( ALuint buffer ); +AL_API void AL_APIENTRY alGetIntegerv( ALenum param, ALint* data ); -/** - * Specify the data to be filled into a buffer. +AL_API void AL_APIENTRY alGetFloatv( ALenum param, ALfloat* data ); + +AL_API void AL_APIENTRY alGetDoublev( ALenum param, ALdouble* data ); + +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 support. + * Obtain the most recent error generated in the AL state machine. */ -ALAPI void ALAPIENTRY alBufferData( ALuint buffer, - ALenum format, - ALvoid* data, - ALsizei size, - ALsizei freq ); +AL_API ALenum AL_APIENTRY alGetError( void ); -ALAPI void ALAPIENTRY alGetBufferi( ALuint buffer, ALenum param, ALint* value ); -ALAPI void ALAPIENTRY alGetBufferf( ALuint buffer, ALenum param, ALfloat* value ); -ALAPI void ALAPIENTRY alGetBufferiv( ALuint buffer, ALenum param, ALint *v); -ALAPI void ALAPIENTRY alGetBufferfv( ALuint buffer, ALenum param, ALfloat *v); +/* + * 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 ); -/** - * Frequency Domain Filters are band filters. - * Attenuation in Media (distance based) - * Reflection Material - * Occlusion Material (separating surface) +AL_API ALenum AL_APIENTRY alGetEnumValue( const ALchar* ename ); + + +/* + * LISTENER + * Listener represents the location and orientation of the + * 'user' in 3D-space. * - * Temporal Domain Filters: - * Early Reflections - * Late Reverb + * Properties include: - * + * Gain AL_GAIN ALfloat + * Position AL_POSITION ALfloat[3] + * Velocity AL_VELOCITY ALfloat[3] + * Orientation AL_ORIENTATION ALfloat[6] (Forward then Up vectors) +*/ + +/* + * 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 ); -/** - * EXTENSION: IASIG Level 2 Environment. - * Environment object generation. - * This is an EXTension that describes the Environment/Reverb - * properties according to IASIG Level 2 specifications. +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 ); /** - * Allocate n environment ids and store them in the array environs. - * Returns the number of environments actually allocated. + * SOURCE + * Sources represent individual sound objects in 3D-space. + * Sources take the PCM data provided in the specified Buffer, + * apply Source-specific modifications, and then + * submit them to be mixed according to spatial arrangement etc. + * + * Properties include: - + * + * Gain AL_GAIN ALfloat + * Min Gain AL_MIN_GAIN ALfloat + * Max Gain AL_MAX_GAIN ALfloat + * Position AL_POSITION ALfloat[3] + * Velocity AL_VELOCITY ALfloat[3] + * Direction AL_DIRECTION ALfloat[3] + * Head Relative Mode AL_SOURCE_RELATIVE ALint (AL_TRUE or AL_FALSE) + * Reference Distance AL_REFERENCE_DISTANCE ALfloat + * Max Distance AL_MAX_DISTANCE ALfloat + * RollOff Factor AL_ROLLOFF_FACTOR ALfloat + * Inner Angle AL_CONE_INNER_ANGLE ALint or ALfloat + * Outer Angle AL_CONE_OUTER_ANGLE ALint or ALfloat + * Cone Outer Gain AL_CONE_OUTER_GAIN ALint or ALfloat + * Pitch AL_PITCH ALfloat + * Looping AL_LOOPING ALint (AL_TRUE or AL_FALSE) + * MS Offset AL_MSEC_OFFSET ALint or ALfloat + * Byte Offset AL_BYTE_OFFSET ALint or ALfloat + * Sample Offset AL_SAMPLE_OFFSET ALint or ALfloat + * Attached Buffer AL_BUFFER ALint + * State (Query only) AL_SOURCE_STATE ALint + * Buffers Queued (Query only) AL_BUFFERS_QUEUED ALint + * Buffers Processed (Query only) AL_BUFFERS_PROCESSED ALint */ -ALAPI ALsizei ALAPIENTRY alGenEnvironmentIASIG( ALsizei n, ALuint* environs ); -ALAPI void ALAPIENTRY alDeleteEnvironmentIASIG( ALsizei n, ALuint* environs ); +/* Create Source objects */ +AL_API void AL_APIENTRY alGenSources( ALsizei n, ALuint* sources ); -ALAPI ALboolean ALAPIENTRY alIsEnvironmentIASIG( ALuint environ ); +/* Delete Source objects */ +AL_API void AL_APIENTRY alDeleteSources( ALsizei n, const ALuint* sources ); -ALAPI void ALAPIENTRY alEnvironmentiIASIG( ALuint eid, ALenum param, ALint value ); +/* Verify a handle is a valid Source */ +AL_API ALboolean AL_APIENTRY alIsSource( ALuint sid ); -ALAPI void ALAPIENTRY alEnvironmentfIASIG( ALuint eid, ALenum param, ALfloat value ); +/* + * Set Source parameters + */ +AL_API void AL_APIENTRY alSourcef( ALuint sid, ALenum param, ALfloat value ); +AL_API void AL_APIENTRY alSource3f( ALuint sid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3 ); +AL_API void AL_APIENTRY alSourcefv( ALuint sid, ALenum param, const ALfloat* values ); -/** - * Queue stuff - */ -ALAPI void ALAPIENTRY alSourceQueueBuffers( ALuint sid, ALsizei numEntries, ALuint *bids ); -ALAPI void ALAPIENTRY alSourceUnqueueBuffers( ALuint sid, ALsizei numEntries, ALuint *bids ); -ALAPI void ALAPIENTRY alQueuei( ALuint sid, ALenum param, ALint value ); +AL_API void AL_APIENTRY alSourcei( ALuint sid, ALenum param, ALint value ); -/** - * Knobs and dials - */ -ALAPI void ALAPIENTRY alDopplerFactor( ALfloat value ); -ALAPI void ALAPIENTRY alDopplerVelocity( ALfloat value ); -ALAPI void ALAPIENTRY alDistanceModel( ALenum distanceModel ); - -#else /* AL_NO_PROTOTYPES */ - - -/** OpenAL Maintenance Functions */ - - void (*alEnable)( ALenum capability ); - void (*alDisable)( ALenum capability ); - ALboolean (*alIsEnabled)( ALenum capability ); - void (*alHint)( ALenum target, ALenum mode ); - ALboolean (*alGetBoolean)( ALenum param ); - ALint (*alGetInteger)( ALenum param ); - ALfloat (*alGetFloat)( ALenum param ); - ALdouble (*alGetDouble)( ALenum param ); - void (*alGetBooleanv)( ALenum param, - ALboolean* data ); - void (*alGetIntegerv)( ALenum param, - ALint* data ); - void (*alGetFloatv)( ALenum param, - ALfloat* data ); - void (*alGetDoublev)( ALenum param, - ALdouble* data ); - const ALubyte* (*GetString)( ALenum param ); - ALenum (*alGetError)( ALvoid ); - - /** - * Extension support. - * Query existance of extension - */ - ALboolean (*alIsExtensionPresent)(const ALubyte* fname ); - - /** - * Extension support. - * Obtain the address of a function (usually an extension) - * with the name fname. All addresses are context-independent. - */ - void* (*alGetProcAddress)( const ALubyte* fname ); - - - /** - * Extension support. - * Obtain the integer value of an enumeration (usually an extension) with the name ename. - */ - ALenum (*alGetEnumValue)( const ALubyte* ename ); +AL_API void AL_APIENTRY alSource3i( ALuint sid, ALenum param, ALint value1, ALint value2, ALint value3 ); -/** - * LISTENER - * Listener is the sample position for a given context. - * The multi-channel (usually stereo) output stream generated - * by the mixer is parametrized by this Listener object: - * its position and velocity relative to Sources, within - * occluder and reflector geometry. - */ - /** - * - * Listener Gain: default 1.0f. - */ - void (*alListenerf)( ALenum pname, ALfloat param ); - - /** - * - * Listener Position: ALfloat[3] - * Listener Velocity: ALfloat[3] - * Listener Orientation: ALfloat[6] (forward and up vector). - */ - void (*alListenerfv)( ALenum pname, ALfloat* param ); - - /* - * Retrieve listener information. - */ - void (*alGetListeneri)( ALenum pname, ALint* value ); - void (*alGetListenerf)( ALenum pname, ALfloat* value ); - - void (*alGetListeneriv)( ALenum pname, ALint* values ); - void (*alGetListenerfv)( ALenum pname, ALfloat* values ); +AL_API void AL_APIENTRY alSourceiv( ALuint sid, ALenum param, const ALint* values ); -/** - * SOURCE - * Source objects are by default localized. Sources - * take the PCM data provided in the specified Buffer, - * apply Source-specific modifications, and then - * submit them to be mixed according to spatial - * arrangement etc. +/* + * Get Source parameters */ +AL_API void AL_APIENTRY alGetSourcef( ALuint sid, ALenum param, ALfloat* value ); - /** Create Source objects. */ - void (*alGenSources)( ALsizei n, ALuint* sources ); +AL_API void AL_APIENTRY alGetSource3f( ALuint sid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3); - /** Delete Source objects. */ - void (*alDeleteSources)( ALsizei n, ALuint* sources ); +AL_API void AL_APIENTRY alGetSourcefv( ALuint sid, ALenum param, ALfloat* values ); - /** Verify a handle is a valid Source. */ - ALboolean (*alIsSource)( ALuint sid ); +AL_API void AL_APIENTRY alGetSourcei( ALuint sid, ALenum param, ALint* value ); - /** Set an integer parameter for a Source object. */ - void (*alSourcei)( ALuint sid, ALenum param, ALint value); +AL_API void AL_APIENTRY alGetSource3i( ALuint sid, ALenum param, ALint* value1, ALint* value2, ALint* value3); - /** Set a float parameter for a Source object. */ - void (*alSourcef)( ALuint sid, ALenum param, ALfloat value); +AL_API void AL_APIENTRY alGetSourceiv( ALuint sid, ALenum param, ALint* values ); - /** Set a 3 float parameter for a Source object. */ - void (*alSource3f)( ALuint sid, ALenum param, - ALfloat f1, ALfloat f2, ALfloat f3 ); - /** Set a float vector parameter for a Source object. */ - void (*alSourcefv)( ALuint sid, ALenum param, - ALfloat* values ); +/* + * Source vector based playback calls + */ - /** Get an integer scalar parameter for a Source object. */ - void (*alGetSourcei)( ALuint sid, - ALenum pname, ALint* value ); +/* Play, replay, or resume (if paused) a list of Sources */ +AL_API void AL_APIENTRY alSourcePlayv( ALsizei ns, const ALuint *sids ); - /** Get an integer parameter for a Source object. */ - void (*alGetSourceiv)( ALuint sid, - ALenum pname, ALint* values ); +/* Stop a list of Sources */ +AL_API void AL_APIENTRY alSourceStopv( ALsizei ns, const ALuint *sids ); - /** Get a float scalar parameter for a Source object. */ - void (*alGetSourcef)( ALuint sid, - ALenum pname, ALfloat* value ); +/* Rewind a list of Sources */ +AL_API void AL_APIENTRY alSourceRewindv( ALsizei ns, const ALuint *sids ); - /** Get three float scalar parameter for a Source object. */ - void (*alGetSource3f)( ALuint sid, ALenum pname, - ALfloat* value1, - ALfloat* value2, - ALfloat* value3); +/* Pause a list of Sources */ +AL_API void AL_APIENTRY alSourcePausev( ALsizei ns, const ALuint *sids ); - /** Get a float vector parameter for a Source object. */ - void (*alGetSourcefv)( ALuint sid, - ALenum pname, ALfloat* values ); +/* + * Source based playback calls + */ - - /** Activate a source, start replay. */ - void (*alSourcePlay)( ALuint sid ); - - /** - * Pause a source, - * temporarily remove it from the mixer list. - */ - void (*alSourcePause)( ALuint sid ); - - /** - * Stop a source, - * temporarily remove it from the mixer list, - * and reset its internal state to pre-Play. - * To remove a Source completely, it has to be - * deleted following Stop, or before Play. - */ - void (*alSourceStop)( ALuint sid ); - - /** - * Rewind a souce. Stopped paused and playing sources, - * resets the offset into the PCM data and sets state to - * AL_INITIAL. - */ - void (*alSourceRewind)( ALuint sid ); - - /** - * vector forms of those functions we all love - */ - void (*alSourcePlayv)( ALsizei ns, ALuint *ids ); - void (*alSourceStopv)( ALsizei ns, ALuint *ids ); - void (*alSourceRewindv)( ALsizei ns, ALuint *ids ); - void (*alSourcePausev)( ALsizei ns, ALuint *ids ); +/* Play, replay, or resume a Source */ +AL_API void AL_APIENTRY alSourcePlay( ALuint sid ); -/** - * BUFFER - * Buffer objects are storage space for sample data. - * Buffers are referred to by Sources. There can be more than - * one Source using the same Buffer data. If Buffers have - * to be duplicated on a per-Source basis, the driver has to - * take care of allocation, copying, and deallocation as well - * as propagating buffer data changes. - */ - - /** Buffer object generation. */ - void (*alGenBuffers)( ALsizei n, ALuint* buffers ); - void (*alDeleteBuffers)( ALsizei n, ALuint* buffers ); - ALboolean (*alIsBuffer)( ALuint buffer ); - - /** - * Specify the data to be filled into a buffer. - */ - void (*alBufferData)( ALuint buffer, - ALenum format, - ALvoid* data, - ALsizei size, - ALsizei freq ); - - void (*alGetBufferi)( ALuint buffer, - ALenum param, ALint* value ); - void (*alGetBufferf)( ALuint buffer, - ALenum param, ALfloat* value ); - void (*alGetBufferiv)( ALuint buffer, - ALenum param, ALint* value ); - void (*alGetBufferfv)( ALuint buffer, - ALenum param, ALfloat* value ); +/* Stop a Source */ +AL_API void AL_APIENTRY alSourceStop( ALuint sid ); + +/* Rewind a Source (set playback postiton to beginning) */ +AL_API void AL_APIENTRY alSourceRewind( ALuint sid ); + +/* Pause a Source */ +AL_API void AL_APIENTRY alSourcePause( ALuint sid ); + +/* + * Source Queuing + */ +AL_API void AL_APIENTRY alSourceQueueBuffers( ALuint sid, ALsizei numEntries, const ALuint *bids ); + +AL_API void AL_APIENTRY alSourceUnqueueBuffers( ALuint sid, ALsizei numEntries, ALuint *bids ); -/** - * EXTENSION: IASIG Level 2 Environment. - * Environment object generation. - * This is an EXTension that describes the Environment/Reverb - * properties according to IASIG Level 2 specifications. - */ - /** - * Allocate n environment ids and store them in the array environs. - * Returns the number of environments actually allocated. - */ - ALsizei (*alGenEnvironmentIASIG)( ALsizei n, ALuint* environs ); - void (*alDeleteEnvironmentIASIG)(ALsizei n, - ALuint* environs); - ALboolean (*alIsEnvironmentIASIG)( ALuint environ ); - void (*alEnvironmentiIASIG)( ALuint eid, - ALenum param, ALint value ); - void (*alEnvironmentfIASIG)( ALuint eid, - ALenum param, ALuint value ); - /** - * Queue stuff - */ - void (*alQueuei)(ALuint sid, ALenum param, ALint value ); - void (*alSourceUnqueueBuffers)(ALuint sid, ALsizei numEntries, ALuint *bids ); - void (*alSourceQueueBuffers)(ALuint sid, ALsizei numEntries, ALuint *bids ); - - void (*alDopplerFactor)( ALfloat value ); - void (*alDopplerVelocity)( ALfloat value ); - void (*alDistanceModel)( ALenum distanceModel ); /** - * Frequency Domain Filters are band filters. - * Attenuation in Media (distance based) - * Reflection Material - * Occlusion Material (separating surface) + * BUFFER + * Buffer objects are storage space for sample data. + * Buffers are referred to by Sources. One Buffer can be used + * by multiple Sources. * - * Temporal Domain Filters: - * Early Reflections - * Late Reverb + * Properties include: - * + * Frequency (Query only) AL_FREQUENCY ALint + * Size (Query only) AL_SIZE ALint + * Bits (Query only) AL_BITS ALint + * Channels (Query only) AL_CHANNELS ALint + */ + +/* 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 bid ); + +/* Specify the data to be copied into a buffer */ +AL_API void AL_APIENTRY alBufferData( ALuint bid, ALenum format, const ALvoid* data, ALsizei size, ALsizei freq ); + +/* + * Set Buffer parameters */ +AL_API void AL_APIENTRY alBufferf( ALuint bid, ALenum param, ALfloat value ); + +AL_API void AL_APIENTRY alBuffer3f( ALuint bid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3 ); -#endif /* AL_NO_PROTOTYPES */ +AL_API void AL_APIENTRY alBufferfv( ALuint bid, ALenum param, const ALfloat* values ); -#ifdef TARGET_OS_MAC -#if TARGET_OS_MAC -#pragma export off -#endif /* TARGET_OS_MAC */ -#endif /* TARGET_OS_MAC */ +AL_API void AL_APIENTRY alBufferi( ALuint bid, ALenum param, ALint value ); +AL_API void AL_APIENTRY alBuffer3i( ALuint bid, ALenum param, ALint value1, ALint value2, ALint value3 ); + +AL_API void AL_APIENTRY alBufferiv( ALuint bid, ALenum param, const ALint* values ); + +/* + * Get Buffer parameters + */ +AL_API void AL_APIENTRY alGetBufferf( ALuint bid, ALenum param, ALfloat* value ); + +AL_API void AL_APIENTRY alGetBuffer3f( ALuint bid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3); + +AL_API void AL_APIENTRY alGetBufferfv( ALuint bid, ALenum param, ALfloat* values ); + +AL_API void AL_APIENTRY alGetBufferi( ALuint bid, ALenum param, ALint* value ); + +AL_API void AL_APIENTRY alGetBuffer3i( ALuint bid, ALenum param, ALint* value1, ALint* value2, ALint* value3); + +AL_API void AL_APIENTRY alGetBufferiv( ALuint bid, ALenum param, ALint* values ); + + +/* + * Global Parameters + */ +AL_API void AL_APIENTRY alDopplerFactor( ALfloat value ); + +AL_API void AL_APIENTRY alDopplerVelocity( ALfloat value ); + +AL_API void AL_APIENTRY alSpeedOfSound( ALfloat value ); + +AL_API void AL_APIENTRY alDistanceModel( ALenum distanceModel ); + +/* + * Pointer-to-function types, 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* data ); +typedef void (AL_APIENTRY *LPALGETINTEGERV)( ALenum param, ALint* data ); +typedef void (AL_APIENTRY *LPALGETFLOATV)( ALenum param, ALfloat* data ); +typedef void (AL_APIENTRY *LPALGETDOUBLEV)( ALenum param, ALdouble* data ); +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 sid ); +typedef void (AL_APIENTRY *LPALSOURCEF)( ALuint sid, ALenum param, ALfloat value); +typedef void (AL_APIENTRY *LPALSOURCE3F)( ALuint sid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3 ); +typedef void (AL_APIENTRY *LPALSOURCEFV)( ALuint sid, ALenum param, const ALfloat* values ); +typedef void (AL_APIENTRY *LPALSOURCEI)( ALuint sid, ALenum param, ALint value); +typedef void (AL_APIENTRY *LPALSOURCE3I)( ALuint sid, ALenum param, ALint value1, ALint value2, ALint value3 ); +typedef void (AL_APIENTRY *LPALSOURCEIV)( ALuint sid, ALenum param, const ALint* values ); +typedef void (AL_APIENTRY *LPALGETSOURCEF)( ALuint sid, ALenum param, ALfloat* value ); +typedef void (AL_APIENTRY *LPALGETSOURCE3F)( ALuint sid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3); +typedef void (AL_APIENTRY *LPALGETSOURCEFV)( ALuint sid, ALenum param, ALfloat* values ); +typedef void (AL_APIENTRY *LPALGETSOURCEI)( ALuint sid, ALenum param, ALint* value ); +typedef void (AL_APIENTRY *LPALGETSOURCE3I)( ALuint sid, ALenum param, ALint* value1, ALint* value2, ALint* value3); +typedef void (AL_APIENTRY *LPALGETSOURCEIV)( ALuint sid, ALenum param, ALint* values ); +typedef void (AL_APIENTRY *LPALSOURCEPLAYV)( ALsizei ns, const ALuint *sids ); +typedef void (AL_APIENTRY *LPALSOURCESTOPV)( ALsizei ns, const ALuint *sids ); +typedef void (AL_APIENTRY *LPALSOURCEREWINDV)( ALsizei ns, const ALuint *sids ); +typedef void (AL_APIENTRY *LPALSOURCEPAUSEV)( ALsizei ns, const ALuint *sids ); +typedef void (AL_APIENTRY *LPALSOURCEPLAY)( ALuint sid ); +typedef void (AL_APIENTRY *LPALSOURCESTOP)( ALuint sid ); +typedef void (AL_APIENTRY *LPALSOURCEREWIND)( ALuint sid ); +typedef void (AL_APIENTRY *LPALSOURCEPAUSE)( ALuint sid ); +typedef void (AL_APIENTRY *LPALSOURCEQUEUEBUFFERS)(ALuint sid, ALsizei numEntries, const ALuint *bids ); +typedef void (AL_APIENTRY *LPALSOURCEUNQUEUEBUFFERS)(ALuint sid, ALsizei numEntries, ALuint *bids ); +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 bid ); +typedef void (AL_APIENTRY *LPALBUFFERDATA)( ALuint bid, ALenum format, const ALvoid* data, ALsizei size, ALsizei freq ); +typedef void (AL_APIENTRY *LPALBUFFERF)( ALuint bid, ALenum param, ALfloat value); +typedef void (AL_APIENTRY *LPALBUFFER3F)( ALuint bid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3 ); +typedef void (AL_APIENTRY *LPALBUFFERFV)( ALuint bid, ALenum param, const ALfloat* values ); +typedef void (AL_APIENTRY *LPALBUFFERI)( ALuint bid, ALenum param, ALint value); +typedef void (AL_APIENTRY *LPALBUFFER3I)( ALuint bid, ALenum param, ALint value1, ALint value2, ALint value3 ); +typedef void (AL_APIENTRY *LPALBUFFERIV)( ALuint bid, ALenum param, const ALint* values ); +typedef void (AL_APIENTRY *LPALGETBUFFERF)( ALuint bid, ALenum param, ALfloat* value ); +typedef void (AL_APIENTRY *LPALGETBUFFER3F)( ALuint bid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3); +typedef void (AL_APIENTRY *LPALGETBUFFERFV)( ALuint bid, ALenum param, ALfloat* values ); +typedef void (AL_APIENTRY *LPALGETBUFFERI)( ALuint bid, ALenum param, ALint* value ); +typedef void (AL_APIENTRY *LPALGETBUFFER3I)( ALuint bid, ALenum param, ALint* value1, ALint* value2, ALint* value3); +typedef void (AL_APIENTRY *LPALGETBUFFERIV)( ALuint bid, 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(TARGET_OS_MAC) && TARGET_OS_MAC + #pragma export off +#endif -#ifdef __cplusplus +#if defined(__cplusplus) } /* extern "C" */ #endif -#endif /* __al_h_ */ +#endif /* AL_AL_H */ diff --git a/Dependencies/OpenAL/include/AL/alc.h b/Dependencies/OpenAL/include/AL/alc.h index 5c8831f..4e84af4 100644 --- a/Dependencies/OpenAL/include/AL/alc.h +++ b/Dependencies/OpenAL/include/AL/alc.h @@ -1,110 +1,275 @@ -#ifndef ALC_CONTEXT_H_ -#define ALC_CONTEXT_H_ +#ifndef AL_ALC_H +#define AL_ALC_H -#include "altypes.h" -#include "alctypes.h" - -#ifdef __cplusplus +#if defined(__cplusplus) extern "C" { #endif -#define ALC_VERSION_0_1 1 - -#ifdef _WIN32 - #ifdef _OPENAL32LIB - #define ALCAPI __declspec(dllexport) +#if defined(_WIN32) && !defined(_XBOX) + #if defined(AL_BUILD_LIBRARY) + #define ALC_API __declspec(dllexport) #else - #define ALCAPI __declspec(dllimport) + #define ALC_API __declspec(dllimport) #endif - - typedef struct ALCdevice_struct ALCdevice; - typedef struct ALCcontext_struct ALCcontext; - - #define ALCAPIENTRY __cdecl #else - #ifdef TARGET_OS_MAC - #if TARGET_OS_MAC - #pragma export on - #endif + #if defined(AL_BUILD_LIBRARY) && defined(HAVE_GCC_VISIBILITY) + #define ALC_API __attribute__((visibility("protected"))) + #else + #define ALC_API extern #endif +#endif + +#if defined(_WIN32) + #define ALC_APIENTRY __cdecl +#else + #define ALC_APIENTRY +#endif - #define ALCAPI - #define ALCAPIENTRY +#if defined(TARGET_OS_MAC) && TARGET_OS_MAC + #pragma export on #endif -#ifndef AL_NO_PROTOTYPES +/* + * The ALCAPI, ALCAPIENTRY, and ALC_INVALID macros are deprecated, but are + * included for applications porting code from AL 1.0 + */ +#define ALCAPI ALC_API +#define ALCAPIENTRY ALC_APIENTRY +#define ALC_INVALID 0 + + +#define ALC_VERSION_0_1 1 + +typedef struct ALCdevice_struct ALCdevice; +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 + +/** + * followed by Hz + */ +#define ALC_FREQUENCY 0x1007 + +/** + * followed by Hz + */ +#define ALC_REFRESH 0x1008 + +/** + * followed by AL_TRUE, AL_FALSE + */ +#define ALC_SYNC 0x1009 + +/** + * followed by Num of requested Mono (3D) Sources + */ +#define ALC_MONO_SOURCES 0x1010 + +/** + * followed by Num of requested Stereo Sources + */ +#define ALC_STEREO_SOURCES 0x1011 + +/** + * errors + */ -ALCAPI ALCcontext * ALCAPIENTRY alcCreateContext( ALCdevice *dev, - ALint* attrlist ); +/** + * No error + */ +#define ALC_NO_ERROR ALC_FALSE /** - * There is no current context, as we can mix - * several active contexts. But al* calls - * only affect the current context. + * No device */ -ALCAPI ALCenum ALCAPIENTRY alcMakeContextCurrent( ALCcontext *alcHandle ); +#define ALC_INVALID_DEVICE 0xA001 /** - * Perform processing on a synced context, non-op on a asynchronous - * context. + * invalid context ID */ -ALCAPI ALCcontext * ALCAPIENTRY alcProcessContext( ALCcontext *alcHandle ); +#define ALC_INVALID_CONTEXT 0xA002 /** - * Suspend processing on an asynchronous context, non-op on a - * synced context. + * bad enum */ -ALCAPI void ALCAPIENTRY alcSuspendContext( ALCcontext *alcHandle ); +#define ALC_INVALID_ENUM 0xA003 -ALCAPI ALCenum ALCAPIENTRY alcDestroyContext( ALCcontext *alcHandle ); +/** + * bad value + */ +#define ALC_INVALID_VALUE 0xA004 -ALCAPI ALCenum ALCAPIENTRY alcGetError( ALCdevice *dev ); +/** + * Out of memory. + */ +#define ALC_OUT_OF_MEMORY 0xA005 -ALCAPI ALCcontext * ALCAPIENTRY alcGetCurrentContext( ALvoid ); -ALCAPI ALCdevice *alcOpenDevice( const ALubyte *tokstr ); -ALCAPI void alcCloseDevice( ALCdevice *dev ); +/** + * The Specifier string for default device + */ +#define ALC_DEFAULT_DEVICE_SPECIFIER 0x1004 +#define ALC_DEVICE_SPECIFIER 0x1005 +#define ALC_EXTENSIONS 0x1006 -ALCAPI ALboolean ALCAPIENTRY alcIsExtensionPresent(ALCdevice *device, ALubyte *extName); -ALCAPI ALvoid * ALCAPIENTRY alcGetProcAddress(ALCdevice *device, ALubyte *funcName); -ALCAPI ALenum ALCAPIENTRY alcGetEnumValue(ALCdevice *device, ALubyte *enumName); +#define ALC_MAJOR_VERSION 0x1000 +#define ALC_MINOR_VERSION 0x1001 -ALCAPI ALCdevice* ALCAPIENTRY alcGetContextsDevice(ALCcontext *context); +#define ALC_ATTRIBUTES_SIZE 0x1002 +#define ALC_ALL_ATTRIBUTES 0x1003 /** + * Capture extension + */ +#define ALC_CAPTURE_DEVICE_SPECIFIER 0x310 +#define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER 0x311 +#define ALC_CAPTURE_SAMPLES 0x312 + + +/* + * 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 Context 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 functions */ -const ALubyte * alcGetString( ALCdevice *deviceHandle, ALenum token ); -void alcGetIntegerv( ALCdevice *deviceHandle, ALenum token , ALsizei size , ALint *dest ); +ALC_API const ALCchar * ALC_APIENTRY alcGetString( ALCdevice *device, ALCenum param ); -#else - ALCcontext * (*alcCreateContext)( ALCdevice *dev, ALint* attrlist ); - ALCenum (*alcMakeContextCurrent)( ALCcontext *alcHandle ); - ALCcontext * (*alcProcessContext)( ALCcontext *alcHandle ); - void (*alcSuspendContext)( ALCcontext *alcHandle ); - ALCenum (*alcDestroyContext)( ALCcontext *alcHandle ); - ALCenum (*alcGetError)( ALCdevice *dev ); - ALCcontext * (*alcGetCurrentContext)( ALvoid ); - ALCdevice * (*alcOpenDevice)( const ALubyte *tokstr ); - void (*alcCloseDevice)( ALCdevice *dev ); - ALboolean (*alcIsExtensionPresent)( ALCdevice *device, ALubyte *extName ); - ALvoid * (*alcGetProcAddress)(ALCdevice *device, ALubyte *funcName ); - ALenum (*alcGetEnumValue)(ALCdevice *device, ALubyte *enumName); - ALCdevice* (*alcGetContextsDevice)(ALCcontext *context); - const ALubyte* (*alcGetString)( ALCdevice *deviceHandle, ALenum token ); - void (*alcGetIntegerv*)( ALCdevice *deviceHandle, ALenum token , ALsizei size , ALint *dest ); - -#endif /* AL_NO_PROTOTYPES */ - -#ifdef TARGET_OS_MAC -#if TARGET_OS_MAC -#pragma export off -#endif /* TARGET_OS_MAC */ -#endif /* TARGET_OS_MAC */ - -#ifdef __cplusplus +ALC_API void ALC_APIENTRY alcGetIntegerv( ALCdevice *device, ALCenum param, ALCsizei size, ALCint *data ); + + +/* + * Capture functions + */ +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 types, 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 *dest ); +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(TARGET_OS_MAC) && TARGET_OS_MAC + #pragma export off +#endif + +#if defined(__cplusplus) } #endif -#endif /* ALC_CONTEXT_H_ */ +#endif /* AL_ALC_H */ -- 2.39.2