Unit KambiOpenAL

DescriptionusesClasses, Interfaces, Objects and RecordsFunctions and ProceduresTypesConstantsVariables

Description

OpenAL library functions. This is a translation of OpenAL C headers: AL/al.h, AL/alc.h, AL/alut.h (and included headers: AL/altypes.h, AL/alctypes.h).

Renamed to KambiOpenAL (from OpenAL) to avoid clash with FPC's OpenAL unit. In the future, we may drop to using FPC's OpenAL unit, for now this unit has at least one advantage over FPC's OpenAL unit: if OpenAL library is not present (so, dylib or dll), it will simply set ALInited to False. While FPC's OpenAL unit links to OpenAL using "external" and will fail when library is not present at runtime.

Ogolne strategie tlumaczenia :

Funkcje i procedury sa przetlumaczone na wskazniki na funkcje. W inicjalizacji tego modulu probujemy je zaladowac z odpowiednich DLLi ale _nie ma zadnych gwarancji ze to sie uda_. Kazdy program uzywajacy tego modulu musi sie jakos upewnic ze ALInited (przed uzyciem dowolnej funkcji alXxx i alcXxx), jesli chce uzywac takze alutXxx to musi tez sprawdzic ze ALUTInited. Np. gry ktore powinny probowac zainicjowac OpenAL'a ale jednoczesnie powinny moc dzialac jesli nie ma OpenAL'a dostepnego (no bo w koncu, jesli nie ma muzyki to trudno - - grac mozna i bez muzyki) musza sprawdzac przed kazdym wejsciem w kazdy kawalek kodu uzywajacy OpenAL'a czy ALInited (ew. czy ALUTInited). Z drugiej strony, programy ktore nie chca komplikowac sobie tak zycia i chca dzialac na zasadzie "jesli nie ma dostepnego OpenAL'a to nie bede dzialal" moga wywolac proste Check(ALInited, "OpenAL is not available. This program requires OpenAL."); (albo cos podobnego dla ALUTInited) i potem w dalszej czesci programu mozemy swobodnie uzywac OpenAL'owych funkcji. Takie dwie funkcje CheckALInited i CheckALUTInited juz sa zreszta gotowe w tym module.

Wszystkie zmienne w interfejsie tego modulu sa zmiennymi tylko dlatego ze to upraszcza mi robote. Nigdy nie moga byc modyfikowane z zewnatrz tego modulu - dotyczy to zarowno wskaznikow na wszystkie funkcje/procedury jak i zmiennych AL/ALUTInited.

uses

Overview

Classes, Interfaces, Objects and Records

Name Description
record TALCdevice translation of AL/alctypes.h
record TALCcontext  
Class EOpenALError  
Class EOpenALInitError  

Functions and Procedures

procedure CheckALInited;
procedure CheckALUTInited;
procedure OpenALRestart;

Types

TALboolean = ByteBool;
PALboolean = ˆTALboolean;
TALbyte = ShortInt;
PALbyte = ˆTALbyte;
TALubyte = Byte;
PALubyte = ˆTALubyte;
TALshort = SmallInt;
PALshort = ˆTALshort;
TALushort = Word;
PALushort = ˆTALushort;
TALuint = LongWord;
PALuint = ˆTALuint;
TALint = LongInt;
PALint = ˆTALint;
TALfloat = Single;
PALfloat = ˆTALfloat;
TALdouble = Double;
PALdouble = ˆTALdouble;
TALsizei = LongInt;
PALsizei = ˆTALsizei;
PALvoid = Pointer;
TALenum = LongInt;
PALenum = ˆTALenum;
TALbitfield = LongWord;
PALbitfield = ˆTALbitfield;
TALclampf = TALfloat;
PALclampf = ˆTALclampf;
TALclampd = TALdouble;
PALclampd = ˆTALclampd;
PALCdevice = ˆTALCdevice;
PALCcontext = ˆTALCcontext;
TALCenum = LongInt;
TALVector3f = TVector3Single;
TALVector3d = TVector3Double;
TALTwoVectors3f = array[0..1]of TALVector3f;
TALTwoVectors3d = array[0..1]of TALVector3d;

Constants

AL_INVALID = -1;
AL_NONE = 0;
AL_FALSE = 0;
AL_TRUE = 1;
AL_SOURCE_TYPE = $0200;
AL_SOURCE_RELATIVE = $0202;
AL_CONE_INNER_ANGLE = $1001;
AL_CONE_OUTER_ANGLE = $1002;
AL_PITCH = $1003;
AL_POSITION = $1004;
AL_DIRECTION = $1005;
AL_VELOCITY = $1006;
AL_LOOPING = $1007;
AL_STREAMING = $1008;
AL_BUFFER = $1009;
AL_GAIN = $100A;
AL_BYTE_LOKI = $100C;
AL_MIN_GAIN = $100D;
AL_MAX_GAIN = $100E;
AL_ORIENTATION = $100F;
AL_SOURCE_STATE = $1010;
AL_INITIAL = $1011;
AL_PLAYING = $1012;
AL_PAUSED = $1013;
AL_STOPPED = $1014;
AL_BUFFERS_QUEUED = $1015;
AL_BUFFERS_PROCESSED = $1016;
AL_PENDING = $1017;
AL_PROCESSED = $1018;
AL_FORMAT_MONO8 = $1100;
AL_FORMAT_MONO16 = $1101;
AL_FORMAT_STEREO8 = $1102;
AL_FORMAT_STEREO16 = $1103;
AL_REFERENCE_DISTANCE = $1020;
AL_ROLLOFF_FACTOR = $1021;
AL_CONE_OUTER_GAIN = $1022;
AL_MAX_DISTANCE = $1023;
AL_FREQUENCY = $2001;
AL_BITS = $2002;
AL_CHANNELS = $2003;
AL_SIZE = $2004;
AL_UNUSED = $2010;
AL_QUEUED = $2011;
AL_CURRENT = $2012;
AL_NO_ERROR = AL_FALSE;
AL_INVALID_NAME = $A001;
AL_ILLEGAL_ENUM = $A002;
AL_INVALID_VALUE = $A003;
AL_ILLEGAL_COMMAND = $A004;
AL_OUT_OF_MEMORY = $A005;
AL_VENDOR = $B001;
AL_VERSION = $B002;
AL_RENDERER = $B003;
AL_EXTENSIONS = $B004;
AL_DOPPLER_FACTOR = $C000;
AL_DOPPLER_VELOCITY = $C001;
AL_DISTANCE_SCALE = $C002;
AL_DISTANCE_MODEL = $D000;
AL_INVERSE_DISTANCE = $D001;
AL_INVERSE_DISTANCE_CLAMPED = $D002;
AL_ENV_ROOM_IASIG = $3001;
AL_ENV_ROOM_HIGH_FREQUENCY_IASIG = $3002;
AL_ENV_ROOM_ROLLOFF_FACTOR_IASIG = $3003;
AL_ENV_DECAY_TIME_IASIG = $3004;
AL_ENV_DECAY_HIGH_FREQUENCY_RATIO_IASIG = $3005;
AL_ENV_REFLECTIONS_IASIG = $3006;
AL_ENV_REFLECTIONS_DELAY_IASIG = $3006;
AL_ENV_REVERB_IASIG = $3007;
AL_ENV_REVERB_DELAY_IASIG = $3008;
AL_ENV_DIFFUSION_IASIG = $3009;
AL_ENV_DENSITY_IASIG = $300A;
AL_ENV_HIGH_FREQUENCY_REFERENCE_IASIG = $300B;
AL_FORMAT_MP3_EXT = $10020;
AL_FORMAT_VORBIS_EXT = $10003;
ALC_INVALID = 0;
ALC_FREQUENCY = $100;
ALC_REFRESH = $101;
ALC_SYNC = $102;
ALC_NO_ERROR = 0;
ALC_INVALID_DEVICE = $200;
ALC_INVALID_CONTEXT = $201;
ALC_INVALID_ENUM = $202;
ALC_INVALID_VALUE = $203;
ALC_OUT_OF_MEMORY = $204;
ALC_DEFAULT_DEVICE_SPECIFIER = $300;
ALC_DEVICE_SPECIFIER = $301;
ALC_EXTENSIONS = $302;
ALC_MAJOR_VERSION = $303;
ALC_MINOR_VERSION = $304;
ALC_ATTRIBUTES_SIZE = $305;
ALC_ALL_ATTRIBUTES = $306;
ALC_FALSE = 0;
ALC_TRUE = 1;
OpenALDLL = 'libopenal.so.0' ;

Variables

alEnable: procedure( capability:TALenum ); cdecl;
alDisable: procedure( capability:TALenum ); cdecl;
alIsEnabled: function( capability:TALenum ):TALboolean; cdecl;
alGetBooleanv: procedure( param:TALenum; data:PALboolean ); cdecl;
alGetIntegerv: procedure( param:TALenum; data:PALint ); cdecl;
alGetFloatv: procedure( param:TALenum; data:PALfloat ); cdecl;
alGetDoublev: procedure( param:TALenum; data:PALdouble ); cdecl;
alGetString: function( param:TALenum ):PChar; cdecl;
alGetBoolean: function( param:TALenum ):TALboolean; cdecl;
alGetInteger: function( param:TALenum ):TALint; cdecl;
alGetFloat: function( param:TALenum ):TALfloat; cdecl;
alGetDouble: function( param:TALenum ):TALdouble; cdecl;
alGetError: function():TALenum; cdecl;
alIsExtensionPresent: function( fname:PChar ):TALboolean; cdecl;
alGetProcAddress: function( fname:PChar ):Pointer; cdecl;
alGetEnumValue: function( ename:PChar ):TALenum; cdecl;
alListenerf: procedure( pname:TALenum; param:TALfloat ); cdecl;
alListeneri: procedure( pname:TALenum; param:TALint ); cdecl;
alListener3f: procedure( pname:TALenum; f1, f2, f3:TALfloat ); cdecl;
alListenerfv: procedure( pname:TALenum; param:PALfloat ); cdecl;
alGetListeneri: procedure( pname:TALenum; value:PALint ); cdecl;
alGetListenerf: procedure( pname:TALenum; value:PALfloat ); cdecl;
alGetListenerfv: procedure( pname:TALenum; values:PALfloat ); cdecl;
alGetListener3f: procedure( pname:TALenum; f1, f2, f3:PALfloat ); cdecl;
alGenSources: procedure( n:TALsizei; sources:PALuint ); cdecl;
alDeleteSources: procedure( n:TALsizei; sources:PALuint ); cdecl;
alIsSource: function( sid:TALuint ):TALboolean; cdecl;
alSourcei: procedure( sid:TALuint; param:TALenum; value:TALint ); cdecl;
alSourcef: procedure( sid:TALuint; param:TALenum; value:TALfloat ); cdecl;
alSource3f: procedure( sid:TALuint; param:TALenum; f1, f2, f3:TALfloat ); cdecl;
alSourcefv: procedure( sid:TALuint; param:TALenum; values:PALfloat ); cdecl;
alGetSourcei: procedure( sid:TALuint; pname:TALenum; value:PALint ); cdecl;
alGetSourcef: procedure( sid:TALuint; pname:TALenum; value:PALfloat ); cdecl;
alGetSourcefv: procedure( sid:TALuint; pname:TALenum; values:PALfloat ); cdecl;
alGetSource3f: procedure( sid:TALuint; pname:TALenum; value1, value2, value3:PALfloat); cdecl;
alSourcePlayv: procedure( ns:TALsizei; ids:PALuint ); cdecl;
alSourceStopv: procedure( ns:TALsizei; ids:PALuint ); cdecl;
alSourceRewindv: procedure( ns:TALsizei; ids:PALuint ); cdecl;
alSourcePausev: procedure( ns:TALsizei; ids:PALuint ); cdecl;
alSourcePlay: procedure( sid:TALuint ); cdecl;
alSourcePause: procedure( sid:TALuint ); cdecl;
alSourceRewind: procedure( sid:TALuint ); cdecl;
alSourceStop: procedure( sid:TALuint ); cdecl;
alGenBuffers: procedure( n:TALsizei; buffers:PALuint ); cdecl;
alDeleteBuffers: procedure( n:TALsizei; buffers:PALuint ); cdecl;
alIsBuffer: function( buffer:TALuint ):TALboolean; cdecl;
alBufferData: procedure( buffer:TALuint; format:TALenum; data:PALvoid; size, freq:TALsizei ); cdecl;
alGetBufferi: procedure( buffer:TALuint; param:TALenum; value:PALint ); cdecl;
alGetBufferf: procedure( buffer:TALuint; param:TALenum; value:PALfloat ); cdecl;
alGenEnvironmentIASIG: function( n:TALsizei; environs:PALuint ):TALsizei; cdecl;
alDeleteEnvironmentIASIG: procedure( n:TALsizei; environs:PALuint ); cdecl;
alIsEnvironmentIASIG: function( environ:TALuint ):TALboolean; cdecl;
alEnvironmentiIASIG: procedure( eid:TALuint; param:TALenum; value:TALint ); cdecl;
alSourceQueueBuffers: procedure( sid:TALuint; numEntries:TALsizei; bids:PALuint ); cdecl;
alSourceUnqueueBuffers: procedure( sid:TALuint; numEntries:TALsizei; bids:PALuint ); cdecl;
alDopplerFactor: procedure( value:TALfloat ); cdecl;
alDopplerVelocity: procedure( value:TALfloat ); cdecl;
alDistanceModel: procedure( distanceModel:TALenum ); cdecl;
alcCreateContext: function( dev:PALCdevice; attrlist:PALint ):PALCcontext; cdecl;
alcMakeContextCurrent: function( alcHandle:PALCcontext ):TALCenum; cdecl;
alcProcessContext: function( alcHandle:PALCcontext ):PALCcontext; cdecl;
alcSuspendContext: procedure( alcHandle:PALCcontext ); cdecl;
alcDestroyContext: function( alcHandle:PALCcontext ):TALCenum; cdecl;
alcGetError: function( dev:PALCdevice ):TALCenum; cdecl;
alcGetCurrentContext: function():PALCcontext; cdecl;
alcOpenDevice: function( tokstr:PChar ):PALCdevice; cdecl;
alcCloseDevice: procedure( dev:PALCdevice ); cdecl;
alcIsExtensionPresent: function(device:PALCdevice; extName:PChar):TALboolean; cdecl;
alcGetProcAddress: function(device:PALCdevice; funcName:PChar):PALvoid; cdecl;
alcGetEnumValue: function(device:PALCdevice; enumName:PChar):TALenum; cdecl;
alcGetContextsDevice: function(context:PALCcontext):PALCdevice; cdecl;
alcGetString: function(deviceHandle:PALCdevice; token:TALenum):PChar; cdecl;
alcGetIntegerv: procedure(deviceHandle:PALCdevice; token:TALenum; size:TALsizei; dest:PALint); cdecl;
alutInit: procedure(var argc:LongInt; argv:PPChar); cdecl;
alutExit: procedure(); cdecl;
alutLoadWAV: function( fname:PChar; var wave:PALvoid; var format, size, bits, freq:TALsizei ):TALboolean; cdecl;
alutLoadWAVFile: procedure(afile:PChar; var format:TALenum; var data:PALvoid; var size, freq:TALsizei; var loop:TALboolean); cdecl;
alutLoadWAVMemory: procedure(memory:PALbyte; var format:TALenum; var data:PALvoid; var size, freq:TALsizei; var loop:TALboolean); cdecl;
alutUnloadWAV: procedure(format:TALenum; data:PALvoid; size, freq:TALsizei); cdecl;
ALInited: boolean = false;
ALUTInited: boolean = false;

Description

Functions and Procedures

procedure CheckALInited;

Check is appropriate variable (ALInited, ALUTInited) True, if not — raise EOpenALInitError with appropriate message. Actually these trivial procedures are implemented only because I wanted to place inside standard error messages for missing OpenAL functionality.

Exceptions raised
EOpenALInitError
If appropriate variable is False.
procedure CheckALUTInited;
 
procedure OpenALRestart;

Reset OpenAL library.

In this unit's initialization, we link to OpenAL library, load all symbols, and initialize ALInited and ALUTInited. In this unit's finalization, we release library handles and set ALInited and ALUTInited back to False.

What this procedure does ? It behaves like finalizing this unit (releasing OpenAL library handles), then sleeping for some short amount, and initializing this unit again (loading OpenAL library symbols).

When is it needed ?

Unix OpenAL implementation seems to have a problem. It's reproduceable in "The Castle" code: When I want to switch from one OpenAL device to the other, I would like to call EndAL (this releases OpenAL context and device), change my device name, and call BeginAL (this allocates OpenAL context and device). But this causes problems under Linux: when user selects some non-working device (e.g. when I select esd device while Esound daemon is not running), OpenAL (correctly) doesn't let me initialize the device (returns nil). But then, after such failure, when I try to initialize *any* other device (that worked before, like alsa or waveout), the initialization of them also fails. I have to restart my program (to restart whole OpenAL library state) to be able to initialize any other backend.

Workaround that I found is to do such OpenALRestart. Release OpenAL library, wait some short time (I guess that otherwise some resources will still occupy the sound device ? In any case, this short sleep is needed...), then do OpenAL library initialization again. And things work correctly.

Types

TALboolean = ByteBool;

* OpenAL bool type.

PALboolean = ˆTALboolean;
 
TALbyte = ShortInt;

* OpenAL 8bit signed byte.

PALbyte = ˆTALbyte;
 
TALubyte = Byte;

* OpenAL 8bit unsigned byte.

PALubyte = ˆTALubyte;
 
TALshort = SmallInt;

* OpenAL 16bit signed short integer type.

PALshort = ˆTALshort;
 
TALushort = Word;

* OpenAL 16bit unsigned short integer type.

PALushort = ˆTALushort;
 
TALuint = LongWord;

* OpenAL 32bit unsigned integer type.

PALuint = ˆTALuint;
 
TALint = LongInt;

* OpenAL 32bit signed integer type.

PALint = ˆTALint;
 
TALfloat = Single;

* OpenAL 32bit floating point type.

PALfloat = ˆTALfloat;
 
TALdouble = Double;

* OpenAL 64bit double point type.

PALdouble = ˆTALdouble;
 
TALsizei = LongInt;

* OpenAL 32bit type.

PALsizei = ˆTALsizei;
 
PALvoid = Pointer;
 
TALenum = LongInt;

* OpenAL enumerations.

PALenum = ˆTALenum;
 
TALbitfield = LongWord;

* OpenAL bitfields.

PALbitfield = ˆTALbitfield;
 
TALclampf = TALfloat;

* OpenAL clamped float.

PALclampf = ˆTALclampf;
 
TALclampd = TALdouble;

* Openal clamped double.

PALclampd = ˆTALclampd;
 
PALCdevice = ˆTALCdevice;
 
PALCcontext = ˆTALCcontext;
 
TALCenum = LongInt;
 
TALVector3f = TVector3Single;
 
TALVector3d = TVector3Double;
 
TALTwoVectors3f = array[0..1]of TALVector3f;

TwoVectors type is useful for OpenAL's listener ORIENTATION property.

TALTwoVectors3d = array[0..1]of TALVector3d;
 

Constants

AL_INVALID = -1;

bad value

AL_NONE = 0;
 
AL_FALSE = 0;

Boolean False.

AL_TRUE = 1;

* Boolean True.

AL_SOURCE_TYPE = $0200;

* * Indicate the type of AL_SOURCE. * Sources can be spatialized

AL_SOURCE_RELATIVE = $0202;

* Indicate Source has relative coordinates.

AL_CONE_INNER_ANGLE = $1001;

* * Directional source, inner cone angle, in degrees. * Range: [0-360] * Default: 360

AL_CONE_OUTER_ANGLE = $1002;

* * Directional source, outer cone angle, in degrees. * Range: [0-360] * Default: 360

AL_PITCH = $1003;

* * Specify the pitch to be applied, either at source, * or on mixer results, at listener. * Range: [0.5-2.0] * Default: 1.0

AL_POSITION = $1004;

* * 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.

AL_DIRECTION = $1005;

* Specify the current direction.

AL_VELOCITY = $1006;

* Specify the current velocity in three dimensional space.

AL_LOOPING = $1007;

* * Indicate whether source is looping. * Type: ALboolean? * Range: [AL_TRUE, AL_FALSE] * Default: FALSE.

AL_STREAMING = $1008;

* * Indicate whether source is meant to be streaming. * Type: ALboolean? * Range: [AL_TRUE, AL_FALSE] * Default: FALSE.

AL_BUFFER = $1009;

* * Indicate the buffer to provide sound samples. * Type: ALuint. * Range: any valid Buffer id.

AL_GAIN = $100A;

* * 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.

AL_BYTE_LOKI = $100C;

byte offset into source (in canon format). -1 if source * is not playing. Don't set this, get this. * * Type: ALint * Range: -1 - +inf

AL_MIN_GAIN = $100D;

* Indicate minimum source attenuation * Type: ALfloat * Range: [0.0 - 1.0] * * Logarthmic

AL_MAX_GAIN = $100E;

* * Indicate maximum source attenuation * Type: ALfloat * Range: [0.0 - 1.0] * * Logarthmic

AL_ORIENTATION = $100F;

* * Indicate listener orientation. * * at/up

AL_SOURCE_STATE = $1010;

* * Source state information.

AL_INITIAL = $1011;
 
AL_PLAYING = $1012;
 
AL_PAUSED = $1013;
 
AL_STOPPED = $1014;
 
AL_BUFFERS_QUEUED = $1015;

* * Buffer Queue params

AL_BUFFERS_PROCESSED = $1016;
 
AL_PENDING = $1017;

* * Buffer states

AL_PROCESSED = $1018;
 
AL_FORMAT_MONO8 = $1100;

* Sound samples: format specifier.

AL_FORMAT_MONO16 = $1101;
 
AL_FORMAT_STEREO8 = $1102;
 
AL_FORMAT_STEREO16 = $1103;
 
AL_REFERENCE_DISTANCE = $1020;

* * source specific reference distance * Type: ALfloat * Range: 0.0 - +inf * * At 0.0, no distance attenuation occurs. Default is * 1.0.

AL_ROLLOFF_FACTOR = $1021;

* * source specific rolloff factor * Type: ALfloat * Range: 0.0 - +inf *

AL_CONE_OUTER_GAIN = $1022;

* * Directional source, outer cone gain. * * Default: 0.0 * Range: [0.0 - 1.0] * Logarithmic

AL_MAX_DISTANCE = $1023;

* * Indicate distance above which sources are not * attenuated using the inverse clamped distance model. * * Default: +inf * Type: ALfloat * Range: 0.0 - +inf

AL_FREQUENCY = $2001;

* * 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.

AL_BITS = $2002;
 
AL_CHANNELS = $2003;
 
AL_SIZE = $2004;
 
AL_UNUSED = $2010;

* * Buffer state. * * Not supported for public use (yet).

AL_QUEUED = $2011;
 
AL_CURRENT = $2012;
 
AL_NO_ERROR = AL_FALSE;

* Errors: No Error.

AL_INVALID_NAME = $A001;

* * Invalid Name paramater passed to AL call.

AL_ILLEGAL_ENUM = $A002;

* * Invalid parameter passed to AL call.

AL_INVALID_VALUE = $A003;

* * Invalid enum parameter value.

AL_ILLEGAL_COMMAND = $A004;

* * Illegal call.

AL_OUT_OF_MEMORY = $A005;

* * No mojo.

AL_VENDOR = $B001;

* Context strings: Vendor Name.

AL_VERSION = $B002;
 
AL_RENDERER = $B003;
 
AL_EXTENSIONS = $B004;
 
AL_DOPPLER_FACTOR = $C000;

* * Doppler scale. Default 1.0

AL_DOPPLER_VELOCITY = $C001;

* * Tweaks speed of propagation.

AL_DISTANCE_SCALE = $C002;

* * Distance scaling

AL_DISTANCE_MODEL = $D000;

* * Distance models * * used in conjunction with DistanceModel * * implicit: NONE, which disances distance attenuation.

AL_INVERSE_DISTANCE = $D001;
 
AL_INVERSE_DISTANCE_CLAMPED = $D002;
 
AL_ENV_ROOM_IASIG = $3001;

* * Parameter: IASIG ROOM blah * Type: intgeger * Range: [-10000, 0] * Default: -10000

AL_ENV_ROOM_HIGH_FREQUENCY_IASIG = $3002;

* * Parameter: IASIG ROOM_HIGH_FREQUENCY * Type: integer * Range: [-10000, 0] * Default: 0

AL_ENV_ROOM_ROLLOFF_FACTOR_IASIG = $3003;

* * Parameter: IASIG ROOM_ROLLOFF_FACTOR * Type: float * Range: [0.0, 10.0] * Default: 0.0

AL_ENV_DECAY_TIME_IASIG = $3004;

* * Parameter: IASIG DECAY_TIME * Type: float * Range: [0.1, 20.0] * Default: 1.0

AL_ENV_DECAY_HIGH_FREQUENCY_RATIO_IASIG = $3005;

* * Parameter: IASIG DECAY_HIGH_FREQUENCY_RATIO * Type: float * Range: [0.1, 2.0] * Default: 0.5

AL_ENV_REFLECTIONS_IASIG = $3006;

* * Parameter: IASIG REFLECTIONS * Type: integer * Range: [-10000, 1000] * Default: -10000

AL_ENV_REFLECTIONS_DELAY_IASIG = $3006;

* * Parameter: IASIG REFLECTIONS_DELAY * Type: float * Range: [0.0, 0.3] * Default: 0.02

AL_ENV_REVERB_IASIG = $3007;

* * Parameter: IASIG REVERB * Type: integer * Range: [-10000,2000] * Default: -10000

AL_ENV_REVERB_DELAY_IASIG = $3008;

* * Parameter: IASIG REVERB_DELAY * Type: float * Range: [0.0, 0.1] * Default: 0.04

AL_ENV_DIFFUSION_IASIG = $3009;

* * Parameter: IASIG DIFFUSION * Type: float * Range: [0.0, 100.0] * Default: 100.0

AL_ENV_DENSITY_IASIG = $300A;

* * Parameter: IASIG DENSITY * Type: float * Range: [0.0, 100.0] * Default: 100.0

AL_ENV_HIGH_FREQUENCY_REFERENCE_IASIG = $300B;

* * Parameter: IASIG HIGH_FREQUENCY_REFERENCE * Type: float * Range: [20.0, 20000.0] * Default: 5000.0

AL_FORMAT_MP3_EXT = $10020;

MP3 format. See http://icculus.org/alextreg/index.php?operation=op_showext&extname=AL_EXT_mp3

AL_FORMAT_VORBIS_EXT = $10003;

Ogg Vorbis format. See http://icculus.org/alextreg/index.php?operation=op_showext&extname=AL_EXT_vorbis

ALC_INVALID = 0;

bad value

ALC_FREQUENCY = $100;
 
ALC_REFRESH = $101;
 
ALC_SYNC = $102;
 
ALC_NO_ERROR = 0;

No error.

ALC_INVALID_DEVICE = $200;

No device.

ALC_INVALID_CONTEXT = $201;

Invalid context ID.

ALC_INVALID_ENUM = $202;

Bad enum.

ALC_INVALID_VALUE = $203;

Bad value.

ALC_OUT_OF_MEMORY = $204;

Out of memory.

ALC_DEFAULT_DEVICE_SPECIFIER = $300;

The Specifier string for default device.

ALC_DEVICE_SPECIFIER = $301;
 
ALC_EXTENSIONS = $302;
 
ALC_MAJOR_VERSION = $303;
 
ALC_MINOR_VERSION = $304;
 
ALC_ATTRIBUTES_SIZE = $305;
 
ALC_ALL_ATTRIBUTES = $306;
 
ALC_FALSE = 0;
 
ALC_TRUE = 1;
 
OpenALDLL = 'libopenal.so.0' ;
 

Variables

alEnable: procedure( capability:TALenum ); cdecl;
 
alDisable: procedure( capability:TALenum ); cdecl;
 
alIsEnabled: function( capability:TALenum ):TALboolean; cdecl;
 
alGetBooleanv: procedure( param:TALenum; data:PALboolean ); cdecl;

State retrieval.

alGetIntegerv: procedure( param:TALenum; data:PALint ); cdecl;

State retrieval.

alGetFloatv: procedure( param:TALenum; data:PALfloat ); cdecl;

State retrieval.

alGetDoublev: procedure( param:TALenum; data:PALdouble ); cdecl;

State retrieval.

alGetString: function( param:TALenum ):PChar; cdecl;

State retrieval.

alGetBoolean: function( param:TALenum ):TALboolean; cdecl;

State retrieval through return value ( for compatibility ).

alGetInteger: function( param:TALenum ):TALint; cdecl;
 
alGetFloat: function( param:TALenum ):TALfloat; cdecl;
 
alGetDouble: function( param:TALenum ):TALdouble; cdecl;
 
alGetError: function():TALenum; cdecl;

Error support. Obtain the most recent error generated in the AL state machine.

alIsExtensionPresent: function( fname:PChar ):TALboolean; cdecl;

Extension support. Obtain the address of a function (usually an extension) with the name fname. All addresses are context-independent.

alGetProcAddress: function( fname:PChar ):Pointer; cdecl;

Extension support. Obtain the address of a function (usually an extension) with the name fname. All addresses are context-independent.

alGetEnumValue: function( ename:PChar ):TALenum; cdecl;

Extension support. Obtain the integer value of an enumeration (usually an extension) with the name ename.

alListenerf: procedure( pname:TALenum; param:TALfloat ); cdecl;

Listener Gain: default 1.0f.

alListeneri: procedure( pname:TALenum; param:TALint ); cdecl;
 
alListener3f: procedure( pname:TALenum; f1, f2, f3:TALfloat ); cdecl;
 
alListenerfv: procedure( pname:TALenum; param:PALfloat ); cdecl;
 
alGetListeneri: procedure( pname:TALenum; value:PALint ); cdecl;

Retrieve listener information.

alGetListenerf: procedure( pname:TALenum; value:PALfloat ); cdecl;
 
alGetListenerfv: procedure( pname:TALenum; values:PALfloat ); cdecl;
 
alGetListener3f: procedure( pname:TALenum; f1, f2, f3:PALfloat ); cdecl;
 
alGenSources: procedure( n:TALsizei; sources:PALuint ); cdecl;

Create Source objects.

alDeleteSources: procedure( n:TALsizei; sources:PALuint ); cdecl;

Delete Source objects.

alIsSource: function( sid:TALuint ):TALboolean; cdecl;

Verify a handle is a valid Source.

alSourcei: procedure( sid:TALuint; param:TALenum; value:TALint ); cdecl;

Set an integer parameter for a Source object.

alSourcef: procedure( sid:TALuint; param:TALenum; value:TALfloat ); cdecl;
 
alSource3f: procedure( sid:TALuint; param:TALenum; f1, f2, f3:TALfloat ); cdecl;
 
alSourcefv: procedure( sid:TALuint; param:TALenum; values:PALfloat ); cdecl;
 
alGetSourcei: procedure( sid:TALuint; pname:TALenum; value:PALint ); cdecl;

Get an integer parameter for a Source object.

alGetSourcef: procedure( sid:TALuint; pname:TALenum; value:PALfloat ); cdecl;
 
alGetSourcefv: procedure( sid:TALuint; pname:TALenum; values:PALfloat ); cdecl;
 
alGetSource3f: procedure( sid:TALuint; pname:TALenum; value1, value2, value3:PALfloat); cdecl;

Warning: this symbol is deprecated.

Deprecated, included for Win compatibility.

alSourcePlayv: procedure( ns:TALsizei; ids:PALuint ); cdecl;
 
alSourceStopv: procedure( ns:TALsizei; ids:PALuint ); cdecl;
 
alSourceRewindv: procedure( ns:TALsizei; ids:PALuint ); cdecl;
 
alSourcePausev: procedure( ns:TALsizei; ids:PALuint ); cdecl;
 
alSourcePlay: procedure( sid:TALuint ); cdecl;

Activate a source, start replay.

alSourcePause: procedure( sid:TALuint ); cdecl;

Pause a source, temporarily remove it from the mixer list.

alSourceRewind: procedure( sid:TALuint ); cdecl;

Rewind a source, set the source to play at the beginning.

alSourceStop: procedure( sid:TALuint ); cdecl;

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.

alGenBuffers: procedure( n:TALsizei; buffers:PALuint ); cdecl;

Buffer object generation.

alDeleteBuffers: procedure( n:TALsizei; buffers:PALuint ); cdecl;
 
alIsBuffer: function( buffer:TALuint ):TALboolean; cdecl;
 
alBufferData: procedure( buffer:TALuint; format:TALenum; data:PALvoid; size, freq:TALsizei ); cdecl;

Specify the data to be filled into a buffer.

alGetBufferi: procedure( buffer:TALuint; param:TALenum; value:PALint ); cdecl;
 
alGetBufferf: procedure( buffer:TALuint; param:TALenum; value:PALfloat ); cdecl;
 
alGenEnvironmentIASIG: function( n:TALsizei; environs:PALuint ):TALsizei; cdecl;

Allocate n environment ids and store them in the array environs. Returns the number of environments actually allocated.

alDeleteEnvironmentIASIG: procedure( n:TALsizei; environs:PALuint ); cdecl;
 
alIsEnvironmentIASIG: function( environ:TALuint ):TALboolean; cdecl;
 
alEnvironmentiIASIG: procedure( eid:TALuint; param:TALenum; value:TALint ); cdecl;
 
alSourceQueueBuffers: procedure( sid:TALuint; numEntries:TALsizei; bids:PALuint ); cdecl;
 
alSourceUnqueueBuffers: procedure( sid:TALuint; numEntries:TALsizei; bids:PALuint ); cdecl;
 
alDopplerFactor: procedure( value:TALfloat ); cdecl;
 
alDopplerVelocity: procedure( value:TALfloat ); cdecl;
 
alDistanceModel: procedure( distanceModel:TALenum ); cdecl;
 
alcCreateContext: function( dev:PALCdevice; attrlist:PALint ):PALCcontext; cdecl;
 
alcMakeContextCurrent: function( alcHandle:PALCcontext ):TALCenum; cdecl;
 
alcProcessContext: function( alcHandle:PALCcontext ):PALCcontext; cdecl;

Perform processing on a synced context, non-op on a asynchronous context.

alcSuspendContext: procedure( alcHandle:PALCcontext ); cdecl;

Suspend processing on an asynchronous context, non-op on a synced context.

alcDestroyContext: function( alcHandle:PALCcontext ):TALCenum; cdecl;
 
alcGetError: function( dev:PALCdevice ):TALCenum; cdecl;
 
alcGetCurrentContext: function():PALCcontext; cdecl;
 
alcOpenDevice: function( tokstr:PChar ):PALCdevice; cdecl;
 
alcCloseDevice: procedure( dev:PALCdevice ); cdecl;
 
alcIsExtensionPresent: function(device:PALCdevice; extName:PChar):TALboolean; cdecl;
 
alcGetProcAddress: function(device:PALCdevice; funcName:PChar):PALvoid; cdecl;
 
alcGetEnumValue: function(device:PALCdevice; enumName:PChar):TALenum; cdecl;
 
alcGetContextsDevice: function(context:PALCcontext):PALCdevice; cdecl;
 
alcGetString: function(deviceHandle:PALCdevice; token:TALenum):PChar; cdecl;
 
alcGetIntegerv: procedure(deviceHandle:PALCdevice; token:TALenum; size:TALsizei; dest:PALint); cdecl;
 
alutInit: procedure(var argc:LongInt; argv:PPChar); cdecl;

translation of AL/alut.h

alutExit: procedure(); cdecl;
 
alutLoadWAV: function( fname:PChar; var wave:PALvoid; var format, size, bits, freq:TALsizei ):TALboolean; cdecl;
 
alutLoadWAVFile: procedure(afile:PChar; var format:TALenum; var data:PALvoid; var size, freq:TALsizei; var loop:TALboolean); cdecl;
 
alutLoadWAVMemory: procedure(memory:PALbyte; var format:TALenum; var data:PALvoid; var size, freq:TALsizei; var loop:TALboolean); cdecl;
 
alutUnloadWAV: procedure(format:TALenum; data:PALvoid; size, freq:TALsizei); cdecl;
 
ALInited: boolean = false;

ALInited means that functions alXxx and alcXxx are loaded, i.e. their pointers in this module are initialized from appropriate library. Jezeli not ALInited to zawsze wszystkie pointery na funkcje alXxx i alcXxx beda rowne nil.

ALUTInited: boolean = false;

ALUTInited means that functions alutXxx are loaded (their pointers are loaded from appropriate library) AND that ALInited is true. I.e. it is not posiible to have (ALUTInited = true and ALInited = false). This may look like a simplification of a real situation because _if_ ever (under some OS) alutXxx functions will be loaded from different library than alXxx functions than it _is_ theoretically possible to have alutXxx functions available but alXxx functions. But the truth is that alutXxx functions are treated by me as COMPLETELY UNUSABLE if alXxx functions are not available. So if ALInited = false, we will never even check for alutXxx functions - if ALInited = false we will always set ALUTInited to false too.


Generated by PasDoc 0.10.0 on 2008-02-25 00:00:33