From b6261de6b40b4b79207cc01889b94e3237e1bba6 Mon Sep 17 00:00:00 2001 From: fgsfds Date: Sat, 31 Aug 2019 04:29:57 +0300 Subject: [PATCH] Sound: Initial OpenAL driver impl --- src/engine/e_sound.pas | 6 +- src/engine/e_sound_al.inc | 758 +++++++++++++++++++++++++++++++++ src/engine/e_soundfile.pas | 90 ++++ src/engine/e_soundfile_wav.pas | 127 ++++++ src/game/Doom2DF.lpr | 5 + src/lib/openal/al.inc | 722 +++++++++++++++++++++++++++++++ src/lib/openal/al.pas | 42 ++ src/lib/openal/alc.inc | 256 +++++++++++ src/lib/openal/alext.inc | 138 ++++++ src/lib/openal/efx.inc | 634 +++++++++++++++++++++++++++ 10 files changed, 2777 insertions(+), 1 deletion(-) create mode 100644 src/engine/e_sound_al.inc create mode 100644 src/engine/e_soundfile.pas create mode 100644 src/engine/e_soundfile_wav.pas create mode 100644 src/lib/openal/al.inc create mode 100644 src/lib/openal/al.pas create mode 100644 src/lib/openal/alc.inc create mode 100644 src/lib/openal/alext.inc create mode 100644 src/lib/openal/efx.inc diff --git a/src/engine/e_sound.pas b/src/engine/e_sound.pas index ebec200..d689dfe 100644 --- a/src/engine/e_sound.pas +++ b/src/engine/e_sound.pas @@ -19,5 +19,9 @@ unit e_sound; {$IFDEF USE_SDLMIXER} {$I e_sound_sdl.inc} {$ELSE} - {$I e_sound_fmod.inc} + {$IFDEF USE_OPENAL} + {$I e_sound_al.inc} + {$ELSE} + {$I e_sound_fmod.inc} + {$ENDIF} {$ENDIF} diff --git a/src/engine/e_sound_al.inc b/src/engine/e_sound_al.inc new file mode 100644 index 0000000..d570129 --- /dev/null +++ b/src/engine/e_sound_al.inc @@ -0,0 +1,758 @@ +(* Copyright (C) Doom 2D: Forever Developers + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + *) +interface + +uses + AL, + {$IFDEF USE_MEMPOOL}mempool,{$ENDIF} + e_soundfile, + e_log, + SysUtils; + +type + TSoundRec = record + Fmt: TSoundFormat; + Data: Pointer; + DataLen: Integer; + alBuffer: ALuint; + isMusic: Boolean; + Loops: Boolean; + nRefs: Integer; + end; + + TBasicSound = class{$IFDEF USE_MEMPOOL}(TPoolObject){$ENDIF} + private + FSource: Integer; + FOldGain: ALfloat; + FMuted: Boolean; + + function InvalidSource(): Boolean; inline; + + protected + FID: DWORD; + FMusic: Boolean; + FPosition: DWORD; + + function RawPlay(Pan: Single; Volume: Single; aPos: DWORD): Boolean; + + public + constructor Create(); + destructor Destroy(); override; + procedure SetID(ID: DWORD); + procedure FreeSound(); + function IsPlaying(): Boolean; + procedure Stop(); + function IsPaused(): Boolean; + procedure Pause(Enable: Boolean); + function GetVolume(): Single; + procedure SetVolume(Volume: Single); + function GetPan(): Single; + procedure SetPan(Pan: Single); + function IsMuted(): Boolean; + procedure Mute(Enable: Boolean); + function GetPosition(): DWORD; + procedure SetPosition(aPos: DWORD); + procedure SetPriority(priority: Integer); + end; + +const + NO_SOUND_ID = DWORD(-1); + +function e_InitSoundSystem(NoOutput: Boolean = False): Boolean; + +function e_LoadSound(FileName: string; var ID: DWORD; isMusic: Boolean; ForceNoLoop: Boolean = False): Boolean; +function e_LoadSoundMem(pData: Pointer; Length: Integer; var ID: DWORD; isMusic: Boolean; ForceNoLoop: Boolean = False): Boolean; + +function e_PlaySound(ID: DWORD): Integer; +function e_PlaySoundPan(ID: DWORD; Pan: Single): Integer; +function e_PlaySoundVolume(ID: DWORD; Volume: Single): Integer; +function e_PlaySoundPanVolume(ID: DWORD; Pan, Volume: Single): Integer; + +procedure e_ModifyChannelsVolumes(SoundMod: Single; setMode: Boolean); +procedure e_MuteChannels(Enable: Boolean); +procedure e_StopChannels(); + +procedure e_DeleteSound(ID: DWORD); +procedure e_RemoveAllSounds(); +procedure e_ReleaseSoundSystem(); +procedure e_SoundUpdate(); + +var + e_SoundsArray: array of TSoundRec = nil; + e_ZeroPosition: array [0..2] of ALfloat; + e_ALError: ALenum = 0; + +implementation + +uses + g_window, g_options, utils; + +const + NUM_SOURCES = 250; + MUSIC_SOURCE = 0; + +var + alDevice: PALCdevice = nil; + alContext: PALCcontext = nil; + // sources for one-shot sounds + // TBasicSounds have a built in source that lives and dies with them + alSources: array of ALuint; + alOwners: array of TBasicSound; + SoundMuted: Boolean = False; + +function CheckALError(): Boolean; +begin + e_ALError := alGetError(); + Result := e_ALError <> AL_NO_ERROR; +end; + +function GetALError(): string; +begin + Result := ''; + case e_ALError of + AL_NO_ERROR: Result := ''; + AL_INVALID_NAME: Result := 'AL_INVALID_NAME'; + AL_INVALID_ENUM: Result := 'AL_INVALID_ENUM'; + AL_INVALID_VALUE: Result := 'AL_INVALID_VALUE'; + AL_INVALID_OPERATION: Result := 'AL_INVALID_OPERATION'; + AL_OUT_OF_MEMORY: Result := 'AL_OUT_OF_MEMORY'; + else Result := Format('unknown error %x', [e_ALError]); + end; +end; + +function e_InitSoundSystem(NoOutput: Boolean = False): Boolean; +var + alExt, alRend, alVendor, alVer: string; + DevName: string = ''; + alAttrs: array [0..4] of ALCint = ( + ALC_STEREO_SOURCES, 1, + ALC_MONO_SOURCES, NUM_SOURCES, + 0 + ); +begin + Result := False; + + DevName := alcGetString(nil, ALC_DEVICE_SPECIFIER); + e_LogWritefln('AL: available devices: %s', [DevName]); + + // TODO: open a dummy device when NoOutput is true or something + DevName := alcGetString(nil, ALC_DEFAULT_DEVICE_SPECIFIER); + e_LogWritefln('AL: trying to open device %s', [DevName]); + + alDevice := alcOpenDevice(PChar(DevName)); + if alDevice = nil then + begin + e_LogWritefln('AL: ERROR: could not open device %s: %s', [DevName, GetALError()]); + exit; + end; + + alContext := alcCreateContext(alDevice, alAttrs); + if alContext = nil then + begin + e_LogWritefln('AL: ERROR: could not create context: %s', [GetALError()]); + alcCloseDevice(alDevice); + alDevice := nil; + exit; + end; + + alcMakeContextCurrent(alContext); + + alVendor := alGetString(AL_VENDOR); + alRend := alGetString(AL_RENDERER); + alVer := alGetString(AL_VERSION); + alExt := alGetString(AL_EXTENSIONS); + + e_LogWriteln('AL INFO:'); + e_LogWriteln(' Version: ' + alVer); + e_LogWriteln(' Vendor: ' + alVendor); + e_LogWriteln(' Renderer: ' + alRend); + e_LogWriteln(' Device: ' + DevName); + e_LogWriteln(' Extensions:'); + e_LogWriteln(' ' + alExt); + + SetLength(alSources, NUM_SOURCES + 1); // 0 is the music source + SetLength(alOwners, NUM_SOURCES + 1); // to avoid destructive operations on sources + ZeroMemory(@alSources[0], sizeof(alSources[0]) * Length(alSources)); + ZeroMemory(@alOwners[0], sizeof(alOwners[0]) * Length(alOwners)); + + alGetError(); // reset the goddamn error state + alGenSources(1, @alSources[0]); // generate the music source + if CheckALError() then + e_LogWriteln('AL: ERROR: alGenSources() for music failed: ' + GetALError()); + + Result := True; +end; + +function FindESound(): DWORD; +var + i: Integer; + +begin + if e_SoundsArray <> nil then + for i := 0 to High(e_SoundsArray) do + if e_SoundsArray[i].alBuffer = 0 then + begin + Result := i; + Exit; + end; + + if e_SoundsArray = nil then + begin + SetLength(e_SoundsArray, 16); + Result := 0; + end + else + begin + Result := High(e_SoundsArray) + 1; + SetLength(e_SoundsArray, Length(e_SoundsArray) + 16); + end; +end; + +function GetALSoundFormat(Fmt: TSoundFormat): ALenum; inline; +begin + if Fmt.Channels = 2 then + begin + if Fmt.SampleBits = 16 then + Result := AL_FORMAT_STEREO16 + else + Result := AL_FORMAT_STEREO8; + end + else + begin + if Fmt.SampleBits = 16 then + Result := AL_FORMAT_MONO16 + else + Result := AL_FORMAT_MONO8; + end; +end; + +function GetALSourceState(S: ALuint): ALint; inline; +begin + alGetSourcei(S, AL_SOURCE_STATE, Result); +end; + +function e_LoadSound(FileName: String; var ID: DWORD; isMusic: Boolean; ForceNoLoop: Boolean = False): Boolean; +var + find_id: DWORD; + Loader: TSoundLoader; +begin + ID := NO_SOUND_ID; + Result := False; + + find_id := FindESound(); + + e_SoundsArray[find_id].Data := nil; + e_SoundsArray[find_id].DataLen := 0; + e_SoundsArray[find_id].isMusic := isMusic; + e_SoundsArray[find_id].Loops := isMusic and not ForceNoLoop; + e_SoundsArray[find_id].nRefs := 0; + + Loader := e_GetSoundLoader(FileName); + if Loader = nil then + begin + e_LogWritefln('Could not find loader for sound `%s`', [FileName]); + exit; + end; + + e_SoundsArray[find_id].Data := Loader.Load(FileName, e_SoundsArray[find_id].DataLen, e_SoundsArray[find_id].Fmt); + if e_SoundsArray[find_id].Data = nil then + begin + e_LogWritefln('Could not load sound `%s`', [FileName]); + exit; + end; + + alGetError(); // reset error state, god damn it + + alGenBuffers(1, Addr(e_SoundsArray[find_id].alBuffer)); + if CheckALError() then + begin + e_LogWritefln('Could not create AL buffer for `%s`: %s', [FileName, GetALError()]); + Loader.Free(e_SoundsArray[find_id].Data); + exit; + end; + + alBufferData( + e_SoundsArray[find_id].alBuffer, + GetALSoundFormat(e_SoundsArray[find_id].Fmt), + e_SoundsArray[find_id].Data, + e_SoundsArray[find_id].DataLen, + e_SoundsArray[find_id].Fmt.SampleRate + ); + + // don't need this anymore + Loader.Free(e_SoundsArray[find_id].Data); + e_SoundsArray[find_id].Data := nil; + e_SoundsArray[find_id].DataLen := 0; + + if CheckALError() then + begin + e_LogWriteln('AL: what the fuck: ' + GetALError()); + alDeleteBuffers(1, Addr(e_SoundsArray[find_id].alBuffer)); + exit; + end; + + ID := find_id; + Result := True; +end; + +function e_LoadSoundMem(pData: Pointer; Length: Integer; var ID: DWORD; isMusic: Boolean; ForceNoLoop: Boolean = False): Boolean; +var + find_id: DWORD; + Loader: TSoundLoader; +begin + ID := NO_SOUND_ID; + Result := False; + + find_id := FindESound(); + + e_SoundsArray[find_id].Data := nil; + e_SoundsArray[find_id].DataLen := 0; + e_SoundsArray[find_id].isMusic := isMusic; + e_SoundsArray[find_id].Loops := isMusic and not ForceNoLoop; + e_SoundsArray[find_id].nRefs := 0; + + Loader := e_GetSoundLoader(pData, Length); + if Loader = nil then + begin + e_LogWritefln('Could not find loader for sound `%p`', [pData]); + exit; + end; + + e_SoundsArray[find_id].Data := Loader.Load(pData, Length, e_SoundsArray[find_id].DataLen, e_SoundsArray[find_id].Fmt); + if e_SoundsArray[find_id].Data = nil then + begin + e_LogWritefln('Could not load sound `%p`', [pData]); + exit; + end; + + alGetError(); // reset error state, god damn it + + alGenBuffers(1, Addr(e_SoundsArray[find_id].alBuffer)); + if CheckALError() then + begin + e_LogWritefln('Could not create AL buffer for `%p`: %s', [pData, GetALError()]); + Loader.Free(e_SoundsArray[find_id].Data); + exit; + end; + + alBufferData( + e_SoundsArray[find_id].alBuffer, + GetALSoundFormat(e_SoundsArray[find_id].Fmt), + e_SoundsArray[find_id].Data, + e_SoundsArray[find_id].DataLen, + e_SoundsArray[find_id].Fmt.SampleRate + ); + + // don't need this anymore + Loader.Free(e_SoundsArray[find_id].Data); + e_SoundsArray[find_id].Data := nil; + e_SoundsArray[find_id].DataLen := 0; + + if CheckALError() then + begin + e_LogWriteln('AL: what the fuck: ' + GetALError()); + alDeleteBuffers(1, Addr(e_SoundsArray[find_id].alBuffer)); + exit; + end; + + ID := find_id; + Result := True; +end; + +function FindSourceForSound(ID: DWORD): Integer; +var + S: Integer; +begin + Result := -1; + if ID > High(e_SoundsArray) then + exit; + + if e_SoundsArray[ID].isMusic then + begin + // last source is for music + Result := MUSIC_SOURCE; + exit; + end; + + for S := 1 to High(alSources) do + if alSources[S] = 0 then + begin + alOwners[S] := nil; // TBasicSounds will set this if needed + Result := S; + break; + end; + + if Result = -1 then Exit; // no voices left + + alGetError(); // reset error state + alGenSources(1, @alSources[Result]); + if CheckALError() then + begin + e_LogWriteln('AL: FindSourceForSound(): alGenSources() failed: ' + GetALError()); + Result := -1; + end; +end; + +procedure AssignSound(ID: DWORD; Src: ALuint); inline; +begin + alGetError(); // reset error state + alSourcei(Src, AL_BUFFER, e_SoundsArray[ID].alBuffer); + alSourcei(Src, AL_SOURCE_RELATIVE, AL_TRUE); + if (e_SoundsArray[ID].Loops) then + alSourcei(Src, AL_LOOPING, AL_TRUE) + else + alSourcei(Src, AL_LOOPING, AL_FALSE); +end; + +function e_PlaySound(ID: DWORD): Integer; +begin + Result := FindSourceForSound(ID); + if Result >= 0 then + begin + AssignSound(ID, alSources[Result]); + alSourcef(alSources[Result], AL_GAIN, 1); + alSourcefv(alSources[Result], AL_POSITION, e_ZeroPosition); + alSourcePlay(alSources[Result]); + end; +end; + +function e_PlaySoundPan(ID: DWORD; Pan: Single): Integer; +var + Pos: array [0..2] of ALfloat; +begin + Result := FindSourceForSound(ID); + if Result >= 0 then + begin + Pos[0] := Pan; + AssignSound(ID, alSources[Result]); + alSourcef(alSources[Result], AL_GAIN, 1); + alSourcefv(alSources[Result], AL_POSITION, Pos); + alSourcePlay(alSources[Result]); + end; +end; + +function e_PlaySoundVolume(ID: DWORD; Volume: Single): Integer; +begin + Result := FindSourceForSound(ID); + if Result >= 0 then + begin + AssignSound(ID, alSources[Result]); + alSourcef(alSources[Result], AL_GAIN, Volume); + alSourcefv(alSources[Result], AL_POSITION, e_ZeroPosition); + alSourcePlay(alSources[Result]); + end; +end; + +function e_PlaySoundPanVolume(ID: DWORD; Pan, Volume: Single): Integer; +var + Pos: array [0..2] of ALfloat; +begin + Result := FindSourceForSound(ID); + if Result >= 0 then + begin + Pos[0] := Pan; + AssignSound(ID, alSources[Result]); + alSourcefv(alSources[Result], AL_POSITION, Pos); + alSourcef(alSources[Result], AL_GAIN, Volume); + alSourcePlay(alSources[Result]); + end; +end; + +procedure e_DeleteSound(ID: DWORD); +begin + if ID > High(e_SoundsArray) then + exit; + if (e_SoundsArray[ID].alBuffer <> 0) then + begin + alDeleteBuffers(1, Addr(e_SoundsArray[ID].alBuffer)); + e_SoundsArray[ID].alBuffer := 0; + end; + if (e_SoundsArray[ID].Data <> nil) then + begin + e_SoundsArray[ID].Fmt.Loader.Free(e_SoundsArray[ID].Data); + e_SoundsArray[ID].Data := nil; + e_SoundsArray[ID].DataLen := 0; + end; +end; + +procedure e_ModifyChannelsVolumes(SoundMod: Single; setMode: Boolean); +var + S: Integer; + V: ALfloat; +begin + // TODO: replace manual volume calculations everywhere with + // alListenerf(AL_GAIN) or something + if setMode then + begin + for S := 1 to High(alSources) do + if alSources[S] <> 0 then + alSourcef(alSources[S], AL_GAIN, SoundMod) + end + else + begin + for S := 1 to High(alSources) do + if alSources[S] <> 0 then + begin + alGetSourcef(alSources[S], AL_GAIN, V); + alSourcef(alSources[S], AL_GAIN, V * SoundMod); + end; + end; +end; + +procedure e_MuteChannels(Enable: Boolean); +begin + if Enable = SoundMuted then + Exit; + + SoundMuted := Enable; +end; + +procedure e_StopChannels(); +var + S: Integer; +begin + alGetError(); // reset error state + for S := Low(alSources) to High(alSources) do + if (alSources[S] <> 0) and (GetALSourceState(alSources[S]) = AL_PLAYING) then + begin + alSourceStop(alSources[S]); + alDeleteSources(1, @alSources[S]); + alSources[S] := 0; + end; +end; + +procedure e_RemoveAllSounds(); +var + i: Integer; +begin + for i := 0 to High(e_SoundsArray) do + if e_SoundsArray[i].alBuffer <> 0 then + e_DeleteSound(i); + SetLength(e_SoundsArray, 0); + e_SoundsArray := nil; +end; + +procedure e_ReleaseSoundSystem(); +begin + e_RemoveAllSounds(); + + alcMakeContextCurrent(nil); + alcDestroyContext(alContext); + alcCloseDevice(alDevice); + + alDevice := nil; + alContext := nil; +end; + +procedure e_SoundUpdate(); +var + S: Integer; +begin + alGetError(); // reset error state + // clear out all stopped sources + for S := 1 to High(alSources) do + if (alSources[S] <> 0) and (GetALSourceState(alSources[S]) = AL_STOPPED) then + begin + alDeleteSources(1, @alSources[S]); + alSources[S] := 0; + alOwners[S] := nil; + end; +end; + +{ TBasicSound: } + +constructor TBasicSound.Create(); +begin + FID := NO_SOUND_ID; + FMusic := False; + FSource := -1; + FPosition := 0; + FMuted := False; + FOldGain := 1; +end; + +destructor TBasicSound.Destroy(); +begin + FreeSound(); + inherited; +end; + +function TBasicSound.InvalidSource(): Boolean; inline; +begin + Result := (FSource < 0) or (alSources[FSource] = 0) or (alOwners[FSource] <> self); +end; + +procedure TBasicSound.FreeSound(); +begin + if FID = NO_SOUND_ID then + Exit; + + Stop(); + FID := NO_SOUND_ID; + FMusic := False; + FPosition := 0; +end; + +function TBasicSound.RawPlay(Pan: Single; Volume: Single; aPos: DWORD): Boolean; +begin + Result := False; + if FID = NO_SOUND_ID then Exit; + + if e_SoundsArray[FID].nRefs >= gMaxSimSounds then + begin + Result := True; + Exit; + end; + + FSource := e_PlaySoundPanVolume(FID, Pan, Volume); + if FSource >= 0 then + begin + alOwners[FSource] := self; + Result := True; + end; +end; + +procedure TBasicSound.SetID(ID: DWORD); +begin + FreeSound(); + + if ID > High(e_SoundsArray) then + exit; + + FID := ID; + FMusic := e_SoundsArray[ID].isMusic; +end; + +function TBasicSound.IsPlaying(): Boolean; +begin + Result := False; + if InvalidSource() then + Exit; + Result := GetALSourceState(alSources[FSource]) = AL_PLAYING; +end; + +procedure TBasicSound.Stop(); +begin + if InvalidSource() then + Exit; + GetPosition(); + alSourceStop(alSources[FSource]); +end; + +function TBasicSound.IsPaused(): Boolean; +begin + Result := False; + if InvalidSource() then + Exit; + Result := GetALSourceState(alSources[FSource]) = AL_PAUSED; +end; + +procedure TBasicSound.Pause(Enable: Boolean); +begin + if InvalidSource() then + Exit; + if Enable then + alSourcePause(alSources[FSource]) + else + alSourcePlay(alSources[FSource]); +end; + +function TBasicSound.GetVolume(): Single; +begin + Result := 0.0; + if InvalidSource() then + Exit; + alGetSourcef(alSources[FSource], AL_GAIN, Result); +end; + +procedure TBasicSound.SetVolume(Volume: Single); +begin + if InvalidSource() then + Exit; + alSourcef(alSources[FSource], AL_GAIN, Volume); +end; + +function TBasicSound.GetPan(): Single; +var + Pos: array [0..2] of ALfloat; +begin + Result := 0.0; + if InvalidSource() then + Exit; + alGetSourcefv(alSources[FSource], AL_POSITION, Pos); + Result := Pos[0]; +end; + +procedure TBasicSound.SetPan(Pan: Single); +var + Pos: array [0..2] of ALfloat; +begin + if InvalidSource() then + Exit; + Pos[0] := Pan; + alSourcefv(alSources[FSource], AL_POSITION, Pos); +end; + +function TBasicSound.IsMuted(): Boolean; +begin + if InvalidSource() then + Result := False + else + Result := FMuted; +end; + +procedure TBasicSound.Mute(Enable: Boolean); +begin + if InvalidSource() then + Exit; + if Enable then + begin + FOldGain := GetVolume(); + FMuted := True; + SetVolume(0); + end + else if FMuted then + begin + FMuted := False; + SetVolume(FOldGain); + end; +end; + +function TBasicSound.GetPosition(): DWORD; +var + Bytes: ALint; +begin + Result := 0; + if InvalidSource() then + Exit; + alGetSourcei(alSources[FSource], AL_BYTE_OFFSET, Bytes); + FPosition := Bytes; + Result := FPosition; +end; + +procedure TBasicSound.SetPosition(aPos: DWORD); +begin + FPosition := aPos; + if InvalidSource() then + Exit; + alSourcei(alSources[FSource], AL_BYTE_OFFSET, aPos); +end; + +procedure TBasicSound.SetPriority(priority: Integer); +begin +end; + +end. diff --git a/src/engine/e_soundfile.pas b/src/engine/e_soundfile.pas new file mode 100644 index 0000000..df4aa45 --- /dev/null +++ b/src/engine/e_soundfile.pas @@ -0,0 +1,90 @@ +(* Copyright (C) Doom 2D: Forever Developers + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + *) +{$INCLUDE ../shared/a_modes.inc} +unit e_soundfile; + +interface + +type + TSoundLoader = class; + + TSoundFormat = record + Loader: TSoundLoader; + SampleBits: Integer; + SampleRate: Integer; + Channels: Integer; + end; + + // each sound file format has its own loader + // TODO: maybe make TBasicSound contain an instance of its loader + // and add a FetchSamples method or something, for streaming shit + TSoundLoader = class + public + // can this loader load the sound file in Data? + function CanLoad(Data: Pointer; Len: Integer): Boolean; virtual; abstract; overload; + // can this loader load the sound file at FName? + function CanLoad(FName: string): Boolean; virtual; abstract; overload; + // load from memory + function Load(Data: Pointer; Len: Integer; var OutLen: Integer; var OutFmt: TSoundFormat): Pointer; virtual; abstract; overload; + // load from file + function Load(FName: string; var OutLen: Integer; var OutFmt: TSoundFormat): Pointer; virtual; abstract; overload; + // needed in case memory is allocated in a lib or something + procedure Free(Data: Pointer); virtual; abstract; + end; + +function e_GetSoundLoader(Data: Pointer; Len: Integer): TSoundLoader; overload; +function e_GetSoundLoader(FName: string): TSoundLoader; overload; + +procedure e_AddSoundLoader(Loader: TSoundLoader); + +implementation + +var + e_SoundLoaders: array of TSoundLoader; + +function e_GetSoundLoader(FName: string): TSoundLoader; overload; +var + I: Integer; +begin + Result := nil; + for I := Low(e_SoundLoaders) to High(e_SoundLoaders) do + if e_SoundLoaders[I].CanLoad(FName) then + begin + Result := e_SoundLoaders[I]; + break; + end; +end; + +function e_GetSoundLoader(Data: Pointer; Len: Integer): TSoundLoader; overload; +var + I: Integer; +begin + Result := nil; + for I := Low(e_SoundLoaders) to High(e_SoundLoaders) do + if e_SoundLoaders[I].CanLoad(Data, Len) then + begin + Result := e_SoundLoaders[I]; + break; + end; +end; + +procedure e_AddSoundLoader(Loader: TSoundLoader); +begin + SetLength(e_SoundLoaders, Length(e_SoundLoaders) + 1); + e_SoundLoaders[High(e_SoundLoaders)] := Loader; +end; + +end. diff --git a/src/engine/e_soundfile_wav.pas b/src/engine/e_soundfile_wav.pas new file mode 100644 index 0000000..b88dd5a --- /dev/null +++ b/src/engine/e_soundfile_wav.pas @@ -0,0 +1,127 @@ +(* Copyright (C) Doom 2D: Forever Developers + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + *) +{$INCLUDE ../shared/a_modes.inc} +unit e_soundfile_wav; + +interface + +uses e_soundfile; + +type + // a WAV loader that just uses SDL_LoadWAV + TWAVLoader = class (TSoundLoader) + public + function CanLoad(Data: Pointer; Len: Integer): Boolean; override; overload; + function CanLoad(FName: string): Boolean; override; overload; + function Load(Data: Pointer; Len: Integer; var OutLen: Integer; var OutFmt: TSoundFormat): Pointer; override; overload; + function Load(FName: string; var OutLen: Integer; var OutFmt: TSoundFormat): Pointer; override; overload; + procedure Free(Data: Pointer); override; + end; + +implementation + +uses sdl2, utils, e_log; + +function TWAVLoader.CanLoad(Data: Pointer; Len: Integer): Boolean; +var + P: PByte; +begin + if Len < 5 then + begin + Result := False; + exit; + end; + P := PByte(Data); + Result := ((P+0)^ = Ord('R')) and ((P+1)^ = Ord('I')) and ((P+2)^ = Ord('F')) and ((P+3)^ = Ord('F')); +end; + +function TWAVLoader.CanLoad(FName: string): Boolean; +begin + // TODO: actually check for RIFF header + Result := GetFilenameExt(FName) = '.wav'; +end; + +function TWAVLoader.Load(Data: Pointer; Len: Integer; var OutLen: Integer; var OutFmt: TSoundFormat): Pointer; +var + Spec: TSDL_AudioSpec; + RW: PSDL_RWops; + TmpLen: UInt32; + TmpBuf: PUInt8; +begin + Result := nil; + + RW := SDL_RWFromConstMem(Data, Len); + + if SDL_LoadWAV_RW(RW, 0, @Spec, @TmpBuf, @TmpLen) = nil then + begin + e_LogWriteln('Could not load WAV: ' + SDL_GetError()); + end + else + begin + OutFmt.Loader := self; + OutFmt.SampleRate := Spec.freq; + OutFmt.SampleBits := SDL_AUDIO_BITSIZE(Spec.format); + OutFmt.Channels := Spec.channels; + OutLen := TmpLen; + Result := TmpBuf; + end; + + SDL_RWclose(RW); +end; + +function TWAVLoader.Load(FName: string; var OutLen: Integer; var OutFmt: TSoundFormat): Pointer; +var + Spec: TSDL_AudioSpec; + RW: PSDL_RWops; + TmpLen: UInt32; + TmpBuf: PUInt8; +begin + Result := nil; + + RW := SDL_RWFromFile(PChar(FName), 'rb'); + + if RW = nil then + begin + e_LogWritefln('Could not open WAV file `%s`: %s', [FName, SDL_GetError()]); + exit; + end; + + if SDL_LoadWAV_RW(RW, 0, @Spec, @TmpBuf, @TmpLen) = nil then + begin + e_LogWritefln('Could not load WAV file `%s`: %s', [FName, SDL_GetError()]); + Result := nil; + end + else + begin + OutFmt.Loader := self; + OutFmt.SampleRate := Spec.freq; + OutFmt.SampleBits := SDL_AUDIO_BITSIZE(Spec.format); + OutFmt.Channels := Spec.channels; + OutLen := TmpLen; + Result := TmpBuf; + end; + + SDL_RWclose(RW); +end; + +procedure TWAVLoader.Free(Data: Pointer); +begin + SDL_FreeWAV(Data); // SDL allocates inside the DLL, so we need this +end; + +initialization + e_AddSoundLoader(TWAVLoader.Create()); +end. diff --git a/src/game/Doom2DF.lpr b/src/game/Doom2DF.lpr index f8d946e..546cabf 100644 --- a/src/game/Doom2DF.lpr +++ b/src/game/Doom2DF.lpr @@ -51,6 +51,11 @@ uses SDL2 in '../lib/sdl2/sdl2.pas', {$IFDEF USE_SDLMIXER} SDL2_mixer in '../lib/sdl2/SDL2_mixer.pas', +{$ENDIF} +{$IFDEF USE_OPENAL} + AL in '../lib/openal/al.pas', + e_soundfile in '../engine/e_soundfile.pas', + e_soundfile_wav in '../engine/e_soundfile_wav.pas', {$ENDIF} ENet in '../lib/enet/enet.pp', e_graphics in '../engine/e_graphics.pas', diff --git a/src/lib/openal/al.inc b/src/lib/openal/al.inc new file mode 100644 index 0000000..d7db89a --- /dev/null +++ b/src/lib/openal/al.inc @@ -0,0 +1,722 @@ +(** + * 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., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * Or go to http://www.gnu.org/copyleft/lgpl.html + *) + + +(* + * 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 + *) + +{ OPENAL + ALAPI AL_API + ALAPIENTRY AL_APIENTRY + AL_INVALID = (-1); + AL_ILLEGAL_ENUM = AL_INVALID_ENUM; + AL_ILLEGAL_COMMAND = AL_INVALID_OPERATION; + + AL_VERSION_1_0 + AL_VERSION_1_1} + + +type + +(** 8-bit boolean *) + ALboolean = cbool; + PALboolean = pcbool; + +(** character *) + ALchar = char; + PALchar = pchar; + +(** signed 8-bit 2's complement integer *) + ALbyte = cint8; + PALbyte = pcint8; + +(** unsigned 8-bit integer *) + ALubyte = cuint8; + PALubyte = pcuint8; + +(** signed 16-bit 2's complement integer *) + ALshort = cint16; + PALshort = pcint16; + +(** unsigned 16-bit integer *) + ALushort = cuint16; + PALushort = pcuint16; + +(** signed 32-bit 2's complement integer *) + ALint = cint32; + PALint = pcint32; + +(** unsigned 32-bit integer *) + ALuint = cuint32; + PALuint = pcuint32; + +(** non-negative 32-bit binary integer size *) + ALsizei = cint32; + PALsizei = pcint32; + +(** enumerated 32-bit value *) + ALenum = cint32; + PALenum = pcint32; + +(** 32-bit IEEE754 floating-point *) + ALfloat = cfloat; + PALfloat = pcfloat; + +(** 64-bit IEEE754 floating-point *) + ALdouble = cdouble; + PALdouble = pcdouble; + +(** void type (for opaque pointers only) *) + PALvoid = pointer; + + +(* Enumerant values begin at column 50. No tabs. *) + +const +(* "no distance model" or "no buffer" *) + AL_NONE = 0; + +(* Boolean False. *) + AL_FALSE = 0; + +(** Boolean True. *) + AL_TRUE = 1; + +(** Indicate Source has relative coordinates. *) + AL_SOURCE_RELATIVE = $202; + + + +(** + * Directional source, inner cone angle, in degrees. + * Range: [0-360] + * Default: 360 + *) + AL_CONE_INNER_ANGLE = $1001; + +(** + * Directional source, outer cone angle, in degrees. + * Range: [0-360] + * Default: 360 + *) + AL_CONE_OUTER_ANGLE = $1002; + +(** + * Specify the pitch to be applied, either at source, + * or on mixer results, at listener. + * Range: [0.5-2.0] + * Default: 1.0 + *) + AL_PITCH = $1003; + +(** + * 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_POSITION = $1004; + +(** Specify the current direction. *) + AL_DIRECTION = $1005; + +(** Specify the current velocity in three dimensional space. *) + AL_VELOCITY = $1006; + +(** + * Indicate whether source is looping. + * Type: ALboolean? + * Range: [AL_TRUE, AL_FALSE] + * Default: FALSE. + *) + AL_LOOPING = $1007; + +(** + * Indicate the buffer to provide sound samples. + * Type: ALuint. + * Range: any valid Buffer id. + *) + AL_BUFFER = $1009; + +(** + * 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_GAIN = $100A; + +(* + * Indicate minimum source attenuation + * Type: ALfloat + * Range: [0.0 - 1.0] + * + * Logarthmic + *) + AL_MIN_GAIN = $100D; + +(** + * Indicate maximum source attenuation + * Type: ALfloat + * Range: [0.0 - 1.0] + * + * Logarthmic + *) + AL_MAX_GAIN = $100E; + +(** + * Indicate listener orientation. + * + * at/up + *) + AL_ORIENTATION = $100F; + +(** + * Source state information. + *) + AL_SOURCE_STATE = $1010; + AL_INITIAL = $1011; + AL_PLAYING = $1012; + AL_PAUSED = $1013; + AL_STOPPED = $1014; + +(** + * Buffer Queue params + *) + AL_BUFFERS_QUEUED = $1015; + AL_BUFFERS_PROCESSED = $1016; + +(** + * Source buffer position information + *) + AL_SEC_OFFSET = $1024; + AL_SAMPLE_OFFSET = $1025; + AL_BYTE_OFFSET = $1026; + +(* + * 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 + *) + AL_SOURCE_TYPE = $1027; + AL_STATIC = $1028; + AL_STREAMING = $1029; + AL_UNDETERMINED = $1030; + +(** Sound samples: format specifier. *) + AL_FORMAT_MONO8 = $1100; + AL_FORMAT_MONO16 = $1101; + AL_FORMAT_STEREO8 = $1102; + AL_FORMAT_STEREO16 = $1103; + +(** + * source specific reference distance + * Type: ALfloat + * Range: 0.0 - +inf + * + * At 0.0, no distance attenuation occurs. Default is + * 1.0. + *) + AL_REFERENCE_DISTANCE = $1020; + +(** + * source specific rolloff factor + * Type: ALfloat + * Range: 0.0 - +inf + * + *) + AL_ROLLOFF_FACTOR = $1021; + +(** + * Directional source, outer cone gain. + * + * Default: 0.0 + * Range: [0.0 - 1.0] + * Logarithmic + *) + AL_CONE_OUTER_GAIN = $1022; + +(** + * Indicate distance above which sources are not + * attenuated using the inverse clamped distance model. + * + * Default: +inf + * Type: ALfloat + * Range: 0.0 - +inf + *) + AL_MAX_DISTANCE = $1023; + +(** + * 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_FREQUENCY = $2001; + AL_BITS = $2002; + AL_CHANNELS = $2003; + AL_SIZE = $2004; + +(** + * Buffer state. + * + * Not supported for public use (yet). + *) + AL_UNUSED = $2010; + AL_PENDING = $2011; + AL_PROCESSED = $2012; + + +(** Errors: No Error. *) + AL_NO_ERROR = AL_FALSE; + +(** + * Invalid Name paramater passed to AL call. + *) + AL_INVALID_NAME = $A001; + +(** + * Invalid parameter passed to AL call. + *) + AL_INVALID_ENUM = $A002; + +(** + * Invalid enum parameter value. + *) + AL_INVALID_VALUE = $A003; + +(** + * Illegal call. + *) + AL_INVALID_OPERATION = $A004; + + +(** + * No mojo. + *) + AL_OUT_OF_MEMORY = $A005; + + +(** Context strings: Vendor Name. *) + AL_VENDOR = $B001; + AL_VERSION = $B002; + AL_RENDERER = $B003; + AL_EXTENSIONS = $B004; + +(** Global tweakage. *) + +(** + * Doppler scale. Default 1.0 + *) + AL_DOPPLER_FACTOR = $C000; + +(** + * Tweaks speed of propagation. + *) + AL_DOPPLER_VELOCITY = $C001; + +(** + * Speed of Sound in units per second + *) + AL_SPEED_OF_SOUND = $C003; + +(** + * Distance models + * + * used in conjunction with DistanceModel + * + * implicit: NONE, which disances distance attenuation. + *) + AL_DISTANCE_MODEL = $D000; + AL_INVERSE_DISTANCE = $D001; + AL_INVERSE_DISTANCE_CLAMPED = $D002; + AL_LINEAR_DISTANCE = $D003; + AL_LINEAR_DISTANCE_CLAMPED = $D004; + AL_EXPONENT_DISTANCE = $D005; + AL_EXPONENT_DISTANCE_CLAMPED = $D006; + +(* + * Renderer State management + *) +procedure alEnable(capability: ALenum); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alDisable(capability: ALenum); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +function alIsEnabled(capability: ALenum): ALboolean; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + + +(* + * State retrieval + *) +function alGetString(param: ALenum): PALchar; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetBooleanv(param: ALenum; data: PALboolean); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetIntegerv(param: ALenum; data: PALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetFloatv(param: ALenum; data: PALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetDoublev(param: ALenum; data: PALdouble); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +function alGetBoolean(param: ALenum): ALboolean; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +function alGetInteger(param: ALenum): ALint; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +function alGetFloat(param: ALenum): ALfloat; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +function alGetDouble(param: ALenum): ALdouble; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + + +(* + * Error support. + * Obtain the most recent error generated in the AL state machine. + *) +function alGetError: ALenum; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + + +(* + * Extension support. + * Query for the presence of an extension, and obtain any appropriate + * function pointers and enum values. + *) +function alIsExtensionPresent(const extname: PALChar): ALboolean; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +function alGetProcAddress(const fname: PALChar): pointer; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +function alGetEnumValue(const ename: PALChar): ALenum; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + + +(* + * LISTENER + * Listener represents the location and orientation of the + * 'user' in 3D-space. + * + * 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 + *) +procedure alListenerf(param: ALenum; value: ALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alListener3f(param: ALenum; value1, value2, value3: ALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alListenerfv(param: ALenum; const values: PALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alListeneri(param: ALenum; value: ALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alListener3i(param: ALenum; value1, value2, value3: ALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alListeneriv(param: ALenum; const values: PALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* + * Get Listener parameters + *) +procedure alGetListenerf(param: ALenum; var value: ALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetListener3f(param: ALenum; var value1, value2, value3: ALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetListenerfv(param: ALenum; values: PALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetListeneri(param: ALenum; var value: ALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetListener3i(param: ALenum; var value1, value2, value3: ALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetListeneriv(param: ALenum; values: PALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + + +(** + * 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 + *) + +(* Create Source objects *) +procedure alGenSources(n: ALsizei; sources: PALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* Delete Source objects *) +procedure alDeleteSources(n: ALsizei; const sources: PALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* Verify a handle is a valid Source *) +function alIsSource(sid: ALuint): ALboolean; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* + * Set Source parameters + *) +procedure alSourcef(sid: ALuint; param: ALenum; value: ALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alSource3f(sid: ALuint; param: ALenum; value1, value2, value3: ALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alSourcefv(sid: ALuint; param: ALenum; const values: PALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alSourcei(sid: ALuint; param: ALenum; value: ALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alSource3i(sid: ALuint; param: ALenum; value1, value2, value3: ALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alSourceiv(sid: ALuint; param: ALenum; const values: PALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* + * Get Source parameters + *) +procedure alGetSourcef(sid: ALuint; param: ALenum; var value: ALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetSource3f(sid: ALuint; param: ALenum; var value1, value2, value3: ALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetSourcefv(sid: ALuint; param: ALenum; values: PALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetSourcei(sid: ALuint; param: ALenum; var value: ALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetSource3i(sid: ALuint; param: ALenum; var value1, value2, value3: ALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetSourceiv(sid: ALuint; param: ALenum; values: PALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + + +(* + * Source vector based playback calls + *) + +(* Play, replay, or resume (if paused) a list of Sources *) +procedure alSourcePlayv(ns: ALsizei; const sids: PALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* Stop a list of Sources *) +procedure alSourceStopv(ns: ALsizei; const sids: PALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* Rewind a list of Sources *) +procedure alSourceRewindv(ns: ALsizei; const sids: PALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* Pause a list of Sources *) +procedure alSourcePausev(ns: ALsizei; const sids: PALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* + * Source based playback calls + *) + +(* Play, replay, or resume a Source *) +procedure alSourcePlay(sid: ALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* Stop a Source *) +procedure alSourceStop(sid: ALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* Rewind a Source (set playback postiton to beginning) *) +procedure alSourceRewind(sid: ALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* Pause a Source *) +procedure alSourcePause(sid: ALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* + * Source Queuing + *) +procedure alSourceQueueBuffers(sid: ALuint; numEntries: ALsizei; const bids: PALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alSourceUnqueueBuffers(sid: ALuint; numEntries: ALsizei; bids: PALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + + +(** + * BUFFER + * Buffer objects are storage space for sample data. + * Buffers are referred to by Sources. One Buffer can be used + * by multiple Sources. + * + * 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 *) +procedure alGenBuffers(n: ALsizei; buffers: PALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* Delete Buffer objects *) +procedure alDeleteBuffers(n: ALsizei; const buffers: PALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* Verify a handle is a valid Buffer *) +function alIsBuffer(bid: ALuint): ALboolean; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* Specify the data to be copied into a buffer *) +procedure alBufferData(bid: ALuint; format: ALenum; data: PALvoid; size: ALsizei; freq: ALsizei); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* + * Set Buffer parameters + *) +procedure alBufferf(bid: ALuint; param: ALenum; value: ALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alBuffer3f(bid: ALuint; param: ALenum; value1, value2, value3: ALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alBufferfv(bid: ALuint; param: ALenum; const values: PALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alBufferi(bid: ALuint; param: ALenum; value: ALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alBuffer3i(bid: ALuint; param: ALenum; value1, value2, value3: ALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alBufferiv(bid: ALuint; param: ALenum; const values: ALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* + * Get Buffer parameters + *) +procedure alGetBufferf(bid: ALuint; param: ALenum; var value: ALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetBuffer3f(bid: ALuint; param: ALenum; var value1, value2, value3: ALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetBufferfv(bid: ALuint; param: ALenum; values: PALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetBufferi(bid: ALuint; param: ALenum; var value: ALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetBuffer3i(bid: ALuint; param: ALenum; var value1, value2, value3: ALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetBufferiv(bid: ALuint; param: ALenum; values: ALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + + +(* + * Global Parameters + *) +procedure alDopplerFactor(value: ALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alDopplerVelocity(value: ALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alSpeedOfSound(value: ALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alDistanceModel(distanceModel: ALenum); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* + * Pointer-to-function types, useful for dynamically getting AL entry points. + *) +{ +type + LPALENABLE = procedure( ALenum capability ); cdecl; + LPALDISABLE = procedure( ALenum capability ); cdecl; + LPALISENABLED = function( ALenum capability ): ALboolean; cdecl; + LPALGETSTRING = function( ALenum param ): PALchar; cdecl; + LPALGETBOOLEANV = procedure( ALenum param, ALboolean* data ); cdecl; + LPALGETINTEGERV = procedure( ALenum param, ALint* data ); cdecl; + LPALGETFLOATV = procedure( ALenum param, ALfloat* data ); cdecl; + LPALGETDOUBLEV = procedure( ALenum param, ALdouble* data ); cdecl; + LPALGETBOOLEAN = function( ALenum param ): ALboolean; cdecl; + LPALGETINTEGER = function( ALenum param ): ALint; cdecl; + LPALGETFLOAT = function( ALenum param ): ALfloat; cdecl; + LPALGETDOUBLE = function( ALenum param ): ALdouble; cdecl; + LPALGETERROR = function( void ): ALenum; cdecl; + LPALISEXTENSIONPRESENT = function(const ALchar* extname ): ALboolean; cdecl; + LPALGETPROCADDRESS = function( const ALchar* fname ): pointer; cdecl; + LPALGETENUMVALUE = function( const ALchar* ename ): ALenum; cdecl; + LPALLISTENERF = procedure( ALenum param, ALfloat value ); cdecl; + LPALLISTENER3F = procedure( ALenum param, ALfloat value1, ALfloat value2, ALfloat value3 ); cdecl; + LPALLISTENERFV = procedure( ALenum param, const ALfloat* values ); cdecl; + LPALLISTENERI = procedure( ALenum param, ALint value ); cdecl; + LPALLISTENER3I = procedure( ALenum param, ALint value1, ALint value2, ALint value3 ); cdecl; + LPALLISTENERIV = procedure( ALenum param, const ALint* values ); cdecl; + LPALGETLISTENERF = procedure( ALenum param, ALfloat* value ); cdecl; + LPALGETLISTENER3F = procedure( ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3 ); cdecl; + LPALGETLISTENERFV = procedure( ALenum param, ALfloat* values ); cdecl; + LPALGETLISTENERI = procedure( ALenum param, ALint* value ); cdecl; + LPALGETLISTENER3I = procedure( ALenum param, ALint *value1, ALint *value2, ALint *value3 ); cdecl; + LPALGETLISTENERIV = procedure( ALenum param, ALint* values ); cdecl; + LPALGENSOURCES = procedure( ALsizei n, ALuint* sources ); cdecl; + LPALDELETESOURCES = procedure( ALsizei n, const ALuint* sources ); cdecl; + LPALISSOURCE = function( ALuint sid ): ALboolean; cdecl; + LPALSOURCEF = procedure( ALuint sid, ALenum param, ALfloat value); cdecl; + LPALSOURCE3F = procedure( ALuint sid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3 ); cdecl; + LPALSOURCEFV = procedure( ALuint sid, ALenum param, const ALfloat* values ); cdecl; + LPALSOURCEI = procedure( ALuint sid, ALenum param, ALint value); cdecl; + LPALSOURCE3I = procedure( ALuint sid, ALenum param, ALint value1, ALint value2, ALint value3 ); cdecl; + LPALSOURCEIV = procedure( ALuint sid, ALenum param, const ALint* values ); cdecl; + LPALGETSOURCEF = procedure( ALuint sid, ALenum param, ALfloat* value ); cdecl; + LPALGETSOURCE3F = procedure( ALuint sid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3); cdecl; + LPALGETSOURCEFV = procedure( ALuint sid, ALenum param, ALfloat* values ); cdecl; + LPALGETSOURCEI = procedure( ALuint sid, ALenum param, ALint* value ); cdecl; + LPALGETSOURCE3I = procedure( ALuint sid, ALenum param, ALint* value1, ALint* value2, ALint* value3); cdecl; + LPALGETSOURCEIV = procedure( ALuint sid, ALenum param, ALint* values ); cdecl; + LPALSOURCEPLAYV = procedure( ALsizei ns, const ALuint *sids ); cdecl; + LPALSOURCESTOPV = procedure( ALsizei ns, const ALuint *sids ); cdecl; + LPALSOURCEREWINDV = procedure( ALsizei ns, const ALuint *sids ); cdecl; + LPALSOURCEPAUSEV = procedure( ALsizei ns, const ALuint *sids ); cdecl; + LPALSOURCEPLAY = procedure( ALuint sid ); cdecl; + LPALSOURCESTOP = procedure( ALuint sid ); cdecl; + LPALSOURCEREWIND = procedure( ALuint sid ); cdecl; + LPALSOURCEPAUSE = procedure( ALuint sid ); cdecl; + LPALSOURCEQUEUEBUFFERS = procedure(ALuint sid, ALsizei numEntries, const ALuint *bids ); cdecl; + LPALSOURCEUNQUEUEBUFFERS = procedure(ALuint sid, ALsizei numEntries, ALuint *bids ); cdecl; + LPALGENBUFFERS = procedure( ALsizei n, ALuint* buffers ); cdecl; + LPALDELETEBUFFERS = procedure( ALsizei n, const ALuint* buffers ); cdecl; + LPALISBUFFER = function( ALuint bid ): ALboolean; cdecl; + LPALBUFFERDATA = procedure( ALuint bid, ALenum format, const ALvoid* data, ALsizei size, ALsizei freq ); cdecl; + LPALBUFFERF = procedure( ALuint bid, ALenum param, ALfloat value); cdecl; + LPALBUFFER3F = procedure( ALuint bid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3 ); cdecl; + LPALBUFFERFV = procedure( ALuint bid, ALenum param, const ALfloat* values ); cdecl; + LPALBUFFERI = procedure( ALuint bid, ALenum param, ALint value); cdecl; + LPALBUFFER3I = procedure( ALuint bid, ALenum param, ALint value1, ALint value2, ALint value3 ); cdecl; + LPALBUFFERIV = procedure( ALuint bid, ALenum param, const ALint* values ); cdecl; + LPALGETBUFFERF = procedure( ALuint bid, ALenum param, ALfloat* value ); cdecl; + LPALGETBUFFER3F = procedure( ALuint bid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3); cdecl; + LPALGETBUFFERFV = procedure( ALuint bid, ALenum param, ALfloat* values ); cdecl; + LPALGETBUFFERI = procedure( ALuint bid, ALenum param, ALint* value ); cdecl; + LPALGETBUFFER3I = procedure( ALuint bid, ALenum param, ALint* value1, ALint* value2, ALint* value3); cdecl; + LPALGETBUFFERIV = procedure( ALuint bid, ALenum param, ALint* values ); cdecl; + LPALDOPPLERFACTOR = procedure( ALfloat value ); cdecl; + LPALDOPPLERVELOCITY = procedure( ALfloat value ); cdecl; + LPALSPEEDOFSOUND = procedure( ALfloat value ); cdecl; + LPALDISTANCEMODEL = procedure( ALenum distanceModel ); cdecl; +} diff --git a/src/lib/openal/al.pas b/src/lib/openal/al.pas new file mode 100644 index 0000000..0d6afba --- /dev/null +++ b/src/lib/openal/al.pas @@ -0,0 +1,42 @@ +{ + Translation of the OpenAL headers for FreePascal + Copyright (C) 2006 by Ivo Steinmann + Copyright (C) 2019 by fgsfds +} + +unit AL; + +{$mode objfpc} + +interface + +uses + ctypes; + +{$IFDEF WINDOWS} + {$DEFINE AL_DYNAMIC} +{$ENDIF} + +{$IF DEFINED(AL_DYNAMIC)} +const +{$IF DEFINED(WINDOWS)} + openallib = 'openal32.dll'; +{$ELSEIF DEFINED(UNIX)} + openallib = 'libopenal.so'; +{$ELSE} + {$MESSAGE ERROR 'AL_DYNAMIC not supported'} +{$IFEND} +{$ELSEIF DEFINED(Darwin)} +{$LINKFRAMEWORK OpenAL} +{$ELSE} + {$LINKLIB openal} +{$ENDIF} + +{$include al.inc} +{$include alc.inc} +{$include alext.inc} +{$include efx.inc} + +implementation + +end. diff --git a/src/lib/openal/alc.inc b/src/lib/openal/alc.inc new file mode 100644 index 0000000..6ad5860 --- /dev/null +++ b/src/lib/openal/alc.inc @@ -0,0 +1,256 @@ +(* + * The ALCAPI, ALCAPIENTRY, and ALC_INVALID macros are deprecated, but are + * included for applications porting code from AL 1.0 + *) + +{ ALCAPI ALC_API + ALCAPIENTRY ALC_APIENTRY + ALC_INVALID = 0; + + + ALC_VERSION_0_1 = 1;} + +type + PALCdevice = ^ALCdevice; + ALCdevice = record + end; + + PALCcontext = ^ALCcontext; + ALCcontext = record + end; + + +(** 8-bit boolean *) + ALCboolean = cbool; + PALCboolean = pcbool; + +(** character *) + ALCchar = char; + PALCchar = pchar; + +(** signed 8-bit 2's complement integer *) + ALCbyte = cint8; + PALCbyte = pcint8; + +(** unsigned 8-bit integer *) + ALCubyte = cuint8; + PALCubyte = pcuint8; + +(** signed 16-bit 2's complement integer *) + ALCshort = cint16; + PALCshort = pcint16; + +(** unsigned 16-bit integer *) + ALCushort = cuint16; + PALCushort = pcuint16; + +(** signed 32-bit 2's complement integer *) + ALCint = cint32; + PALCint = pcint32; + +(** unsigned 32-bit integer *) + ALCuint = cuint32; + PALCuint = pcuint32; + +(** non-negative 32-bit binary integer size *) + ALCsizei = cint32; + PALCsizei = pcint32; + +(** enumerated 32-bit value *) + ALCenum = cint32; + PALCenum = pcint32; + +(** 32-bit IEEE754 floating-point *) + ALCfloat = cfloat; + PALCfloat = pcfloat; + +(** 64-bit IEEE754 floating-point *) + ALCdouble = cdouble; + PALCdouble = pcdouble; + +(** void type (for opaque pointers only) *) + PALCvoid = pointer; + + +(* Enumerant values begin at column 50. No tabs. *) +const + +(* Boolean False. *) + ALC_FALSE = 0; + +(* Boolean True. *) + ALC_TRUE = 1; + +(** + * followed by Hz + *) + ALC_FREQUENCY = $1007; + +(** + * followed by Hz + *) + ALC_REFRESH = $1008; + +(** + * followed by AL_TRUE, AL_FALSE + *) + ALC_SYNC = $1009; + +(** + * followed by Num of requested Mono (3D) Sources + *) + ALC_MONO_SOURCES = $1010; + +(** + * followed by Num of requested Stereo Sources + *) + ALC_STEREO_SOURCES = $1011; + +(** + * errors + *) + +(** + * No error + *) + ALC_NO_ERROR = ALC_FALSE; + +(** + * No device + *) + ALC_INVALID_DEVICE = $A001; + +(** + * invalid context ID + *) + ALC_INVALID_CONTEXT = $A002; + +(** + * bad enum + *) + ALC_INVALID_ENUM = $A003; + +(** + * bad value + *) + ALC_INVALID_VALUE = $A004; + +(** + * Out of memory. + *) + ALC_OUT_OF_MEMORY = $A005; + + +(** + * The Specifier string for default device + *) + ALC_DEFAULT_DEVICE_SPECIFIER = $1004; + ALC_DEVICE_SPECIFIER = $1005; + ALC_EXTENSIONS = $1006; + + ALC_MAJOR_VERSION = $1000; + ALC_MINOR_VERSION = $1001; + + ALC_ATTRIBUTES_SIZE = $1002; + ALC_ALL_ATTRIBUTES = $1003; + +(** + * Capture extension + *) + ALC_CAPTURE_DEVICE_SPECIFIER = $310; + ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER = $311; + ALC_CAPTURE_SAMPLES = $312; + + +(* + * Context Management + *) +function alcCreateContext(device: PALCdevice; const attrlist: PALCint): PALCcontext; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +function alcMakeContextCurrent(context: PALCcontext): ALCboolean; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alcProcessContext(context: PALCcontext); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alcSuspendContext(context: PALCcontext); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alcDestroyContext(context: PALCcontext); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +function alcGetCurrentContext: PALCcontext; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +function alcGetContextsDevice(context: PALCcontext): PALCdevice; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + + +(* + * Device Management + *) +function alcOpenDevice(const devicename: PALCchar): PALCdevice; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +function alcCloseDevice(device: PALCdevice): ALCboolean; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + + +(* + * Error support. + * Obtain the most recent Context error + *) +function alcGetError(device: PALCdevice): ALCenum; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + + +(* + * Extension support. + * Query for the presence of an extension, and obtain any appropriate + * function pointers and enum values. + *) +function alcIsExtensionPresent(device: PALCdevice; const extname: PALCchar): ALCboolean; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +function alcGetProcAddress(device: PALCdevice; const funcname: PALCchar): pointer; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +function alcGetEnumValue(device: PALCdevice; const enumname: PALCchar): ALCenum; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + + +(* + * Query functions + *) +function alcGetString(device: PALCdevice; param: ALCenum): PALCchar; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alcGetIntegerv(device: PALCdevice; param: ALCenum; size: ALCsizei; data: PALCint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + + +(* + * Capture functions + *) +function alcCaptureOpenDevice(const devicename: PALCchar; frequency: ALCuint; format: ALCenum; buffersize: ALCsizei): PALCdevice; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +function alcCaptureCloseDevice(device: PALCdevice): ALCboolean; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alcCaptureStart(device: PALCdevice); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alcCaptureStop(device: PALCdevice); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alcCaptureSamples(device: PALCdevice; buffer: PALCvoid; samples: ALCsizei); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* + * Pointer-to-function types, useful for dynamically getting ALC entry points. + *) +{ +type + LPALCCREATECONTEXT = function(ALCdevice *device, const ALCint *attrlist): PALCcontext; cdecl; + LPALCMAKECONTEXTCURRENT = function( ALCcontext *context ): ALCboolean; cdecl; + LPALCPROCESSCONTEXT = procedure( ALCcontext *context ); cdecl; + LPALCSUSPENDCONTEXT = procedure( ALCcontext *context ); cdecl; + LPALCDESTROYCONTEXT = procedure( ALCcontext *context ); cdecl; + LPALCGETCURRENTCONTEXT = function( ALCvoid ): PALCcontext; cdecl; + LPALCGETCONTEXTSDEVICE = function( ALCcontext *context ): PALCdevice; cdecl; + LPALCOPENDEVICE = function( const ALCchar *devicename ): PALCdevice; cdecl; + LPALCCLOSEDEVICE = function( ALCdevice *device ): ALCboolean; cdecl; + LPALCGETERROR = function( ALCdevice *device ): ALCenum; cdecl; + LPALCISEXTENSIONPRESENT = function( ALCdevice *device, const ALCchar *extname ): ALCboolean; cdecl; + LPALCGETPROCADDRESS = function(ALCdevice *device, const ALCchar *funcname ): pointer; cdecl; + LPALCGETENUMVALUE = function(ALCdevice *device, const ALCchar *enumname ): ALCenum; cdecl; + LPALCGETSTRING = function( ALCdevice *device, ALCenum param ): PALCchar; cdecl; + LPALCGETINTEGERV = procedure(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *dest ); cdecl; + LPALCCAPTUREOPENDEVICE = function( const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize ): PALCdevice; cdecl; + LPALCCAPTURECLOSEDEVICE = function( ALCdevice *device ): ALCboolean; cdecl; + LPALCCAPTURESTART = procedure( ALCdevice *device ); cdecl; + LPALCCAPTURESTOP = procedure( ALCdevice *device ); cdecl; + LPALCCAPTURESAMPLES = procedure( ALCdevice *device, ALCvoid *buffer, ALCsizei samples ); cdecl; +} diff --git a/src/lib/openal/alext.inc b/src/lib/openal/alext.inc new file mode 100644 index 0000000..4dd8b00 --- /dev/null +++ b/src/lib/openal/alext.inc @@ -0,0 +1,138 @@ +(* AL_LOKI_IMA_ADPCM_format extension *) +const + AL_FORMAT_IMA_ADPCM_MONO16_EXT = $10000; + AL_FORMAT_IMA_ADPCM_STEREO16_EXT = $10001; + +(* AL_LOKI_WAVE_format extension *) +const + AL_FORMAT_WAVE_EXT = $10002; + +(* AL_EXT_vorbis extension *) +const + AL_FORMAT_VORBIS_EXT = $10003; + +(* AL_LOKI_quadriphonic extension *) +const + AL_FORMAT_QUAD8_LOKI = $10004; + AL_FORMAT_QUAD16_LOKI = $10005; + +(* AL_EXT_float32 extension *) +const + AL_FORMAT_MONO_FLOAT32 = $10010; + AL_FORMAT_STEREO_FLOAT32 = $10011; + +(* AL_EXT_double extension *) +const + AL_FORMAT_MONO_DOUBLE_EXT = $10012; + AL_FORMAT_STEREO_DOUBLE_EXT = $10013; + +(* ALC_LOKI_audio_channel extension *) +const + ALC_CHAN_MAIN_LOKI = $500001; + ALC_CHAN_PCM_LOKI = $500002; + ALC_CHAN_CD_LOKI = $500003; + +(* ALC_ENUMERATE_ALL_EXT extension *) +const + ALC_DEFAULT_ALL_DEVICES_SPECIFIER = $1012; + ALC_ALL_DEVICES_SPECIFIER = $1013; + +(* AL_EXT_MCFORMATS extension *) +const + AL_FORMAT_QUAD8 = $1204; + AL_FORMAT_QUAD16 = $1205; + AL_FORMAT_QUAD32 = $1206; + AL_FORMAT_REAR8 = $1207; + AL_FORMAT_REAR16 = $1208; + AL_FORMAT_REAR32 = $1209; + AL_FORMAT_51CHN8 = $120A; + AL_FORMAT_51CHN16 = $120B; + AL_FORMAT_51CHN32 = $120C; + AL_FORMAT_61CHN8 = $120D; + AL_FORMAT_61CHN16 = $120E; + AL_FORMAT_61CHN32 = $120F; + AL_FORMAT_71CHN8 = $1210; + AL_FORMAT_71CHN16 = $1211; + AL_FORMAT_71CHN32 = $1212; + +(* AL_EXT_IMA4 extension *) +const + AL_FORMAT_MONO_IMA4 = $1300; + AL_FORMAT_STEREO_IMA4 = $1301; + +(* AL_EXT_buffer_sub_data extension *) +const + AL_BYTE_RW_OFFSETS_EXT = $1031; + AL_SAMPLE_RW_OFFSETS_EXT = $1032; + AL_SEC_RW_OFFSETS_EXT = $1033; + +procedure alBufferSubDataEXT(buffer :ALuint; format :ALenum; const data :PALvoid; offset :ALsizei; length :ALsizei); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* AL_EXT_STATIC_BUFFER extension *) +procedure alBufferDataStatic(buffer :ALint; format :ALenum; data :Pointer; size, freq :ALsizei); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* AL_EXT_sample_buffer_object extension *) +const + AL_SAMPLE_SOURCE_EXT = $1040; + AL_SAMPLE_SINK_EXT = $1041; + AL_READ_ONLY_EXT = $1042; + AL_WRITE_ONLY_EXT = $1043; + AL_READ_WRITE_EXT = $1044; + AL_STREAM_WRITE_EXT = $1045; + AL_STREAM_READ_EXT = $1046; + AL_STREAM_COPY_EXT = $1047; + AL_STATIC_WRITE_EXT = $1048; + AL_STATIC_READ_EXT = $1049; + AL_STATIC_COPY_EXT = $104A; + AL_DYNAMIC_WRITE_EXT = $104B; + AL_DYNAMIC_READ_EXT = $104C; + AL_DYNAMIC_COPY_EXT = $104D; + + procedure alGenDatabuffersEXT(n:ALsizei; puiBuffers:pALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + procedure alDeleteDatabuffersEXT(n:ALsizei; puiBuffers:pALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + function alIsDatabufferEXT(uiBuffer:ALuint):ALboolean; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + procedure alDatabufferDataEXT(buffer:ALuint; data:pALvoid; size:ALsizei; usage:ALenum); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + procedure alDatabufferSubDataEXT(buffer:ALuint; start:ALuint; length:ALsizei; data:pALvoid); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + procedure alGetDatabufferSubDataEXT(buffer:ALuint; start:ALuint; length:ALsizei; data:pALvoid); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + procedure alDatabufferfEXT(buffer:ALuint; eParam:ALenum; flValue:ALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + procedure alDatabufferfvEXT(buffer:ALuint; eParam:ALenum; flValues:pALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + procedure alDatabufferiEXT(buffer:ALuint; eParam:ALenum; lValue:ALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + procedure alDatabufferivEXT(buffer:ALuint; eParam:ALenum; plValues:pALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + procedure alGetDatabufferfEXT(buffer:ALuint; eParam:ALenum; pflValue:pALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + procedure alGetDatabufferfvEXT(buffer:ALuint; eParam:ALenum; pflValues:pALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + procedure alGetDatabufferiEXT(buffer:ALuint; eParam:ALenum; plValue:pALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + procedure alGetDatabufferivEXT(buffer:ALuint; eParam:ALenum; plValues:pALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + procedure alSelectDatabufferEXT(target:ALenum; uiBuffer:ALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + function alMapDatabufferEXT(uiBuffer:ALuint; start:ALuint; length:ALsizei; access:ALenum):pALvoid; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + procedure alUnmapDatabufferEXT(uiBuffer:ALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* ALC_EXT_disconnect extension *) +const + ALC_CONNECTED = $0313; + +(* ALC_EXT_thread_local_context extension *) + +function alcMakeCurrent(context :PALCcontext) :ALCboolean; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; +function alcGetThreadContext() :PALCcontext; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +(* AL_EXT_source_distance_model extension *) +const + AL_SOURCE_DISTANCE_MODEL = $0200; + +(* ALC_SOFT_HRTF extension *) +const + ALC_HRTF_SOFT = $1992; + ALC_DONT_CARE_SOFT = $0002; + ALC_HRTF_STATUS_SOFT = $1993; + ALC_HRTF_DISABLED_SOFT = $0000; + ALC_HRTF_ENABLED_SOFT = $0001; + ALC_HRTF_DENIED_SOFT = $0002; + ALC_HRTF_REQUIRED_SOFT = $0003; + ALC_HRTF_HEADPHONES_DETECTED_SOFT = $0004; + ALC_HRTF_UNSUPPORTED_FORMAT_SOFT = $0005; + ALC_NUM_HRTF_SPECIFIERS_SOFT = $1994; + ALC_HRTF_SPECIFIER_SOFT = $1995; + ALC_HRTF_ID_SOFT = $1996; + +function alcGetStringiSOFT(device: PALCdevice; paramName: ALCenum; index: ALCsizei): PALCchar; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; +function alcResetDeviceSOFT(device: PALCdevice; attribs: PALCint): ALCboolean; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; diff --git a/src/lib/openal/efx.inc b/src/lib/openal/efx.inc new file mode 100644 index 0000000..517bc09 --- /dev/null +++ b/src/lib/openal/efx.inc @@ -0,0 +1,634 @@ +const + ALC_EXT_EFX_NAME = 'ALC_EXT_EFX'; + ALC_EFX_MAJOR_VERSION = $20001; + ALC_EFX_MINOR_VERSION = $20002; + ALC_MAX_AUXILIARY_SENDS = $20003; + (* Listener properties. *) + AL_METERS_PER_UNIT = $20004; + (* Source properties. *) + AL_DIRECT_FILTER = $20005; + AL_AUXILIARY_SEND_FILTER = $20006; + AL_AIR_ABSORPTION_FACTOR = $20007; + AL_ROOM_ROLLOFF_FACTOR = $20008; + AL_CONE_OUTER_GAINHF = $20009; + AL_DIRECT_FILTER_GAINHF_AUTO = $2000A; + AL_AUXILIARY_SEND_FILTER_GAIN_AUTO = $2000B; + AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO = $2000C; + (* Effect properties. *) + (* Reverb effect parameters *) + AL_REVERB_DENSITY = $0001; + AL_REVERB_DIFFUSION = $0002; + AL_REVERB_GAIN = $0003; + AL_REVERB_GAINHF = $0004; + AL_REVERB_DECAY_TIME = $0005; + AL_REVERB_DECAY_HFRATIO = $0006; + AL_REVERB_REFLECTIONS_GAIN = $0007; + AL_REVERB_REFLECTIONS_DELAY = $0008; + AL_REVERB_LATE_REVERB_GAIN = $0009; + AL_REVERB_LATE_REVERB_DELAY = $000A; + AL_REVERB_AIR_ABSORPTION_GAINHF = $000B; + AL_REVERB_ROOM_ROLLOFF_FACTOR = $000C; + AL_REVERB_DECAY_HFLIMIT = $000D; + (* EAX Reverb effect parameters *) + AL_EAXREVERB_DENSITY = $0001; + AL_EAXREVERB_DIFFUSION = $0002; + AL_EAXREVERB_GAIN = $0003; + AL_EAXREVERB_GAINHF = $0004; + AL_EAXREVERB_GAINLF = $0005; + AL_EAXREVERB_DECAY_TIME = $0006; + AL_EAXREVERB_DECAY_HFRATIO = $0007; + AL_EAXREVERB_DECAY_LFRATIO = $0008; + AL_EAXREVERB_REFLECTIONS_GAIN = $0009; + AL_EAXREVERB_REFLECTIONS_DELAY = $000A; + AL_EAXREVERB_REFLECTIONS_PAN = $000B; + AL_EAXREVERB_LATE_REVERB_GAIN = $000C; + AL_EAXREVERB_LATE_REVERB_DELAY = $000D; + AL_EAXREVERB_LATE_REVERB_PAN = $000E; + AL_EAXREVERB_ECHO_TIME = $000F; + AL_EAXREVERB_ECHO_DEPTH = $0010; + AL_EAXREVERB_MODULATION_TIME = $0011; + AL_EAXREVERB_MODULATION_DEPTH = $0012; + AL_EAXREVERB_AIR_ABSORPTION_GAINHF = $0013; + AL_EAXREVERB_HFREFERENCE = $0014; + AL_EAXREVERB_LFREFERENCE = $0015; + AL_EAXREVERB_ROOM_ROLLOFF_FACTOR = $0016; + AL_EAXREVERB_DECAY_HFLIMIT = $0017; + (* Chorus effect parameters *) + AL_CHORUS_WAVEFORM = $0001; + AL_CHORUS_PHASE = $0002; + AL_CHORUS_RATE = $0003; + AL_CHORUS_DEPTH = $0004; + AL_CHORUS_FEEDBACK = $0005; + AL_CHORUS_DELAY = $0006; + (* Distortion effect parameters *) + AL_DISTORTION_EDGE = $0001; + AL_DISTORTION_GAIN = $0002; + AL_DISTORTION_LOWPASS_CUTOFF = $0003; + AL_DISTORTION_EQCENTER = $0004; + AL_DISTORTION_EQBANDWIDTH = $0005; + (* Echo effect parameters *) + AL_ECHO_DELAY = $0001; + AL_ECHO_LRDELAY = $0002; + AL_ECHO_DAMPING = $0003; + AL_ECHO_FEEDBACK = $0004; + AL_ECHO_SPREAD = $0005; + (* Flanger effect parameters *) + AL_FLANGER_WAVEFORM = $0001; + AL_FLANGER_PHASE = $0002; + AL_FLANGER_RATE = $0003; + AL_FLANGER_DEPTH = $0004; + AL_FLANGER_FEEDBACK = $0005; + AL_FLANGER_DELAY = $0006; + (* Frequency shifter effect parameters *) + AL_FREQUENCY_SHIFTER_FREQUENCY = $0001; + AL_FREQUENCY_SHIFTER_LEFT_DIRECTION = $0002; + AL_FREQUENCY_SHIFTER_RIGHT_DIRECTION = $0003; + (* Vocal morpher effect parameters *) + AL_VOCAL_MORPHER_PHONEMEA = $0001; + AL_VOCAL_MORPHER_PHONEMEA_COARSE_TUNING = $0002; + AL_VOCAL_MORPHER_PHONEMEB = $0003; + AL_VOCAL_MORPHER_PHONEMEB_COARSE_TUNING = $0004; + AL_VOCAL_MORPHER_WAVEFORM = $0005; + AL_VOCAL_MORPHER_RATE = $0006; + (* Pitchshifter effect parameters *) + AL_PITCH_SHIFTER_COARSE_TUNE = $0001; + AL_PITCH_SHIFTER_FINE_TUNE = $0002; + (* Ringmodulator effect parameters *) + AL_RING_MODULATOR_FREQUENCY = $0001; + AL_RING_MODULATOR_HIGHPASS_CUTOFF = $0002; + AL_RING_MODULATOR_WAVEFORM = $0003; + (* Autowah effect parameters *) + AL_AUTOWAH_ATTACK_TIME = $0001; + AL_AUTOWAH_RELEASE_TIME = $0002; + AL_AUTOWAH_RESONANCE = $0003; + AL_AUTOWAH_PEAK_GAIN = $0004; + (* Compressor effect parameters *) + AL_COMPRESSOR_ONOFF = $0001; + (* Equalizer effect parameters *) + AL_EQUALIZER_LOW_GAIN = $0001; + AL_EQUALIZER_LOW_CUTOFF = $0002; + AL_EQUALIZER_MID1_GAIN = $0003; + AL_EQUALIZER_MID1_CENTER = $0004; + AL_EQUALIZER_MID1_WIDTH = $0005; + AL_EQUALIZER_MID2_GAIN = $0006; + AL_EQUALIZER_MID2_CENTER = $0007; + AL_EQUALIZER_MID2_WIDTH = $0008; + AL_EQUALIZER_HIGH_GAIN = $0009; + AL_EQUALIZER_HIGH_CUTOFF = $000A; + (* Effect type *) + AL_EFFECT_FIRST_PARAMETER = $0000; + AL_EFFECT_LAST_PARAMETER = $8000; + AL_EFFECT_TYPE = $8001; + (* Effect types, used with the AL_EFFECT_TYPE property *) + AL_EFFECT_NULL = $0000; + AL_EFFECT_REVERB = $0001; + AL_EFFECT_CHORUS = $0002; + AL_EFFECT_DISTORTION = $0003; + AL_EFFECT_ECHO = $0004; + AL_EFFECT_FLANGER = $0005; + AL_EFFECT_FREQUENCY_SHIFTER = $0006; + AL_EFFECT_VOCAL_MORPHER = $0007; + AL_EFFECT_PITCH_SHIFTER = $0008; + AL_EFFECT_RING_MODULATOR = $0009; + AL_EFFECT_AUTOWAH = $000A; + AL_EFFECT_COMPRESSOR = $000B; + AL_EFFECT_EQUALIZER = $000C; + AL_EFFECT_EAXREVERB = $8000; + (* Auxiliary Effect Slot properties. *) + AL_EFFECTSLOT_EFFECT = $0001; + AL_EFFECTSLOT_GAIN = $0002; + AL_EFFECTSLOT_AUXILIARY_SEND_AUTO = $0003; + (* NULL Auxiliary Slot ID to disable a source send. *) + AL_EFFECTSLOT_NULL = $0000; + (* Filter properties. *) + (* Lowpass filter parameters *) + AL_LOWPASS_GAIN = $0001; + AL_LOWPASS_GAINHF = $0002; + (* Highpass filter parameters *) + AL_HIGHPASS_GAIN = $0001; + AL_HIGHPASS_GAINLF = $0002; + (* Bandpass filter parameters *) + AL_BANDPASS_GAIN = $0001; + AL_BANDPASS_GAINLF = $0002; + AL_BANDPASS_GAINHF = $0003; + (* Filter type *) + AL_FILTER_FIRST_PARAMETER = $0000; + AL_FILTER_LAST_PARAMETER = $8000; + AL_FILTER_TYPE = $8001; + (* Filter types, used with the AL_FILTER_TYPE property *) + AL_FILTER_NULL = $0000; + AL_FILTER_LOWPASS = $0001; + AL_FILTER_HIGHPASS = $0002; + AL_FILTER_BANDPASS = $0003; + +const + (* Filter ranges and defaults. *) + (* Lowpass filter *) + AL_LOWPASS_MIN_GAIN = 0.0; + AL_LOWPASS_MAX_GAIN = 1.0; + AL_LOWPASS_DEFAULT_GAIN = 1.0; + AL_LOWPASS_MIN_GAINHF = 0.0; + AL_LOWPASS_MAX_GAINHF = 1.0; + AL_LOWPASS_DEFAULT_GAINHF = 1.0; + (* Highpass filter *) + AL_HIGHPASS_MIN_GAIN = 0.0; + AL_HIGHPASS_MAX_GAIN = 1.0; + AL_HIGHPASS_DEFAULT_GAIN = 1.0; + AL_HIGHPASS_MIN_GAINLF = 0.0; + AL_HIGHPASS_MAX_GAINLF = 1.0; + AL_HIGHPASS_DEFAULT_GAINLF = 1.0; + (* Bandpass filter *) + AL_BANDPASS_MIN_GAIN = 0.0; + AL_BANDPASS_MAX_GAIN = 1.0; + AL_BANDPASS_DEFAULT_GAIN = 1.0; + AL_BANDPASS_MIN_GAINHF = 0.0; + AL_BANDPASS_MAX_GAINHF = 1.0; + AL_BANDPASS_DEFAULT_GAINHF = 1.0; + AL_BANDPASS_MIN_GAINLF = 0.0; + AL_BANDPASS_MAX_GAINLF = 1.0; + AL_BANDPASS_DEFAULT_GAINLF = 1.0; + (* Effect parameter ranges and defaults. *) + (* Standard reverb effect *) + AL_REVERB_MIN_DENSITY = 0.0; + AL_REVERB_MAX_DENSITY = 1.0; + AL_REVERB_DEFAULT_DENSITY = 1.0; + AL_REVERB_MIN_DIFFUSION = 0.0; + AL_REVERB_MAX_DIFFUSION = 1.0; + AL_REVERB_DEFAULT_DIFFUSION = 1.0; + AL_REVERB_MIN_GAIN = 0.0; + AL_REVERB_MAX_GAIN = 1.0; + AL_REVERB_DEFAULT_GAIN = 0.32; + AL_REVERB_MIN_GAINHF = 0.0; + AL_REVERB_MAX_GAINHF = 1.0; + AL_REVERB_DEFAULT_GAINHF = 0.89; + AL_REVERB_MIN_DECAY_TIME = 0.1; + AL_REVERB_MAX_DECAY_TIME = 20.0; + AL_REVERB_DEFAULT_DECAY_TIME = 1.49; + AL_REVERB_MIN_DECAY_HFRATIO = 0.1; + AL_REVERB_MAX_DECAY_HFRATIO = 2.0; + AL_REVERB_DEFAULT_DECAY_HFRATIO = 0.83; + AL_REVERB_MIN_REFLECTIONS_GAIN = 0.0; + AL_REVERB_MAX_REFLECTIONS_GAIN = 3.16; + AL_REVERB_DEFAULT_REFLECTIONS_GAIN = 0.5; + AL_REVERB_MIN_REFLECTIONS_DELAY = 0.0; + AL_REVERB_MAX_REFLECTIONS_DELAY = 0.3; + AL_REVERB_DEFAULT_REFLECTIONS_DELAY = 0.7; + AL_REVERB_MIN_LATE_REVERB_GAIN = 0.0; + AL_REVERB_MAX_LATE_REVERB_GAIN = 10.0; + AL_REVERB_DEFAULT_LATE_REVERB_GAIN = 1.26; + AL_REVERB_MIN_LATE_REVERB_DELAY = 0.0; + AL_REVERB_MAX_LATE_REVERB_DELAY = 0.1; + AL_REVERB_DEFAULT_LATE_REVERB_DELAY = 0.9; + AL_REVERB_MIN_AIR_ABSORPTION_GAINHF = 0.892; + AL_REVERB_MAX_AIR_ABSORPTION_GAINHF = 1.0; + AL_REVERB_DEFAULT_AIR_ABSORPTION_GAINHF = 0.994; + AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR = 0.0; + AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR = 10.0; + AL_REVERB_DEFAULT_ROOM_ROLLOFF_FACTOR = 0.0; + AL_REVERB_MIN_DECAY_HFLIMIT = AL_FALSE; + AL_REVERB_MAX_DECAY_HFLIMIT = AL_TRUE; + AL_REVERB_DEFAULT_DECAY_HFLIMIT = AL_TRUE; + (* EAX reverb effect *) + AL_EAXREVERB_MIN_DENSITY = 0.0; + AL_EAXREVERB_MAX_DENSITY = 1.0; + AL_EAXREVERB_DEFAULT_DENSITY = 1.0; + AL_EAXREVERB_MIN_DIFFUSION = 0.0; + AL_EAXREVERB_MAX_DIFFUSION = 1.0; + AL_EAXREVERB_DEFAULT_DIFFUSION = 1.0; + AL_EAXREVERB_MIN_GAIN = 0.0; + AL_EAXREVERB_MAX_GAIN = 1.0; + AL_EAXREVERB_DEFAULT_GAIN = 0.32; + AL_EAXREVERB_MIN_GAINHF = 0.0; + AL_EAXREVERB_MAX_GAINHF = 1.0; + AL_EAXREVERB_DEFAULT_GAINHF = 0.89; + AL_EAXREVERB_MIN_GAINLF = 0.0; + AL_EAXREVERB_MAX_GAINLF = 1.0; + AL_EAXREVERB_DEFAULT_GAINLF = 1.0; + AL_EAXREVERB_MIN_DECAY_TIME = 0.1; + AL_EAXREVERB_MAX_DECAY_TIME = 20.0; + AL_EAXREVERB_DEFAULT_DECAY_TIME = 1.49; + AL_EAXREVERB_MIN_DECAY_HFRATIO = 0.1; + AL_EAXREVERB_MAX_DECAY_HFRATIO = 2.0; + AL_EAXREVERB_DEFAULT_DECAY_HFRATIO = 0.83; + AL_EAXREVERB_MIN_DECAY_LFRATIO = 0.1; + AL_EAXREVERB_MAX_DECAY_LFRATIO = 2.0; + AL_EAXREVERB_DEFAULT_DECAY_LFRATIO = 1.0; + AL_EAXREVERB_MIN_REFLECTIONS_GAIN = 0.0; + AL_EAXREVERB_MAX_REFLECTIONS_GAIN = 3.16; + AL_EAXREVERB_DEFAULT_REFLECTIONS_GAIN = 0.5; + AL_EAXREVERB_MIN_REFLECTIONS_DELAY = 0.0; + AL_EAXREVERB_MAX_REFLECTIONS_DELAY = 0.3; + AL_EAXREVERB_DEFAULT_REFLECTIONS_DELAY = 0.7; + AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ = 0.0; + AL_EAXREVERB_MIN_LATE_REVERB_GAIN = 0.0; + AL_EAXREVERB_MAX_LATE_REVERB_GAIN = 10.0; + AL_EAXREVERB_DEFAULT_LATE_REVERB_GAIN = 1.26; + AL_EAXREVERB_MIN_LATE_REVERB_DELAY = 0.0; + AL_EAXREVERB_MAX_LATE_REVERB_DELAY = 0.1; + AL_EAXREVERB_DEFAULT_LATE_REVERB_DELAY = 0.9; + AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ = 0.0; + AL_EAXREVERB_MIN_ECHO_TIME = 0.3; + AL_EAXREVERB_MAX_ECHO_TIME = 0.25; + AL_EAXREVERB_DEFAULT_ECHO_TIME = 0.25; + AL_EAXREVERB_MIN_ECHO_DEPTH = 0.0; + AL_EAXREVERB_MAX_ECHO_DEPTH = 1.0; + AL_EAXREVERB_DEFAULT_ECHO_DEPTH = 0.0; + AL_EAXREVERB_MIN_MODULATION_TIME = 0.4; + AL_EAXREVERB_MAX_MODULATION_TIME = 4.0; + AL_EAXREVERB_DEFAULT_MODULATION_TIME = 0.25; + AL_EAXREVERB_MIN_MODULATION_DEPTH = 0.0; + AL_EAXREVERB_MAX_MODULATION_DEPTH = 1.0; + AL_EAXREVERB_DEFAULT_MODULATION_DEPTH = 0.0; + AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF = 0.892; + AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF = 1.0; + AL_EAXREVERB_DEFAULT_AIR_ABSORPTION_GAINHF = 0.994; + AL_EAXREVERB_MIN_HFREFERENCE = 1000.0; + AL_EAXREVERB_MAX_HFREFERENCE = 20000.0; + AL_EAXREVERB_DEFAULT_HFREFERENCE = 5000.0; + AL_EAXREVERB_MIN_LFREFERENCE = 20.0; + AL_EAXREVERB_MAX_LFREFERENCE = 1000.0; + AL_EAXREVERB_DEFAULT_LFREFERENCE = 250.0; + AL_EAXREVERB_MIN_ROOM_ROLLOFF_FACTOR = 0.0; + AL_EAXREVERB_MAX_ROOM_ROLLOFF_FACTOR = 10.0; + AL_EAXREVERB_DEFAULT_ROOM_ROLLOFF_FACTOR = 0.0; + AL_EAXREVERB_MIN_DECAY_HFLIMIT = AL_FALSE; + AL_EAXREVERB_MAX_DECAY_HFLIMIT = AL_TRUE; + AL_EAXREVERB_DEFAULT_DECAY_HFLIMIT = AL_TRUE; + (* Chorus effect *) + AL_CHORUS_WAVEFORM_SINUSOID = 0; + AL_CHORUS_WAVEFORM_TRIANGLE = 1; + AL_CHORUS_MIN_WAVEFORM = 0; + AL_CHORUS_MAX_WAVEFORM = 1; + AL_CHORUS_DEFAULT_WAVEFORM = 1; + AL_CHORUS_MIN_PHASE = -180; + AL_CHORUS_MAX_PHASE = 180; + AL_CHORUS_DEFAULT_PHASE = 90; + AL_CHORUS_MIN_RATE = 0.0; + AL_CHORUS_MAX_RATE = 10.0; + AL_CHORUS_DEFAULT_RATE = 1.1; + AL_CHORUS_MIN_DEPTH = 0.0; + AL_CHORUS_MAX_DEPTH = 1.0; + AL_CHORUS_DEFAULT_DEPTH = 0.1; + AL_CHORUS_MIN_FEEDBACK = -1.0; + AL_CHORUS_MAX_FEEDBACK = 1.0; + AL_CHORUS_DEFAULT_FEEDBACK = 0.25; + AL_CHORUS_MIN_DELAY = 0.0; + AL_CHORUS_MAX_DELAY = 0.016; + AL_CHORUS_DEFAULT_DELAY = 0.016; + (* Distortion effect *) + AL_DISTORTION_MIN_EDGE = 0.0; + AL_DISTORTION_MAX_EDGE = 1.0; + AL_DISTORTION_DEFAULT_EDGE = 0.2; + AL_DISTORTION_MIN_GAIN = 0.1; + AL_DISTORTION_MAX_GAIN = 1.0; + AL_DISTORTION_DEFAULT_GAIN = 0.5; + AL_DISTORTION_MIN_LOWPASS_CUTOFF = 80.0; + AL_DISTORTION_MAX_LOWPASS_CUTOFF = 24000.0; + AL_DISTORTION_DEFAULT_LOWPASS_CUTOFF = 8000.0; + AL_DISTORTION_MIN_EQCENTER = 80.0; + AL_DISTORTION_MAX_EQCENTER = 24000.0; + AL_DISTORTION_DEFAULT_EQCENTER = 3600.0; + AL_DISTORTION_MIN_EQBANDWIDTH = 80.0; + AL_DISTORTION_MAX_EQBANDWIDTH = 24000.0; + AL_DISTORTION_DEFAULT_EQBANDWIDTH = 3600.0; + (* Echo effect *) + AL_ECHO_MIN_DELAY = 0.0; + AL_ECHO_MAX_DELAY = 0.207; + AL_ECHO_DEFAULT_DELAY = 0.1; + AL_ECHO_MIN_LRDELAY = 0.0; + AL_ECHO_MAX_LRDELAY = 0.404; + AL_ECHO_DEFAULT_LRDELAY = 0.1; + AL_ECHO_MIN_DAMPING = 0.0; + AL_ECHO_MAX_DAMPING = 0.99; + AL_ECHO_DEFAULT_DAMPING = 0.5; + AL_ECHO_MIN_FEEDBACK = 0.0; + AL_ECHO_MAX_FEEDBACK = 1.0; + AL_ECHO_DEFAULT_FEEDBACK = 0.5; + AL_ECHO_MIN_SPREAD = -1.0; + AL_ECHO_MAX_SPREAD = 1.0; + AL_ECHO_DEFAULT_SPREAD = -1.0; + (* Flanger effect *) + AL_FLANGER_WAVEFORM_SINUSOID = 0; + AL_FLANGER_WAVEFORM_TRIANGLE = 1; + AL_FLANGER_MIN_WAVEFORM = 0; + AL_FLANGER_MAX_WAVEFORM = 1; + AL_FLANGER_DEFAULT_WAVEFORM = 1; + AL_FLANGER_MIN_PHASE = -180; + AL_FLANGER_MAX_PHASE = 180; + AL_FLANGER_DEFAULT_PHASE = 0; + AL_FLANGER_MIN_RATE = 0.0; + AL_FLANGER_MAX_RATE = 10.0; + AL_FLANGER_DEFAULT_RATE = 0.27; + AL_FLANGER_MIN_DEPTH = 0.0; + AL_FLANGER_MAX_DEPTH = 1.0; + AL_FLANGER_DEFAULT_DEPTH = 1.0; + AL_FLANGER_MIN_FEEDBACK = -1.0; + AL_FLANGER_MAX_FEEDBACK = 1.0; + AL_FLANGER_DEFAULT_FEEDBACK = -0.5; + AL_FLANGER_MIN_DELAY = 0.0; + AL_FLANGER_MAX_DELAY = 0.4; + AL_FLANGER_DEFAULT_DELAY = 0.2; + (* Frequency shifter effect *) + AL_FREQUENCY_SHIFTER_MIN_FREQUENCY = 0.0; + AL_FREQUENCY_SHIFTER_MAX_FREQUENCY = 24000.0; + AL_FREQUENCY_SHIFTER_DEFAULT_FREQUENCY = 0.0; + AL_FREQUENCY_SHIFTER_MIN_LEFT_DIRECTION = 0; + AL_FREQUENCY_SHIFTER_MAX_LEFT_DIRECTION = 2; + AL_FREQUENCY_SHIFTER_DEFAULT_LEFT_DIRECTION = 0; + AL_FREQUENCY_SHIFTER_DIRECTION_DOWN = 0; + AL_FREQUENCY_SHIFTER_DIRECTION_UP = 1; + AL_FREQUENCY_SHIFTER_DIRECTION_OFF = 2; + AL_FREQUENCY_SHIFTER_MIN_RIGHT_DIRECTION = 0; + AL_FREQUENCY_SHIFTER_MAX_RIGHT_DIRECTION = 2; + AL_FREQUENCY_SHIFTER_DEFAULT_RIGHT_DIRECTION = 0; + (* Vocal morpher effect *) + AL_VOCAL_MORPHER_MIN_PHONEMEA = 0; + AL_VOCAL_MORPHER_MAX_PHONEMEA = 29; + AL_VOCAL_MORPHER_DEFAULT_PHONEMEA = 0; + AL_VOCAL_MORPHER_MIN_PHONEMEA_COARSE_TUNING = -24; + AL_VOCAL_MORPHER_MAX_PHONEMEA_COARSE_TUNING = 24; + AL_VOCAL_MORPHER_DEFAULT_PHONEMEA_COARSE_TUNING = 0; + AL_VOCAL_MORPHER_MIN_PHONEMEB = 0; + AL_VOCAL_MORPHER_MAX_PHONEMEB = 29; + AL_VOCAL_MORPHER_DEFAULT_PHONEMEB = 10; + AL_VOCAL_MORPHER_MIN_PHONEMEB_COARSE_TUNING = -24; + AL_VOCAL_MORPHER_MAX_PHONEMEB_COARSE_TUNING = 24; + AL_VOCAL_MORPHER_DEFAULT_PHONEMEB_COARSE_TUNING = 0; + AL_VOCAL_MORPHER_PHONEME_A = 0; + AL_VOCAL_MORPHER_PHONEME_E = 1; + AL_VOCAL_MORPHER_PHONEME_I = 2; + AL_VOCAL_MORPHER_PHONEME_O = 3; + AL_VOCAL_MORPHER_PHONEME_U = 4; + AL_VOCAL_MORPHER_PHONEME_AA = 5; + AL_VOCAL_MORPHER_PHONEME_AE = 6; + AL_VOCAL_MORPHER_PHONEME_AH = 7; + AL_VOCAL_MORPHER_PHONEME_AO = 8; + AL_VOCAL_MORPHER_PHONEME_EH = 9; + AL_VOCAL_MORPHER_PHONEME_ER = 10; + AL_VOCAL_MORPHER_PHONEME_IH = 11; + AL_VOCAL_MORPHER_PHONEME_IY = 12; + AL_VOCAL_MORPHER_PHONEME_UH = 13; + AL_VOCAL_MORPHER_PHONEME_UW = 14; + AL_VOCAL_MORPHER_PHONEME_B = 15; + AL_VOCAL_MORPHER_PHONEME_D = 16; + AL_VOCAL_MORPHER_PHONEME_F = 17; + AL_VOCAL_MORPHER_PHONEME_G = 18; + AL_VOCAL_MORPHER_PHONEME_J = 19; + AL_VOCAL_MORPHER_PHONEME_K = 20; + AL_VOCAL_MORPHER_PHONEME_L = 21; + AL_VOCAL_MORPHER_PHONEME_M = 22; + AL_VOCAL_MORPHER_PHONEME_N = 23; + AL_VOCAL_MORPHER_PHONEME_P = 24; + AL_VOCAL_MORPHER_PHONEME_R = 25; + AL_VOCAL_MORPHER_PHONEME_S = 26; + AL_VOCAL_MORPHER_PHONEME_T = 27; + AL_VOCAL_MORPHER_PHONEME_V = 28; + AL_VOCAL_MORPHER_PHONEME_Z = 29; + AL_VOCAL_MORPHER_WAVEFORM_SINUSOID = 0; + AL_VOCAL_MORPHER_WAVEFORM_TRIANGLE = 1; + AL_VOCAL_MORPHER_WAVEFORM_SAWTOOTH = 2; + AL_VOCAL_MORPHER_MIN_WAVEFORM = 0; + AL_VOCAL_MORPHER_MAX_WAVEFORM = 2; + AL_VOCAL_MORPHER_DEFAULT_WAVEFORM = 0; + AL_VOCAL_MORPHER_MIN_RATE = 0.0; + AL_VOCAL_MORPHER_MAX_RATE = 10.0; + AL_VOCAL_MORPHER_DEFAULT_RATE = 1.41; + (* Pitch shifter effect *) + AL_PITCH_SHIFTER_MIN_COARSE_TUNE = -12; + AL_PITCH_SHIFTER_MAX_COARSE_TUNE = 12; + AL_PITCH_SHIFTER_DEFAULT_COARSE_TUNE = 12; + AL_PITCH_SHIFTER_MIN_FINE_TUNE = -50; + AL_PITCH_SHIFTER_MAX_FINE_TUNE = 50; + AL_PITCH_SHIFTER_DEFAULT_FINE_TUNE = 0; + (* Ring modulator effect *) + AL_RING_MODULATOR_MIN_FREQUENCY = 0.0; + AL_RING_MODULATOR_MAX_FREQUENCY = 8000.0; + AL_RING_MODULATOR_DEFAULT_FREQUENCY = 440.0; + AL_RING_MODULATOR_MIN_HIGHPASS_CUTOFF = 0.0; + AL_RING_MODULATOR_MAX_HIGHPASS_CUTOFF = 24000.0; + AL_RING_MODULATOR_DEFAULT_HIGHPASS_CUTOFF = 800.0; + AL_RING_MODULATOR_SINUSOID = 0; + AL_RING_MODULATOR_SAWTOOTH = 1; + AL_RING_MODULATOR_SQUARE = 2; + AL_RING_MODULATOR_MIN_WAVEFORM = 0; + AL_RING_MODULATOR_MAX_WAVEFORM = 2; + AL_RING_MODULATOR_DEFAULT_WAVEFORM = 0; + (* Autowah effect *) + AL_AUTOWAH_MIN_ATTACK_TIME = 0.1; + AL_AUTOWAH_MAX_ATTACK_TIME = 1.0; + AL_AUTOWAH_DEFAULT_ATTACK_TIME = 0.6; + AL_AUTOWAH_MIN_RELEASE_TIME = 0.1; + AL_AUTOWAH_MAX_RELEASE_TIME = 1.0; + AL_AUTOWAH_DEFAULT_RELEASE_TIME = 0.6; + AL_AUTOWAH_MIN_RESONANCE = 2.0; + AL_AUTOWAH_MAX_RESONANCE = 1000.0; + AL_AUTOWAH_DEFAULT_RESONANCE = 1000.0; + AL_AUTOWAH_MIN_PEAK_GAIN = 0.3; + AL_AUTOWAH_MAX_PEAK_GAIN = 31621.0; + AL_AUTOWAH_DEFAULT_PEAK_GAIN = 11.22; + (* Compressor effect *) + AL_COMPRESSOR_MIN_ONOFF = 0; + AL_COMPRESSOR_MAX_ONOFF = 1; + AL_COMPRESSOR_DEFAULT_ONOFF = 1; + (* Equalizer effect *) + AL_EQUALIZER_MIN_LOW_GAIN = 0.126; + AL_EQUALIZER_MAX_LOW_GAIN = 7.943; + AL_EQUALIZER_DEFAULT_LOW_GAIN = 1.0; + AL_EQUALIZER_MIN_LOW_CUTOFF = 50.0; + AL_EQUALIZER_MAX_LOW_CUTOFF = 800.0; + AL_EQUALIZER_DEFAULT_LOW_CUTOFF = 200.0; + AL_EQUALIZER_MIN_MID1_GAIN = 0.126; + AL_EQUALIZER_MAX_MID1_GAIN = 7.943; + AL_EQUALIZER_DEFAULT_MID1_GAIN = 1.0; + AL_EQUALIZER_MIN_MID1_CENTER = 200.0; + AL_EQUALIZER_MAX_MID1_CENTER = 3000.0; + AL_EQUALIZER_DEFAULT_MID1_CENTER = 500.0; + AL_EQUALIZER_MIN_MID1_WIDTH = 0.1; + AL_EQUALIZER_MAX_MID1_WIDTH = 1.0; + AL_EQUALIZER_DEFAULT_MID1_WIDTH = 1.0; + AL_EQUALIZER_MIN_MID2_GAIN = 0.126; + AL_EQUALIZER_MAX_MID2_GAIN = 7.943; + AL_EQUALIZER_DEFAULT_MID2_GAIN = 1.0; + AL_EQUALIZER_MIN_MID2_CENTER = 1000.0; + AL_EQUALIZER_MAX_MID2_CENTER = 8000.0; + AL_EQUALIZER_DEFAULT_MID2_CENTER = 3000.0; + AL_EQUALIZER_MIN_MID2_WIDTH = 0.1; + AL_EQUALIZER_MAX_MID2_WIDTH = 1.0; + AL_EQUALIZER_DEFAULT_MID2_WIDTH = 1.0; + AL_EQUALIZER_MIN_HIGH_GAIN = 0.126; + AL_EQUALIZER_MAX_HIGH_GAIN = 7.943; + AL_EQUALIZER_DEFAULT_HIGH_GAIN = 1.0; + AL_EQUALIZER_MIN_HIGH_CUTOFF = 4000.0; + AL_EQUALIZER_MAX_HIGH_CUTOFF = 16000.0; + AL_EQUALIZER_DEFAULT_HIGH_CUTOFF = 6000.0; + (* Source parameter value ranges and defaults. *) + AL_MIN_AIR_ABSORPTION_FACTOR = 0.0; + AL_MAX_AIR_ABSORPTION_FACTOR = 10.0; + AL_DEFAULT_AIR_ABSORPTION_FACTOR = 0.0; + AL_MIN_ROOM_ROLLOFF_FACTOR = 0.0; + AL_MAX_ROOM_ROLLOFF_FACTOR = 10.0; + AL_DEFAULT_ROOM_ROLLOFF_FACTOR = 0.0; + AL_MIN_CONE_OUTER_GAINHF = 0.0; + AL_MAX_CONE_OUTER_GAINHF = 1.0; + AL_DEFAULT_CONE_OUTER_GAINHF = 1.0; + AL_MIN_DIRECT_FILTER_GAINHF_AUTO = AL_FALSE; + AL_MAX_DIRECT_FILTER_GAINHF_AUTO = AL_TRUE; + AL_DEFAULT_DIRECT_FILTER_GAINHF_AUTO = AL_TRUE; + AL_MIN_AUXILIARY_SEND_FILTER_GAIN_AUTO = AL_FALSE; + AL_MAX_AUXILIARY_SEND_FILTER_GAIN_AUTO = AL_TRUE; + AL_DEFAULT_AUXILIARY_SEND_FILTER_GAIN_AUTO = AL_TRUE; + AL_MIN_AUXILIARY_SEND_FILTER_GAINHF_AUTO = AL_FALSE; + AL_MAX_AUXILIARY_SEND_FILTER_GAINHF_AUTO = AL_TRUE; + AL_DEFAULT_AUXILIARY_SEND_FILTER_GAINHF_AUTO = AL_TRUE; + (* Listener parameter value ranges and defaults. *) + AL_MIN_METERS_PER_UNIT = 0.0; // FIXME: was FLT_MIN + AL_MAX_METERS_PER_UNIT = 1e10; // FIXME: was FLT_MAX + AL_DEFAULT_METERS_PER_UNIT = 1.0; + +procedure alGenEffects(n: ALsizei; effects: pALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alDeleteEffects(n: ALsizei; effects: pALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +function alIsEffect(effect: ALuint): ALboolean; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alEffecti(effect: ALuint; param: ALenum; iValue: ALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alEffectiv(effect: ALuint; param: ALenum; piValues: pALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alEffectf(effect: ALuint; param: ALenum; flValue: ALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alEffectfv(effect: ALuint; param: ALenum; pflValues: pALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetEffecti(effect: ALuint; param: ALenum; piValue: pALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetEffectiv(effect: ALuint; param: ALenum; piValues: pALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetEffectf(effect: ALuint; param: ALenum; pflValue: pALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetEffectfv(effect: ALuint; param: ALenum; pflValues: pALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGenFilters(n: ALsizei; filters: pALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alDeleteFilters(n: ALsizei; filters: pALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +function alIsFilter(filter: ALuint): ALboolean; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alFilteri(filter: ALuint; param: ALenum; iValue: ALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alFilteriv(filter: ALuint; param: ALenum; piValues: pALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alFilterf(filter: ALuint; param: ALenum; flValue: ALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alFilterfv(filter: ALuint; param: ALenum; pflValues: pALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetFilteri(filter: ALuint; param: ALenum; piValue: pALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetFilteriv(filter: ALuint; param: ALenum; piValues: pALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetFilterf(filter: ALuint; param: ALenum; pflValue: pALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetFilterfv(filter: ALuint; param: ALenum; pflValues: pALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGenAuxiliaryEffectSlots(n: ALsizei; effectslots: pALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alDeleteAuxiliaryEffectSlots(n: ALsizei; effectslots: pALuint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +function alIsAuxiliaryEffectSlot(effectslot: ALuint): ALboolean; cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alAuxiliaryEffectSloti(effectslot: ALuint; param: ALenum; iValue: ALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alAuxiliaryEffectSlotiv(effectslot: ALuint; param: ALenum; piValues: pALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alAuxiliaryEffectSlotf(effectslot: ALuint; param: ALenum; flValue: ALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alAuxiliaryEffectSlotfv(effectslot: ALuint; param: ALenum; pflValues: pALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetAuxiliaryEffectSloti(effectslot: ALuint; param: ALenum; piValue: pALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetAuxiliaryEffectSlotiv(effectslot: ALuint; param: ALenum; piValues: pALint); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetAuxiliaryEffectSlotf(effectslot: ALuint; param: ALenum; pflValue: pALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +procedure alGetAuxiliaryEffectSlotfv(effectslot: ALuint; param: ALenum; pflValues: pALfloat); cdecl; external {$IFDEF AL_DYNAMIC}openallib{$ENDIF}; + +{ +type + /* 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*); +} \ No newline at end of file -- 2.29.2