From b53bcac5289d7d76d1a970b864a45505d5408b9d Mon Sep 17 00:00:00 2001 From: Daniel Date: Mon, 30 May 2016 11:04:09 +0200 Subject: [PATCH] OpenAL Test --- CrystalJohan.vcxproj | 6 +- CrystalJohan.vcxproj.filters | 6 + OpenAL.cpp | 161 ++++ OpenAL.h | 10 + WAVE/Sound.wav | Bin 0 -> 24685 bytes openAL/include/EFX-Util.h | 446 +++++++++++ openAL/include/al.h | 732 +++++++++++++++++ openAL/include/alc.h | 281 +++++++ openAL/include/efx-creative.h | 151 ++++ openAL/include/efx.h | 737 ++++++++++++++++++ openAL/include/xram.h | 94 +++ openAL/libs/Win32/EFX-Util_MT/EFX-Util.lib | Bin 0 -> 9072 bytes openAL/libs/Win32/EFX-Util_MTDLL/EFX-Util.lib | Bin 0 -> 9220 bytes openAL/libs/Win32/OpenAL32.lib | Bin 0 -> 20552 bytes openAL/libs/Win64/EFX-Util_MT/EFX-Util.lib | Bin 0 -> 15158 bytes openAL/libs/Win64/EFX-Util_MTDLL/EFX-Util.lib | Bin 0 -> 15308 bytes openAL/libs/Win64/OpenAL32.lib | Bin 0 -> 19858 bytes 17 files changed, 2622 insertions(+), 2 deletions(-) create mode 100644 OpenAL.cpp create mode 100644 OpenAL.h create mode 100644 WAVE/Sound.wav create mode 100644 openAL/include/EFX-Util.h create mode 100644 openAL/include/al.h create mode 100644 openAL/include/alc.h create mode 100644 openAL/include/efx-creative.h create mode 100644 openAL/include/efx.h create mode 100644 openAL/include/xram.h create mode 100644 openAL/libs/Win32/EFX-Util_MT/EFX-Util.lib create mode 100644 openAL/libs/Win32/EFX-Util_MTDLL/EFX-Util.lib create mode 100644 openAL/libs/Win32/OpenAL32.lib create mode 100644 openAL/libs/Win64/EFX-Util_MT/EFX-Util.lib create mode 100644 openAL/libs/Win64/EFX-Util_MTDLL/EFX-Util.lib create mode 100644 openAL/libs/Win64/OpenAL32.lib diff --git a/CrystalJohan.vcxproj b/CrystalJohan.vcxproj index eb8f65c..1b7f959 100644 --- a/CrystalJohan.vcxproj +++ b/CrystalJohan.vcxproj @@ -120,14 +120,14 @@ true WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) - freeglut/include + freeglut/include; openAL/include Console true true true - freeglut/lib + freeglut/lib; openAL/libs @@ -161,6 +161,7 @@ + @@ -175,6 +176,7 @@ + diff --git a/CrystalJohan.vcxproj.filters b/CrystalJohan.vcxproj.filters index 4b5393a..1a2e551 100644 --- a/CrystalJohan.vcxproj.filters +++ b/CrystalJohan.vcxproj.filters @@ -54,6 +54,9 @@ Source Files + + Source Files + @@ -98,6 +101,9 @@ Header Files + + Header Files + diff --git a/OpenAL.cpp b/OpenAL.cpp new file mode 100644 index 0000000..36073c9 --- /dev/null +++ b/OpenAL.cpp @@ -0,0 +1,161 @@ +#include "OpenAL.h" +#include +#include +#include +#include +#include + +int OpenAL::endWithError(char* msg, int error = 0) +{ + //Display error message in console + std::cout << msg << "\n"; + system("PAUSE"); + return error; +} + +OpenAL::OpenAL() +{ + Test(); + +} + +OpenAL::~OpenAL() +{ +} + +boolean OpenAL::Test() +{ + //Loading of the WAVE file + FILE *fp = NULL; //Create FILE pointer for the WAVE file + fp = fopen("WAVE/Sound.wav", "rb"); //Open the WAVE file + if (!fp) return endWithError("Failed to open file"); //Could not open file + + //Variables to store info about the WAVE file (all of them is not needed for OpenAL) + char type[4]; + DWORD size, chunkSize; + short formatType, channels; + DWORD sampleRate, avgBytesPerSec; + short bytesPerSample, bitsPerSample; + DWORD dataSize; + + //Check that the WAVE file is OK + fread(type, sizeof(char), 4, fp); //Reads the first bytes in the file + if (type[0] != 'R' || type[1] != 'I' || type[2] != 'F' || type[3] != 'F') //Should be "RIFF" + return endWithError("No RIFF"); //Not RIFF + + fread(&size, sizeof(DWORD), 1, fp); //Continue to read the file + fread(type, sizeof(char), 4, fp); //Continue to read the file + if (type[0] != 'W' || type[1] != 'A' || type[2] != 'V' || type[3] != 'E') //This part should be "WAVE" + return endWithError("not WAVE"); //Not WAVE + + fread(type, sizeof(char), 4, fp); //Continue to read the file + if (type[0] != 'f' || type[1] != 'm' || type[2] != 't' || type[3] != ' ') //This part should be "fmt " + return endWithError("not fmt "); //Not fmt + + //Now we know that the file is a acceptable WAVE file + //Info about the WAVE data is now read and stored + fread(&chunkSize, sizeof(DWORD), 1, fp); + fread(&formatType, sizeof(short), 1, fp); + fread(&channels, sizeof(short), 1, fp); + fread(&sampleRate, sizeof(DWORD), 1, fp); + fread(&avgBytesPerSec, sizeof(DWORD), 1, fp); + fread(&bytesPerSample, sizeof(short), 1, fp); + fread(&bitsPerSample, sizeof(short), 1, fp); + + fread(type, sizeof(char), 4, fp); + if (type[0] != 'd' || type[1] != 'a' || type[2] != 't' || type[3] != 'a') //This part should be "data" + return endWithError("Missing DATA"); //not data + + fread(&dataSize, sizeof(DWORD), 1, fp); //The size of the sound data is read + + //Display the info about the WAVE file + std::cout << "Chunk Size: " << chunkSize << "\n"; + std::cout << "Format Type: " << formatType << "\n"; + std::cout << "Channels: " << channels << "\n"; + std::cout << "Sample Rate: " << sampleRate << "\n"; + std::cout << "Average Bytes Per Second: " << avgBytesPerSec << "\n"; + std::cout << "Bytes Per Sample: " << bytesPerSample << "\n"; + std::cout << "Bits Per Sample: " << bitsPerSample << "\n"; + std::cout << "Data Size: " << dataSize << "\n"; + + unsigned char* buf = new unsigned char[dataSize]; //Allocate memory for the sound data + std::cout << fread(buf, sizeof(BYTE), dataSize, fp) << " bytes loaded\n"; //Read the sound data and display the + //number of bytes loaded. + //Should be the same as the Data Size if OK + + + //Now OpenAL needs to be initialized + ALCdevice *device; //Create an OpenAL Device + ALCcontext *context; //And an OpenAL Context + device = alcOpenDevice(NULL); //Open the device + if (!device) return endWithError("no sound device"); //Error during device oening + context = alcCreateContext(device, NULL); //Give the device a context + alcMakeContextCurrent(context); //Make the context the current + if (!context) return endWithError("no sound context"); //Error during context handeling + + ALuint source; //Is the name of source (where the sound come from) + ALuint buffer; //Stores the sound data + ALuint frequency = sampleRate;; //The Sample Rate of the WAVE file + ALenum format = 0; //The audio format (bits per sample, number of channels) + + alGenBuffers(1, &buffer); //Generate one OpenAL Buffer and link to "buffer" + alGenSources(1, &source); //Generate one OpenAL Source and link to "source" + if (alGetError() != AL_NO_ERROR) return endWithError("Error GenSource"); //Error during buffer/source generation + + //Figure out the format of the WAVE file + if (bitsPerSample == 8) + { + if (channels == 1) + format = AL_FORMAT_MONO8; + else if (channels == 2) + format = AL_FORMAT_STEREO8; + } + else if (bitsPerSample == 16) + { + if (channels == 1) + format = AL_FORMAT_MONO16; + else if (channels == 2) + format = AL_FORMAT_STEREO16; + } + if (!format) return endWithError("Wrong BitPerSample"); //Not valid format + + alBufferData(buffer, format, buf, dataSize, frequency); //Store the sound data in the OpenAL Buffer + if (alGetError() != AL_NO_ERROR) + return endWithError("Error loading ALBuffer"); //Error during buffer loading + + //Sound setting variables + ALfloat SourcePos[] = { 0.0, 0.0, 0.0 }; //Position of the source sound + ALfloat SourceVel[] = { 0.0, 0.0, 0.0 }; //Velocity of the source sound + ALfloat ListenerPos[] = { 0.0, 0.0, 0.0 }; //Position of the listener + ALfloat ListenerVel[] = { 0.0, 0.0, 0.0 }; //Velocity of the listener + ALfloat ListenerOri[] = { 0.0, 0.0, -1.0, 0.0, 1.0, 0.0 }; //Orientation of the listener + //First direction vector, then vector pointing up) + //Listener + alListenerfv(AL_POSITION, ListenerPos); //Set position of the listener + alListenerfv(AL_VELOCITY, ListenerVel); //Set velocity of the listener + alListenerfv(AL_ORIENTATION, ListenerOri); //Set orientation of the listener + + //Source + alSourcei(source, AL_BUFFER, buffer); //Link the buffer to the source + alSourcef(source, AL_PITCH, 1.0f); //Set the pitch of the source + alSourcef(source, AL_GAIN, 1.0f); //Set the gain of the source + alSourcefv(source, AL_POSITION, SourcePos); //Set the position of the source + alSourcefv(source, AL_VELOCITY, SourceVel); //Set the velocity of the source + alSourcei(source, AL_LOOPING, AL_FALSE); //Set if source is looping sound + + //PLAY + alSourcePlay(source); //Play the sound buffer linked to the source + if (alGetError() != AL_NO_ERROR) return endWithError("Error playing sound"); //Error when playing sound + system("PAUSE"); //Pause to let the sound play + + //Clean-up + fclose(fp); //Close the WAVE file + delete[] buf; //Delete the sound data buffer + alDeleteSources(1, &source); //Delete the OpenAL Source + alDeleteBuffers(1, &buffer); //Delete the OpenAL Buffer + alcMakeContextCurrent(NULL); //Make no context current + alcDestroyContext(context); //Destroy the OpenAL Context + alcCloseDevice(device); //Close the OpenAL Device + + return EXIT_SUCCESS; +} \ No newline at end of file diff --git a/OpenAL.h b/OpenAL.h new file mode 100644 index 0000000..fdf32ae --- /dev/null +++ b/OpenAL.h @@ -0,0 +1,10 @@ +#pragma once +class OpenAL +{ +public: + int endWithError(char* msg, int error = 0); + OpenAL(); + ~OpenAL(); + boolean Test(); + +}; diff --git a/WAVE/Sound.wav b/WAVE/Sound.wav new file mode 100644 index 0000000000000000000000000000000000000000..74ccfd2bec31c8f33aa6ceac01b964ac3ba46b9d GIT binary patch literal 24685 zcmW)|X_GD2btT6B<}VK0;V+JGI6^H&TT-_MYiiAu0C64wJiK|RSM#kq=RD^*Cr{3E z=ACcN^=1H%06`E0MM^DEq{XI0N>oeHY7K2iI2>Vz{i(yh!0X}yFJ8T>doxe&v-jF- zuf0#b`T5U$=5Xf|pSbQDT)pZLTl{ssQ~$y=ZJ_|L!i#DDdPgI#s^6}%_t z{ntPD<&Tbj`X3j+`r?QGC6)7=cYpBXKY!)Zx1IO?zgK?Y?$7*;-MR5|zw`P3?&o(G z&%S=|_g}eX{&WB5{_#(y_0j*d6@FiM^}nItb&2!ax613Ed;Kdv`1U{j!>@(^`A7M$ zf9L9dzPWer8~^#QgrB)5#y|QGKYX|P)F1uFgXz0x)94lb`y_hbIe2ZzpXt{Iul+Qg ztZ%%b#{R2nbJ*$q{LlXC|L{{^K7J{D>SuoCmw)4}AN?0~d+<}Q{6GKvy}iNsXMf@+ zzWGu5*MGkEwI6<%^S^2C{Tcn~O8S@82Y>vTpW6P+Z;d+jxsK>qLl_iy;D_?<6oU3~EE-+e9ky)Sy#e)pH(`wu%t^P%|P|DyDddHKVaXP2M< zA3w*xQGVqgnxkJ3ed%j|{r#8oI*q?|dcClJ)+o1s<6r*DYe#mxe169FcWrU+R}Y&% zUhMae|LKG2{a^c)(X~(ATK`Dfx#dOv-+uR#zy7(?7mvR*|GV+l&0o6nqZe=e$bI-9 zXRj^1JO9g1{lp*r`O)1k{$%ju@A1z(vVZbtUQvGYvws@i`{HLm*Kz7MzjWi`+ka_) z@t3bZ{8u+q=*>bJf@N%2QN{`(if=U%<`-S2$!AOGQR{?m7+ zZMb)1_dD6)vGd?BKk5$j`s)23|MTCU|H_U_rF`p_VOD)_~E~Q`-8tZ_m3pg>%8`h_q<~OECYb8 z{{8pE-}%)~-ucRR-Z#XzXXO#Z6*wa@oXzxC+mJAZZRb$=Qsc0OV<{Ed~>fJ zNX^S<)GMDH-TdZX{rIEh=npy{e*OJ--+KAY&KLfqxp7UHjvwB>`{t*mEH(Pw`uunM zA3U!|;)7rM@U%K`BXNOE&Z7)-zQ1gf2y`kttJDsnz{x{y5zxVE1x7IJ;nH_c(qpfN-JwHDFFn#rR z??;N7yUDk{(Z2cF-bdeiK6ve#mPHTl1xA1LrO_&ays{QPhJ#+P*Skf+ww`o^1g zzjP4In(AqEpYwZnj?~VzFZx&d>gDcEmNmtLhtofNHZZ5t!>y}kVDA3zza71$-#DCp z>-*n)`<*KJ=(|tH=8EoIyS*o0yuT`AUY(x2{nh2OZ_T$q-%&?Z*_*%gjr`GEy8Gtc zUH`3bKc!x1-g&+A=Jiy|5>+0pn!rs1r=bqr0>C<=5*Dw6rhx3m?SRHRH+G&ZeG!er|7l`VBL)yt2MHOPZN&IK5%Kc=^>+PdnO?R%hnzez}~SR-+wx za`oQ3XY1MM=D`8G$fe|J4F~bPt=F~u9{Q$0FhS z7J2lf2{ZZD-NWwD_MIC>?gURixSDwJ;&N5VH@>vpf9TAu*B%C^(`C&pargBDQ-1T7 z^W<%RuQOj*^86{?-;SpfkJvo2-PF2$yE7K{u7BaKK=P&uC?h1#ysDcF5AlZ@qIK zZFT9g@(FP%_vOx=TQ}bL!WXXXj-xE({TTi}ycx@5S2}{=we%&bWO1?1DKj+~?W1ay?%#a# z=G}v!nXitQQPDPa;aggK{POE>oj$#2$QhN zy1sZ)hW2cIVs!7BUL*=Z9NU!nbsN}PmX}o#cW;00Q1*G4U!Je1!^$$XEdTWB)3+X< z6~Urz3*V1IG1uGIHT(i;qSdxx4AJ%0D2t2xt-?h6BVY)>xVx@6j2LsC?2eKv)^ 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 Hz + */ +#define ALC_FREQUENCY 0x1007 + +/** + * followed by Hz + */ +#define ALC_REFRESH 0x1008 + +/** + * followed by AL_TRUE, AL_FALSE + */ +#define ALC_SYNC 0x1009 + +/** + * followed by Num of requested Mono (3D) Sources + */ +#define ALC_MONO_SOURCES 0x1010 + +/** + * followed by Num of requested Stereo Sources + */ +#define ALC_STEREO_SOURCES 0x1011 + +/** + * errors + */ + +/** + * No error + */ +#define ALC_NO_ERROR ALC_FALSE + +/** + * No device + */ +#define ALC_INVALID_DEVICE 0xA001 + +/** + * invalid context ID + */ +#define ALC_INVALID_CONTEXT 0xA002 + +/** + * bad enum + */ +#define ALC_INVALID_ENUM 0xA003 + +/** + * bad value + */ +#define ALC_INVALID_VALUE 0xA004 + +/** + * Out of memory. + */ +#define ALC_OUT_OF_MEMORY 0xA005 + + +/** + * The Specifier string for default device + */ +#define ALC_DEFAULT_DEVICE_SPECIFIER 0x1004 +#define ALC_DEVICE_SPECIFIER 0x1005 +#define ALC_EXTENSIONS 0x1006 + +#define ALC_MAJOR_VERSION 0x1000 +#define ALC_MINOR_VERSION 0x1001 + +#define ALC_ATTRIBUTES_SIZE 0x1002 +#define ALC_ALL_ATTRIBUTES 0x1003 + +/** + * ALC_ENUMERATE_ALL_EXT enums + */ +#define ALC_DEFAULT_ALL_DEVICES_SPECIFIER 0x1012 +#define ALC_ALL_DEVICES_SPECIFIER 0x1013 + +/** + * Capture extension + */ +#define ALC_CAPTURE_DEVICE_SPECIFIER 0x310 +#define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER 0x311 +#define ALC_CAPTURE_SAMPLES 0x312 + + +/* + * Context Management + */ +ALC_API ALCcontext * ALC_APIENTRY alcCreateContext( ALCdevice *device, const ALCint* attrlist ); + +ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent( ALCcontext *context ); + +ALC_API void ALC_APIENTRY alcProcessContext( ALCcontext *context ); + +ALC_API void ALC_APIENTRY alcSuspendContext( ALCcontext *context ); + +ALC_API void ALC_APIENTRY alcDestroyContext( ALCcontext *context ); + +ALC_API ALCcontext * ALC_APIENTRY alcGetCurrentContext( void ); + +ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice( ALCcontext *context ); + + +/* + * Device Management + */ +ALC_API ALCdevice * ALC_APIENTRY alcOpenDevice( const ALCchar *devicename ); + +ALC_API ALCboolean ALC_APIENTRY alcCloseDevice( ALCdevice *device ); + + +/* + * Error support. + * Obtain the most recent Context error + */ +ALC_API ALCenum ALC_APIENTRY alcGetError( ALCdevice *device ); + + +/* + * Extension support. + * Query for the presence of an extension, and obtain any appropriate + * function pointers and enum values. + */ +ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent( ALCdevice *device, const ALCchar *extname ); + +ALC_API void * ALC_APIENTRY alcGetProcAddress( ALCdevice *device, const ALCchar *funcname ); + +ALC_API ALCenum ALC_APIENTRY alcGetEnumValue( ALCdevice *device, const ALCchar *enumname ); + + +/* + * Query functions + */ +ALC_API const ALCchar * ALC_APIENTRY alcGetString( ALCdevice *device, ALCenum param ); + +ALC_API void ALC_APIENTRY alcGetIntegerv( ALCdevice *device, ALCenum param, ALCsizei size, ALCint *data ); + + +/* + * Capture functions + */ +ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice( const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize ); + +ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice( ALCdevice *device ); + +ALC_API void ALC_APIENTRY alcCaptureStart( ALCdevice *device ); + +ALC_API void ALC_APIENTRY alcCaptureStop( ALCdevice *device ); + +ALC_API void ALC_APIENTRY alcCaptureSamples( ALCdevice *device, ALCvoid *buffer, ALCsizei samples ); + +/* + * Pointer-to-function types, useful for dynamically getting ALC entry points. + */ +typedef ALCcontext * (ALC_APIENTRY *LPALCCREATECONTEXT) (ALCdevice *device, const ALCint *attrlist); +typedef ALCboolean (ALC_APIENTRY *LPALCMAKECONTEXTCURRENT)( ALCcontext *context ); +typedef void (ALC_APIENTRY *LPALCPROCESSCONTEXT)( ALCcontext *context ); +typedef void (ALC_APIENTRY *LPALCSUSPENDCONTEXT)( ALCcontext *context ); +typedef void (ALC_APIENTRY *LPALCDESTROYCONTEXT)( ALCcontext *context ); +typedef ALCcontext * (ALC_APIENTRY *LPALCGETCURRENTCONTEXT)( void ); +typedef ALCdevice * (ALC_APIENTRY *LPALCGETCONTEXTSDEVICE)( ALCcontext *context ); +typedef ALCdevice * (ALC_APIENTRY *LPALCOPENDEVICE)( const ALCchar *devicename ); +typedef ALCboolean (ALC_APIENTRY *LPALCCLOSEDEVICE)( ALCdevice *device ); +typedef ALCenum (ALC_APIENTRY *LPALCGETERROR)( ALCdevice *device ); +typedef ALCboolean (ALC_APIENTRY *LPALCISEXTENSIONPRESENT)( ALCdevice *device, const ALCchar *extname ); +typedef void * (ALC_APIENTRY *LPALCGETPROCADDRESS)(ALCdevice *device, const ALCchar *funcname ); +typedef ALCenum (ALC_APIENTRY *LPALCGETENUMVALUE)(ALCdevice *device, const ALCchar *enumname ); +typedef const ALCchar* (ALC_APIENTRY *LPALCGETSTRING)( ALCdevice *device, ALCenum param ); +typedef void (ALC_APIENTRY *LPALCGETINTEGERV)( ALCdevice *device, ALCenum param, ALCsizei size, ALCint *dest ); +typedef ALCdevice * (ALC_APIENTRY *LPALCCAPTUREOPENDEVICE)( const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize ); +typedef ALCboolean (ALC_APIENTRY *LPALCCAPTURECLOSEDEVICE)( ALCdevice *device ); +typedef void (ALC_APIENTRY *LPALCCAPTURESTART)( ALCdevice *device ); +typedef void (ALC_APIENTRY *LPALCCAPTURESTOP)( ALCdevice *device ); +typedef void (ALC_APIENTRY *LPALCCAPTURESAMPLES)( ALCdevice *device, ALCvoid *buffer, ALCsizei samples ); + +#if defined(TARGET_OS_MAC) && TARGET_OS_MAC + #pragma export off +#endif + +#if defined(__cplusplus) +} +#endif + +#endif /* AL_ALC_H */ diff --git a/openAL/include/efx-creative.h b/openAL/include/efx-creative.h new file mode 100644 index 0000000..4ea9da6 --- /dev/null +++ b/openAL/include/efx-creative.h @@ -0,0 +1,151 @@ +#ifndef __efxcreative_h_ +#define __efxcreative_h_ + +/** + * efx-creative.h - Environmental Audio Extensions + * for OpenAL Effects Extension. + * + */ +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * Effect object definitions to be used with alEffect functions. + * + * Effect parameter value definitions, ranges, and defaults + * appear farther down in this file. + */ + +/* AL EAXReverb effect parameters. */ +#define AL_EAXREVERB_DENSITY 0x0001 +#define AL_EAXREVERB_DIFFUSION 0x0002 +#define AL_EAXREVERB_GAIN 0x0003 +#define AL_EAXREVERB_GAINHF 0x0004 +#define AL_EAXREVERB_GAINLF 0x0005 +#define AL_EAXREVERB_DECAY_TIME 0x0006 +#define AL_EAXREVERB_DECAY_HFRATIO 0x0007 +#define AL_EAXREVERB_DECAY_LFRATIO 0x0008 +#define AL_EAXREVERB_REFLECTIONS_GAIN 0x0009 +#define AL_EAXREVERB_REFLECTIONS_DELAY 0x000A +#define AL_EAXREVERB_REFLECTIONS_PAN 0x000B +#define AL_EAXREVERB_LATE_REVERB_GAIN 0x000C +#define AL_EAXREVERB_LATE_REVERB_DELAY 0x000D +#define AL_EAXREVERB_LATE_REVERB_PAN 0x000E +#define AL_EAXREVERB_ECHO_TIME 0x000F +#define AL_EAXREVERB_ECHO_DEPTH 0x0010 +#define AL_EAXREVERB_MODULATION_TIME 0x0011 +#define AL_EAXREVERB_MODULATION_DEPTH 0x0012 +#define AL_EAXREVERB_AIR_ABSORPTION_GAINHF 0x0013 +#define AL_EAXREVERB_HFREFERENCE 0x0014 +#define AL_EAXREVERB_LFREFERENCE 0x0015 +#define AL_EAXREVERB_ROOM_ROLLOFF_FACTOR 0x0016 +#define AL_EAXREVERB_DECAY_HFLIMIT 0x0017 + +/* Effect type definitions to be used with AL_EFFECT_TYPE. */ +#define AL_EFFECT_EAXREVERB 0x8000 + + + + /********************************************************** + * Effect parameter structures, value definitions, ranges and defaults. + */ + +/** + * AL reverb effect parameter ranges and defaults + */ +#define AL_EAXREVERB_MIN_DENSITY 0.0f +#define AL_EAXREVERB_MAX_DENSITY 1.0f +#define AL_EAXREVERB_DEFAULT_DENSITY 1.0f + +#define AL_EAXREVERB_MIN_DIFFUSION 0.0f +#define AL_EAXREVERB_MAX_DIFFUSION 1.0f +#define AL_EAXREVERB_DEFAULT_DIFFUSION 1.0f + +#define AL_EAXREVERB_MIN_GAIN 0.0f +#define AL_EAXREVERB_MAX_GAIN 1.0f +#define AL_EAXREVERB_DEFAULT_GAIN 0.32f + +#define AL_EAXREVERB_MIN_GAINHF 0.0f +#define AL_EAXREVERB_MAX_GAINHF 1.0f +#define AL_EAXREVERB_DEFAULT_GAINHF 0.89f + +#define AL_EAXREVERB_MIN_GAINLF 0.0f +#define AL_EAXREVERB_MAX_GAINLF 1.0f +#define AL_EAXREVERB_DEFAULT_GAINLF 1.0f + +#define AL_EAXREVERB_MIN_DECAY_TIME 0.1f +#define AL_EAXREVERB_MAX_DECAY_TIME 20.0f +#define AL_EAXREVERB_DEFAULT_DECAY_TIME 1.49f + +#define AL_EAXREVERB_MIN_DECAY_HFRATIO 0.1f +#define AL_EAXREVERB_MAX_DECAY_HFRATIO 2.0f +#define AL_EAXREVERB_DEFAULT_DECAY_HFRATIO 0.83f + +#define AL_EAXREVERB_MIN_DECAY_LFRATIO 0.1f +#define AL_EAXREVERB_MAX_DECAY_LFRATIO 2.0f +#define AL_EAXREVERB_DEFAULT_DECAY_LFRATIO 1.0f + +#define AL_EAXREVERB_MIN_REFLECTIONS_GAIN 0.0f +#define AL_EAXREVERB_MAX_REFLECTIONS_GAIN 3.16f +#define AL_EAXREVERB_DEFAULT_REFLECTIONS_GAIN 0.05f + +#define AL_EAXREVERB_MIN_REFLECTIONS_DELAY 0.0f +#define AL_EAXREVERB_MAX_REFLECTIONS_DELAY 0.3f +#define AL_EAXREVERB_DEFAULT_REFLECTIONS_DELAY 0.007f + +#define AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN {0.0f, 0.0f, 0.0f} + +#define AL_EAXREVERB_MIN_LATE_REVERB_GAIN 0.0f +#define AL_EAXREVERB_MAX_LATE_REVERB_GAIN 10.0f +#define AL_EAXREVERB_DEFAULT_LATE_REVERB_GAIN 1.26f + +#define AL_EAXREVERB_MIN_LATE_REVERB_DELAY 0.0f +#define AL_EAXREVERB_MAX_LATE_REVERB_DELAY 0.1f +#define AL_EAXREVERB_DEFAULT_LATE_REVERB_DELAY 0.011f + +#define AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN {0.0f, 0.0f, 0.0f} + +#define AL_EAXREVERB_MIN_ECHO_TIME 0.075f +#define AL_EAXREVERB_MAX_ECHO_TIME 0.25f +#define AL_EAXREVERB_DEFAULT_ECHO_TIME 0.25f + +#define AL_EAXREVERB_MIN_ECHO_DEPTH 0.0f +#define AL_EAXREVERB_MAX_ECHO_DEPTH 1.0f +#define AL_EAXREVERB_DEFAULT_ECHO_DEPTH 0.0f + +#define AL_EAXREVERB_MIN_MODULATION_TIME 0.04f +#define AL_EAXREVERB_MAX_MODULATION_TIME 4.0f +#define AL_EAXREVERB_DEFAULT_MODULATION_TIME 0.25f + +#define AL_EAXREVERB_MIN_MODULATION_DEPTH 0.0f +#define AL_EAXREVERB_MAX_MODULATION_DEPTH 1.0f +#define AL_EAXREVERB_DEFAULT_MODULATION_DEPTH 0.0f + +#define AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF 0.892f +#define AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF 1.0f +#define AL_EAXREVERB_DEFAULT_AIR_ABSORPTION_GAINHF 0.994f + +#define AL_EAXREVERB_MIN_HFREFERENCE 1000.0f +#define AL_EAXREVERB_MAX_HFREFERENCE 20000.0f +#define AL_EAXREVERB_DEFAULT_HFREFERENCE 5000.0f + +#define AL_EAXREVERB_MIN_LFREFERENCE 20.0f +#define AL_EAXREVERB_MAX_LFREFERENCE 1000.0f +#define AL_EAXREVERB_DEFAULT_LFREFERENCE 250.0f + +#define AL_EAXREVERB_MIN_ROOM_ROLLOFF_FACTOR 0.0f +#define AL_EAXREVERB_MAX_ROOM_ROLLOFF_FACTOR 10.0f +#define AL_EAXREVERB_DEFAULT_ROOM_ROLLOFF_FACTOR 0.0f + +#define AL_EAXREVERB_MIN_DECAY_HFLIMIT AL_FALSE +#define AL_EAXREVERB_MAX_DECAY_HFLIMIT AL_TRUE +#define AL_EAXREVERB_DEFAULT_DECAY_HFLIMIT AL_TRUE + + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* __efxcreative_h_ */ diff --git a/openAL/include/efx.h b/openAL/include/efx.h new file mode 100644 index 0000000..fece160 --- /dev/null +++ b/openAL/include/efx.h @@ -0,0 +1,737 @@ +#ifndef __efx_h_ +#define __efx_h_ + + +#ifdef __cplusplus +extern "C" { +#endif + +#define ALC_EXT_EFX_NAME "ALC_EXT_EFX" + +/** + * Context definitions to be used with alcCreateContext. + * These values must be unique and not conflict with other + * al context values. + */ +#define ALC_EFX_MAJOR_VERSION 0x20001 +#define ALC_EFX_MINOR_VERSION 0x20002 +#define ALC_MAX_AUXILIARY_SENDS 0x20003 + + + + +/** + * Listener definitions to be used with alListener functions. + * These values must be unique and not conflict with other + * al listener values. + */ +#define AL_METERS_PER_UNIT 0x20004 + + + + +/** + * Source definitions to be used with alSource functions. + * These values must be unique and not conflict with other + * al source values. + */ +#define AL_DIRECT_FILTER 0x20005 +#define AL_AUXILIARY_SEND_FILTER 0x20006 +#define AL_AIR_ABSORPTION_FACTOR 0x20007 +#define AL_ROOM_ROLLOFF_FACTOR 0x20008 +#define AL_CONE_OUTER_GAINHF 0x20009 +#define AL_DIRECT_FILTER_GAINHF_AUTO 0x2000A +#define AL_AUXILIARY_SEND_FILTER_GAIN_AUTO 0x2000B +#define AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO 0x2000C + + + + +/** + * Effect object definitions to be used with alEffect functions. + * + * Effect parameter value definitions, ranges, and defaults + * appear farther down in this file. + */ + +/* Reverb Parameters */ +#define AL_REVERB_DENSITY 0x0001 +#define AL_REVERB_DIFFUSION 0x0002 +#define AL_REVERB_GAIN 0x0003 +#define AL_REVERB_GAINHF 0x0004 +#define AL_REVERB_DECAY_TIME 0x0005 +#define AL_REVERB_DECAY_HFRATIO 0x0006 +#define AL_REVERB_REFLECTIONS_GAIN 0x0007 +#define AL_REVERB_REFLECTIONS_DELAY 0x0008 +#define AL_REVERB_LATE_REVERB_GAIN 0x0009 +#define AL_REVERB_LATE_REVERB_DELAY 0x000A +#define AL_REVERB_AIR_ABSORPTION_GAINHF 0x000B +#define AL_REVERB_ROOM_ROLLOFF_FACTOR 0x000C +#define AL_REVERB_DECAY_HFLIMIT 0x000D + +/* Chorus Parameters */ +#define AL_CHORUS_WAVEFORM 0x0001 +#define AL_CHORUS_PHASE 0x0002 +#define AL_CHORUS_RATE 0x0003 +#define AL_CHORUS_DEPTH 0x0004 +#define AL_CHORUS_FEEDBACK 0x0005 +#define AL_CHORUS_DELAY 0x0006 + +/* Distortion Parameters */ +#define AL_DISTORTION_EDGE 0x0001 +#define AL_DISTORTION_GAIN 0x0002 +#define AL_DISTORTION_LOWPASS_CUTOFF 0x0003 +#define AL_DISTORTION_EQCENTER 0x0004 +#define AL_DISTORTION_EQBANDWIDTH 0x0005 + +/* Echo Parameters */ +#define AL_ECHO_DELAY 0x0001 +#define AL_ECHO_LRDELAY 0x0002 +#define AL_ECHO_DAMPING 0x0003 +#define AL_ECHO_FEEDBACK 0x0004 +#define AL_ECHO_SPREAD 0x0005 + +/* Flanger Parameters */ +#define AL_FLANGER_WAVEFORM 0x0001 +#define AL_FLANGER_PHASE 0x0002 +#define AL_FLANGER_RATE 0x0003 +#define AL_FLANGER_DEPTH 0x0004 +#define AL_FLANGER_FEEDBACK 0x0005 +#define AL_FLANGER_DELAY 0x0006 + +/* Frequencyshifter Parameters */ +#define AL_FREQUENCY_SHIFTER_FREQUENCY 0x0001 +#define AL_FREQUENCY_SHIFTER_LEFT_DIRECTION 0x0002 +#define AL_FREQUENCY_SHIFTER_RIGHT_DIRECTION 0x0003 + +/* Vocalmorpher Parameters */ +#define AL_VOCAL_MORPHER_PHONEMEA 0x0001 +#define AL_VOCAL_MORPHER_PHONEMEA_COARSE_TUNING 0x0002 +#define AL_VOCAL_MORPHER_PHONEMEB 0x0003 +#define AL_VOCAL_MORPHER_PHONEMEB_COARSE_TUNING 0x0004 +#define AL_VOCAL_MORPHER_WAVEFORM 0x0005 +#define AL_VOCAL_MORPHER_RATE 0x0006 + +/* Pitchshifter Parameters */ +#define AL_PITCH_SHIFTER_COARSE_TUNE 0x0001 +#define AL_PITCH_SHIFTER_FINE_TUNE 0x0002 + +/* Ringmodulator Parameters */ +#define AL_RING_MODULATOR_FREQUENCY 0x0001 +#define AL_RING_MODULATOR_HIGHPASS_CUTOFF 0x0002 +#define AL_RING_MODULATOR_WAVEFORM 0x0003 + +/* Autowah Parameters */ +#define AL_AUTOWAH_ATTACK_TIME 0x0001 +#define AL_AUTOWAH_RELEASE_TIME 0x0002 +#define AL_AUTOWAH_RESONANCE 0x0003 +#define AL_AUTOWAH_PEAK_GAIN 0x0004 + +/* Compressor Parameters */ +#define AL_COMPRESSOR_ONOFF 0x0001 + +/* Equalizer Parameters */ +#define AL_EQUALIZER_LOW_GAIN 0x0001 +#define AL_EQUALIZER_LOW_CUTOFF 0x0002 +#define AL_EQUALIZER_MID1_GAIN 0x0003 +#define AL_EQUALIZER_MID1_CENTER 0x0004 +#define AL_EQUALIZER_MID1_WIDTH 0x0005 +#define AL_EQUALIZER_MID2_GAIN 0x0006 +#define AL_EQUALIZER_MID2_CENTER 0x0007 +#define AL_EQUALIZER_MID2_WIDTH 0x0008 +#define AL_EQUALIZER_HIGH_GAIN 0x0009 +#define AL_EQUALIZER_HIGH_CUTOFF 0x000A + +/* Effect type */ +#define AL_EFFECT_FIRST_PARAMETER 0x0000 +#define AL_EFFECT_LAST_PARAMETER 0x8000 +#define AL_EFFECT_TYPE 0x8001 + +/* Effect type definitions to be used with AL_EFFECT_TYPE. */ +#define AL_EFFECT_NULL 0x0000 /* Can also be used as an Effect Object ID */ +#define AL_EFFECT_REVERB 0x0001 +#define AL_EFFECT_CHORUS 0x0002 +#define AL_EFFECT_DISTORTION 0x0003 +#define AL_EFFECT_ECHO 0x0004 +#define AL_EFFECT_FLANGER 0x0005 +#define AL_EFFECT_FREQUENCY_SHIFTER 0x0006 +#define AL_EFFECT_VOCAL_MORPHER 0x0007 +#define AL_EFFECT_PITCH_SHIFTER 0x0008 +#define AL_EFFECT_RING_MODULATOR 0x0009 +#define AL_EFFECT_AUTOWAH 0x000A +#define AL_EFFECT_COMPRESSOR 0x000B +#define AL_EFFECT_EQUALIZER 0x000C + +/** + * Auxiliary Slot object definitions to be used with alAuxiliaryEffectSlot functions. + */ +#define AL_EFFECTSLOT_EFFECT 0x0001 +#define AL_EFFECTSLOT_GAIN 0x0002 +#define AL_EFFECTSLOT_AUXILIARY_SEND_AUTO 0x0003 + +/** + * Value to be used as an Auxiliary Slot ID to disable a source send.. + */ +#define AL_EFFECTSLOT_NULL 0x0000 + + + +/** + * Filter object definitions to be used with alFilter functions. + */ + +/* Lowpass parameters. */ +#define AL_LOWPASS_GAIN 0x0001 +#define AL_LOWPASS_GAINHF 0x0002 + +/* Highpass Parameters */ +#define AL_HIGHPASS_GAIN 0x0001 +#define AL_HIGHPASS_GAINLF 0x0002 + +/* Bandpass Parameters */ +#define AL_BANDPASS_GAIN 0x0001 +#define AL_BANDPASS_GAINLF 0x0002 +#define AL_BANDPASS_GAINHF 0x0003 + +/* Filter type */ +#define AL_FILTER_FIRST_PARAMETER 0x0000 +#define AL_FILTER_LAST_PARAMETER 0x8000 +#define AL_FILTER_TYPE 0x8001 + +/* Filter type definitions to be used with AL_FILTER_TYPE. */ +#define AL_FILTER_NULL 0x0000 /* Can also be used as a Filter Object ID */ +#define AL_FILTER_LOWPASS 0x0001 +#define AL_FILTER_HIGHPASS 0x0002 +#define AL_FILTER_BANDPASS 0x0003 + + +/** + * Effect object functions. + */ + +/* Create Effect objects. */ +typedef void (__cdecl *LPALGENEFFECTS)( ALsizei n, ALuint* effects ); + +/* Delete Effect objects. */ +typedef void (__cdecl *LPALDELETEEFFECTS)( ALsizei n, ALuint* effects ); + +/* Verify a handle is a valid Effect. */ +typedef ALboolean (__cdecl *LPALISEFFECT)( ALuint eid ); + +/* Set an integer parameter for an Effect object. */ +typedef void (__cdecl *LPALEFFECTI)( ALuint eid, ALenum param, ALint value); +typedef void (__cdecl *LPALEFFECTIV)( ALuint eid, ALenum param, ALint* values ); + +/* Set a floating point parameter for an Effect object. */ +typedef void (__cdecl *LPALEFFECTF)( ALuint eid, ALenum param, ALfloat value); +typedef void (__cdecl *LPALEFFECTFV)( ALuint eid, ALenum param, ALfloat* values ); + +/* Get an integer parameter for an Effect object. */ +typedef void (__cdecl *LPALGETEFFECTI)( ALuint eid, ALenum pname, ALint* value ); +typedef void (__cdecl *LPALGETEFFECTIV)( ALuint eid, ALenum pname, ALint* values ); + +/* Get a floating point parameter for an Effect object. */ +typedef void (__cdecl *LPALGETEFFECTF)( ALuint eid, ALenum pname, ALfloat* value ); +typedef void (__cdecl *LPALGETEFFECTFV)( ALuint eid, ALenum pname, ALfloat* values ); + + +/** + * Filter object functions + */ + +/* Create Filter objects. */ +typedef void (__cdecl *LPALGENFILTERS)( ALsizei n, ALuint* filters ); + +/* Delete Filter objects. */ +typedef void (__cdecl *LPALDELETEFILTERS)( ALsizei n, ALuint* filters ); + +/* Verify a handle is a valid Filter. */ +typedef ALboolean (__cdecl *LPALISFILTER)( ALuint fid ); + +/* Set an integer parameter for a Filter object. */ +typedef void (__cdecl *LPALFILTERI)( ALuint fid, ALenum param, ALint value ); +typedef void (__cdecl *LPALFILTERIV)( ALuint fid, ALenum param, ALint* values ); + +/* Set a floating point parameter for an Filter object. */ +typedef void (__cdecl *LPALFILTERF)( ALuint fid, ALenum param, ALfloat value); +typedef void (__cdecl *LPALFILTERFV)( ALuint fid, ALenum param, ALfloat* values ); + +/* Get an integer parameter for a Filter object. */ +typedef void (__cdecl *LPALGETFILTERI)( ALuint fid, ALenum pname, ALint* value ); +typedef void (__cdecl *LPALGETFILTERIV)( ALuint fid, ALenum pname, ALint* values ); + +/* Get a floating point parameter for a Filter object. */ +typedef void (__cdecl *LPALGETFILTERF)( ALuint fid, ALenum pname, ALfloat* value ); +typedef void (__cdecl *LPALGETFILTERFV)( ALuint fid, ALenum pname, ALfloat* values ); + + +/** + * Auxiliary Slot object functions + */ + +/* Create Auxiliary Slot objects. */ +typedef void (__cdecl *LPALGENAUXILIARYEFFECTSLOTS)( ALsizei n, ALuint* slots ); + +/* Delete Auxiliary Slot objects. */ +typedef void (__cdecl *LPALDELETEAUXILIARYEFFECTSLOTS)( ALsizei n, ALuint* slots ); + +/* Verify a handle is a valid Auxiliary Slot. */ +typedef ALboolean (__cdecl *LPALISAUXILIARYEFFECTSLOT)( ALuint slot ); + +/* Set an integer parameter for a Auxiliary Slot object. */ +typedef void (__cdecl *LPALAUXILIARYEFFECTSLOTI)( ALuint asid, ALenum param, ALint value ); +typedef void (__cdecl *LPALAUXILIARYEFFECTSLOTIV)( ALuint asid, ALenum param, ALint* values ); + +/* Set a floating point parameter for an Auxiliary Slot object. */ +typedef void (__cdecl *LPALAUXILIARYEFFECTSLOTF)( ALuint asid, ALenum param, ALfloat value ); +typedef void (__cdecl *LPALAUXILIARYEFFECTSLOTFV)( ALuint asid, ALenum param, ALfloat* values ); + +/* Get an integer parameter for a Auxiliary Slot object. */ +typedef void (__cdecl *LPALGETAUXILIARYEFFECTSLOTI)( ALuint asid, ALenum pname, ALint* value ); +typedef void (__cdecl *LPALGETAUXILIARYEFFECTSLOTIV)( ALuint asid, ALenum pname, ALint* values ); + +/* Get a floating point parameter for a Auxiliary Slot object. */ +typedef void (__cdecl *LPALGETAUXILIARYEFFECTSLOTF)( ALuint asid, ALenum pname, ALfloat* value ); +typedef void (__cdecl *LPALGETAUXILIARYEFFECTSLOTFV)( ALuint asid, ALenum pname, ALfloat* values ); + + + + +/********************************************************** + * Filter ranges and defaults. + */ + +/** + * Lowpass filter + */ + +#define LOWPASS_MIN_GAIN 0.0f +#define LOWPASS_MAX_GAIN 1.0f +#define LOWPASS_DEFAULT_GAIN 1.0f + +#define LOWPASS_MIN_GAINHF 0.0f +#define LOWPASS_MAX_GAINHF 1.0f +#define LOWPASS_DEFAULT_GAINHF 1.0f + +/** + * Highpass filter + */ + +#define HIGHPASS_MIN_GAIN 0.0f +#define HIGHPASS_MAX_GAIN 1.0f +#define HIGHPASS_DEFAULT_GAIN 1.0f + +#define HIGHPASS_MIN_GAINLF 0.0f +#define HIGHPASS_MAX_GAINLF 1.0f +#define HIGHPASS_DEFAULT_GAINLF 1.0f + +/** + * Bandpass filter + */ + +#define BANDPASS_MIN_GAIN 0.0f +#define BANDPASS_MAX_GAIN 1.0f +#define BANDPASS_DEFAULT_GAIN 1.0f + +#define BANDPASS_MIN_GAINHF 0.0f +#define BANDPASS_MAX_GAINHF 1.0f +#define BANDPASS_DEFAULT_GAINHF 1.0f + +#define BANDPASS_MIN_GAINLF 0.0f +#define BANDPASS_MAX_GAINLF 1.0f +#define BANDPASS_DEFAULT_GAINLF 1.0f + + + + + /********************************************************** + * Effect parameter structures, value definitions, ranges and defaults. + */ + +/** + * AL reverb effect parameter ranges and defaults + */ +#define AL_REVERB_MIN_DENSITY 0.0f +#define AL_REVERB_MAX_DENSITY 1.0f +#define AL_REVERB_DEFAULT_DENSITY 1.0f + +#define AL_REVERB_MIN_DIFFUSION 0.0f +#define AL_REVERB_MAX_DIFFUSION 1.0f +#define AL_REVERB_DEFAULT_DIFFUSION 1.0f + +#define AL_REVERB_MIN_GAIN 0.0f +#define AL_REVERB_MAX_GAIN 1.0f +#define AL_REVERB_DEFAULT_GAIN 0.32f + +#define AL_REVERB_MIN_GAINHF 0.0f +#define AL_REVERB_MAX_GAINHF 1.0f +#define AL_REVERB_DEFAULT_GAINHF 0.89f + +#define AL_REVERB_MIN_DECAY_TIME 0.1f +#define AL_REVERB_MAX_DECAY_TIME 20.0f +#define AL_REVERB_DEFAULT_DECAY_TIME 1.49f + +#define AL_REVERB_MIN_DECAY_HFRATIO 0.1f +#define AL_REVERB_MAX_DECAY_HFRATIO 2.0f +#define AL_REVERB_DEFAULT_DECAY_HFRATIO 0.83f + +#define AL_REVERB_MIN_REFLECTIONS_GAIN 0.0f +#define AL_REVERB_MAX_REFLECTIONS_GAIN 3.16f +#define AL_REVERB_DEFAULT_REFLECTIONS_GAIN 0.05f + +#define AL_REVERB_MIN_REFLECTIONS_DELAY 0.0f +#define AL_REVERB_MAX_REFLECTIONS_DELAY 0.3f +#define AL_REVERB_DEFAULT_REFLECTIONS_DELAY 0.007f + +#define AL_REVERB_MIN_LATE_REVERB_GAIN 0.0f +#define AL_REVERB_MAX_LATE_REVERB_GAIN 10.0f +#define AL_REVERB_DEFAULT_LATE_REVERB_GAIN 1.26f + +#define AL_REVERB_MIN_LATE_REVERB_DELAY 0.0f +#define AL_REVERB_MAX_LATE_REVERB_DELAY 0.1f +#define AL_REVERB_DEFAULT_LATE_REVERB_DELAY 0.011f + +#define AL_REVERB_MIN_AIR_ABSORPTION_GAINHF 0.892f +#define AL_REVERB_MAX_AIR_ABSORPTION_GAINHF 1.0f +#define AL_REVERB_DEFAULT_AIR_ABSORPTION_GAINHF 0.994f + +#define AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR 0.0f +#define AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR 10.0f +#define AL_REVERB_DEFAULT_ROOM_ROLLOFF_FACTOR 0.0f + +#define AL_REVERB_MIN_DECAY_HFLIMIT AL_FALSE +#define AL_REVERB_MAX_DECAY_HFLIMIT AL_TRUE +#define AL_REVERB_DEFAULT_DECAY_HFLIMIT AL_TRUE + +/** + * AL chorus effect parameter ranges and defaults + */ +#define AL_CHORUS_MIN_WAVEFORM 0 +#define AL_CHORUS_MAX_WAVEFORM 1 +#define AL_CHORUS_DEFAULT_WAVEFORM 1 + +#define AL_CHORUS_WAVEFORM_SINUSOID 0 +#define AL_CHORUS_WAVEFORM_TRIANGLE 1 + +#define AL_CHORUS_MIN_PHASE (-180) +#define AL_CHORUS_MAX_PHASE 180 +#define AL_CHORUS_DEFAULT_PHASE 90 + +#define AL_CHORUS_MIN_RATE 0.0f +#define AL_CHORUS_MAX_RATE 10.0f +#define AL_CHORUS_DEFAULT_RATE 1.1f + +#define AL_CHORUS_MIN_DEPTH 0.0f +#define AL_CHORUS_MAX_DEPTH 1.0f +#define AL_CHORUS_DEFAULT_DEPTH 0.1f + +#define AL_CHORUS_MIN_FEEDBACK (-1.0f) +#define AL_CHORUS_MAX_FEEDBACK 1.0f +#define AL_CHORUS_DEFAULT_FEEDBACK 0.25f + +#define AL_CHORUS_MIN_DELAY 0.0f +#define AL_CHORUS_MAX_DELAY 0.016f +#define AL_CHORUS_DEFAULT_DELAY 0.016f + +/** + * AL distortion effect parameter ranges and defaults + */ +#define AL_DISTORTION_MIN_EDGE 0.0f +#define AL_DISTORTION_MAX_EDGE 1.0f +#define AL_DISTORTION_DEFAULT_EDGE 0.2f + +#define AL_DISTORTION_MIN_GAIN 0.01f +#define AL_DISTORTION_MAX_GAIN 1.0f +#define AL_DISTORTION_DEFAULT_GAIN 0.05f + +#define AL_DISTORTION_MIN_LOWPASS_CUTOFF 80.0f +#define AL_DISTORTION_MAX_LOWPASS_CUTOFF 24000.0f +#define AL_DISTORTION_DEFAULT_LOWPASS_CUTOFF 8000.0f + +#define AL_DISTORTION_MIN_EQCENTER 80.0f +#define AL_DISTORTION_MAX_EQCENTER 24000.0f +#define AL_DISTORTION_DEFAULT_EQCENTER 3600.0f + +#define AL_DISTORTION_MIN_EQBANDWIDTH 80.0f +#define AL_DISTORTION_MAX_EQBANDWIDTH 24000.0f +#define AL_DISTORTION_DEFAULT_EQBANDWIDTH 3600.0f + +/** + * AL echo effect parameter ranges and defaults + */ +#define AL_ECHO_MIN_DELAY 0.0f +#define AL_ECHO_MAX_DELAY 0.207f +#define AL_ECHO_DEFAULT_DELAY 0.1f + +#define AL_ECHO_MIN_LRDELAY 0.0f +#define AL_ECHO_MAX_LRDELAY 0.404f +#define AL_ECHO_DEFAULT_LRDELAY 0.1f + +#define AL_ECHO_MIN_DAMPING 0.0f +#define AL_ECHO_MAX_DAMPING 0.99f +#define AL_ECHO_DEFAULT_DAMPING 0.5f + +#define AL_ECHO_MIN_FEEDBACK 0.0f +#define AL_ECHO_MAX_FEEDBACK 1.0f +#define AL_ECHO_DEFAULT_FEEDBACK 0.5f + +#define AL_ECHO_MIN_SPREAD (-1.0f) +#define AL_ECHO_MAX_SPREAD 1.0f +#define AL_ECHO_DEFAULT_SPREAD (-1.0f) + +/** + * AL flanger effect parameter ranges and defaults + */ +#define AL_FLANGER_MIN_WAVEFORM 0 +#define AL_FLANGER_MAX_WAVEFORM 1 +#define AL_FLANGER_DEFAULT_WAVEFORM 1 + +#define AL_FLANGER_WAVEFORM_SINUSOID 0 +#define AL_FLANGER_WAVEFORM_TRIANGLE 1 + +#define AL_FLANGER_MIN_PHASE (-180) +#define AL_FLANGER_MAX_PHASE 180 +#define AL_FLANGER_DEFAULT_PHASE 0 + +#define AL_FLANGER_MIN_RATE 0.0f +#define AL_FLANGER_MAX_RATE 10.0f +#define AL_FLANGER_DEFAULT_RATE 0.27f + +#define AL_FLANGER_MIN_DEPTH 0.0f +#define AL_FLANGER_MAX_DEPTH 1.0f +#define AL_FLANGER_DEFAULT_DEPTH 1.0f + +#define AL_FLANGER_MIN_FEEDBACK (-1.0f) +#define AL_FLANGER_MAX_FEEDBACK 1.0f +#define AL_FLANGER_DEFAULT_FEEDBACK (-0.5f) + +#define AL_FLANGER_MIN_DELAY 0.0f +#define AL_FLANGER_MAX_DELAY 0.004f +#define AL_FLANGER_DEFAULT_DELAY 0.002f + +/** + * AL frequency shifter effect parameter ranges and defaults + */ +#define AL_FREQUENCY_SHIFTER_MIN_FREQUENCY 0.0f +#define AL_FREQUENCY_SHIFTER_MAX_FREQUENCY 24000.0f +#define AL_FREQUENCY_SHIFTER_DEFAULT_FREQUENCY 0.0f + +#define AL_FREQUENCY_SHIFTER_MIN_LEFT_DIRECTION 0 +#define AL_FREQUENCY_SHIFTER_MAX_LEFT_DIRECTION 2 +#define AL_FREQUENCY_SHIFTER_DEFAULT_LEFT_DIRECTION 0 + +#define AL_FREQUENCY_SHIFTER_MIN_RIGHT_DIRECTION 0 +#define AL_FREQUENCY_SHIFTER_MAX_RIGHT_DIRECTION 2 +#define AL_FREQUENCY_SHIFTER_DEFAULT_RIGHT_DIRECTION 0 + +#define AL_FREQUENCY_SHIFTER_DIRECTION_DOWN 0 +#define AL_FREQUENCY_SHIFTER_DIRECTION_UP 1 +#define AL_FREQUENCY_SHIFTER_DIRECTION_OFF 2 + +/** + * AL vocal morpher effect parameter ranges and defaults + */ +#define AL_VOCAL_MORPHER_MIN_PHONEMEA 0 +#define AL_VOCAL_MORPHER_MAX_PHONEMEA 29 +#define AL_VOCAL_MORPHER_DEFAULT_PHONEMEA 0 + +#define AL_VOCAL_MORPHER_MIN_PHONEMEA_COARSE_TUNING (-24) +#define AL_VOCAL_MORPHER_MAX_PHONEMEA_COARSE_TUNING 24 +#define AL_VOCAL_MORPHER_DEFAULT_PHONEMEA_COARSE_TUNING 0 + +#define AL_VOCAL_MORPHER_MIN_PHONEMEB 0 +#define AL_VOCAL_MORPHER_MAX_PHONEMEB 29 +#define AL_VOCAL_MORPHER_DEFAULT_PHONEMEB 10 + +#define AL_VOCAL_MORPHER_PHONEME_A 0 +#define AL_VOCAL_MORPHER_PHONEME_E 1 +#define AL_VOCAL_MORPHER_PHONEME_I 2 +#define AL_VOCAL_MORPHER_PHONEME_O 3 +#define AL_VOCAL_MORPHER_PHONEME_U 4 +#define AL_VOCAL_MORPHER_PHONEME_AA 5 +#define AL_VOCAL_MORPHER_PHONEME_AE 6 +#define AL_VOCAL_MORPHER_PHONEME_AH 7 +#define AL_VOCAL_MORPHER_PHONEME_AO 8 +#define AL_VOCAL_MORPHER_PHONEME_EH 9 +#define AL_VOCAL_MORPHER_PHONEME_ER 10 +#define AL_VOCAL_MORPHER_PHONEME_IH 11 +#define AL_VOCAL_MORPHER_PHONEME_IY 12 +#define AL_VOCAL_MORPHER_PHONEME_UH 13 +#define AL_VOCAL_MORPHER_PHONEME_UW 14 +#define AL_VOCAL_MORPHER_PHONEME_B 15 +#define AL_VOCAL_MORPHER_PHONEME_D 16 +#define AL_VOCAL_MORPHER_PHONEME_F 17 +#define AL_VOCAL_MORPHER_PHONEME_G 18 +#define AL_VOCAL_MORPHER_PHONEME_J 19 +#define AL_VOCAL_MORPHER_PHONEME_K 20 +#define AL_VOCAL_MORPHER_PHONEME_L 21 +#define AL_VOCAL_MORPHER_PHONEME_M 22 +#define AL_VOCAL_MORPHER_PHONEME_N 23 +#define AL_VOCAL_MORPHER_PHONEME_P 24 +#define AL_VOCAL_MORPHER_PHONEME_R 25 +#define AL_VOCAL_MORPHER_PHONEME_S 26 +#define AL_VOCAL_MORPHER_PHONEME_T 27 +#define AL_VOCAL_MORPHER_PHONEME_V 28 +#define AL_VOCAL_MORPHER_PHONEME_Z 29 + +#define AL_VOCAL_MORPHER_MIN_PHONEMEB_COARSE_TUNING (-24) +#define AL_VOCAL_MORPHER_MAX_PHONEMEB_COARSE_TUNING 24 +#define AL_VOCAL_MORPHER_DEFAULT_PHONEMEB_COARSE_TUNING 0 + +#define AL_VOCAL_MORPHER_MIN_WAVEFORM 0 +#define AL_VOCAL_MORPHER_MAX_WAVEFORM 2 +#define AL_VOCAL_MORPHER_DEFAULT_WAVEFORM 0 + +#define AL_VOCAL_MORPHER_WAVEFORM_SINUSOID 0 +#define AL_VOCAL_MORPHER_WAVEFORM_TRIANGLE 1 +#define AL_VOCAL_MORPHER_WAVEFORM_SAWTOOTH 2 + +#define AL_VOCAL_MORPHER_MIN_RATE 0.0f +#define AL_VOCAL_MORPHER_MAX_RATE 10.0f +#define AL_VOCAL_MORPHER_DEFAULT_RATE 1.41f + +/** + * AL pitch shifter effect parameter ranges and defaults + */ +#define AL_PITCH_SHIFTER_MIN_COARSE_TUNE (-12) +#define AL_PITCH_SHIFTER_MAX_COARSE_TUNE 12 +#define AL_PITCH_SHIFTER_DEFAULT_COARSE_TUNE 12 + +#define AL_PITCH_SHIFTER_MIN_FINE_TUNE (-50) +#define AL_PITCH_SHIFTER_MAX_FINE_TUNE 50 +#define AL_PITCH_SHIFTER_DEFAULT_FINE_TUNE 0 + +/** + * AL ring modulator effect parameter ranges and defaults + */ +#define AL_RING_MODULATOR_MIN_FREQUENCY 0.0f +#define AL_RING_MODULATOR_MAX_FREQUENCY 8000.0f +#define AL_RING_MODULATOR_DEFAULT_FREQUENCY 440.0f + +#define AL_RING_MODULATOR_MIN_HIGHPASS_CUTOFF 0.0f +#define AL_RING_MODULATOR_MAX_HIGHPASS_CUTOFF 24000.0f +#define AL_RING_MODULATOR_DEFAULT_HIGHPASS_CUTOFF 800.0f + +#define AL_RING_MODULATOR_MIN_WAVEFORM 0 +#define AL_RING_MODULATOR_MAX_WAVEFORM 2 +#define AL_RING_MODULATOR_DEFAULT_WAVEFORM 0 + +#define AL_RING_MODULATOR_SINUSOID 0 +#define AL_RING_MODULATOR_SAWTOOTH 1 +#define AL_RING_MODULATOR_SQUARE 2 + +/** + * AL autowah effect parameter ranges and defaults + */ +#define AL_AUTOWAH_MIN_ATTACK_TIME 0.0001f +#define AL_AUTOWAH_MAX_ATTACK_TIME 1.0f +#define AL_AUTOWAH_DEFAULT_ATTACK_TIME 0.06f + +#define AL_AUTOWAH_MIN_RELEASE_TIME 0.0001f +#define AL_AUTOWAH_MAX_RELEASE_TIME 1.0f +#define AL_AUTOWAH_DEFAULT_RELEASE_TIME 0.06f + +#define AL_AUTOWAH_MIN_RESONANCE 2.0f +#define AL_AUTOWAH_MAX_RESONANCE 1000.0f +#define AL_AUTOWAH_DEFAULT_RESONANCE 1000.0f + +#define AL_AUTOWAH_MIN_PEAK_GAIN 0.00003f +#define AL_AUTOWAH_MAX_PEAK_GAIN 31621.0f +#define AL_AUTOWAH_DEFAULT_PEAK_GAIN 11.22f + +/** + * AL compressor effect parameter ranges and defaults + */ +#define AL_COMPRESSOR_MIN_ONOFF 0 +#define AL_COMPRESSOR_MAX_ONOFF 1 +#define AL_COMPRESSOR_DEFAULT_ONOFF 1 + +/** + * AL equalizer effect parameter ranges and defaults + */ +#define AL_EQUALIZER_MIN_LOW_GAIN 0.126f +#define AL_EQUALIZER_MAX_LOW_GAIN 7.943f +#define AL_EQUALIZER_DEFAULT_LOW_GAIN 1.0f + +#define AL_EQUALIZER_MIN_LOW_CUTOFF 50.0f +#define AL_EQUALIZER_MAX_LOW_CUTOFF 800.0f +#define AL_EQUALIZER_DEFAULT_LOW_CUTOFF 200.0f + +#define AL_EQUALIZER_MIN_MID1_GAIN 0.126f +#define AL_EQUALIZER_MAX_MID1_GAIN 7.943f +#define AL_EQUALIZER_DEFAULT_MID1_GAIN 1.0f + +#define AL_EQUALIZER_MIN_MID1_CENTER 200.0f +#define AL_EQUALIZER_MAX_MID1_CENTER 3000.0f +#define AL_EQUALIZER_DEFAULT_MID1_CENTER 500.0f + +#define AL_EQUALIZER_MIN_MID1_WIDTH 0.01f +#define AL_EQUALIZER_MAX_MID1_WIDTH 1.0f +#define AL_EQUALIZER_DEFAULT_MID1_WIDTH 1.0f + +#define AL_EQUALIZER_MIN_MID2_GAIN 0.126f +#define AL_EQUALIZER_MAX_MID2_GAIN 7.943f +#define AL_EQUALIZER_DEFAULT_MID2_GAIN 1.0f + +#define AL_EQUALIZER_MIN_MID2_CENTER 1000.0f +#define AL_EQUALIZER_MAX_MID2_CENTER 8000.0f +#define AL_EQUALIZER_DEFAULT_MID2_CENTER 3000.0f + +#define AL_EQUALIZER_MIN_MID2_WIDTH 0.01f +#define AL_EQUALIZER_MAX_MID2_WIDTH 1.0f +#define AL_EQUALIZER_DEFAULT_MID2_WIDTH 1.0f + +#define AL_EQUALIZER_MIN_HIGH_GAIN 0.126f +#define AL_EQUALIZER_MAX_HIGH_GAIN 7.943f +#define AL_EQUALIZER_DEFAULT_HIGH_GAIN 1.0f + +#define AL_EQUALIZER_MIN_HIGH_CUTOFF 4000.0f +#define AL_EQUALIZER_MAX_HIGH_CUTOFF 16000.0f +#define AL_EQUALIZER_DEFAULT_HIGH_CUTOFF 6000.0f + + + + +/********************************************************** + * Source parameter value definitions, ranges and defaults. + */ +#define AL_MIN_AIR_ABSORPTION_FACTOR 0.0f +#define AL_MAX_AIR_ABSORPTION_FACTOR 10.0f +#define AL_DEFAULT_AIR_ABSORPTION_FACTOR 0.0f + +#define AL_MIN_ROOM_ROLLOFF_FACTOR 0.0f +#define AL_MAX_ROOM_ROLLOFF_FACTOR 10.0f +#define AL_DEFAULT_ROOM_ROLLOFF_FACTOR 0.0f + +#define AL_MIN_CONE_OUTER_GAINHF 0.0f +#define AL_MAX_CONE_OUTER_GAINHF 1.0f +#define AL_DEFAULT_CONE_OUTER_GAINHF 1.0f + +#define AL_MIN_DIRECT_FILTER_GAINHF_AUTO AL_FALSE +#define AL_MAX_DIRECT_FILTER_GAINHF_AUTO AL_TRUE +#define AL_DEFAULT_DIRECT_FILTER_GAINHF_AUTO AL_TRUE + +#define AL_MIN_AUXILIARY_SEND_FILTER_GAIN_AUTO AL_FALSE +#define AL_MAX_AUXILIARY_SEND_FILTER_GAIN_AUTO AL_TRUE +#define AL_DEFAULT_AUXILIARY_SEND_FILTER_GAIN_AUTO AL_TRUE + +#define AL_MIN_AUXILIARY_SEND_FILTER_GAINHF_AUTO AL_FALSE +#define AL_MAX_AUXILIARY_SEND_FILTER_GAINHF_AUTO AL_TRUE +#define AL_DEFAULT_AUXILIARY_SEND_FILTER_GAINHF_AUTO AL_TRUE + + + + +/********************************************************** + * Listener parameter value definitions, ranges and defaults. + */ +#define AL_MIN_METERS_PER_UNIT FLT_MIN +#define AL_MAX_METERS_PER_UNIT FLT_MAX +#define AL_DEFAULT_METERS_PER_UNIT 1.0f + + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* __efx_h_ */ diff --git a/openAL/include/xram.h b/openAL/include/xram.h new file mode 100644 index 0000000..5d83662 --- /dev/null +++ b/openAL/include/xram.h @@ -0,0 +1,94 @@ +#include + +// X-RAM Function pointer definitions +typedef ALboolean (__cdecl *EAXSetBufferMode)(ALsizei n, ALuint *buffers, ALint value); +typedef ALenum (__cdecl *EAXGetBufferMode)(ALuint buffer, ALint *value); + +////////////////////////////////////////////////////////////////////////////// +// Query for X-RAM extension +// +// if (alIsExtensionPresent("EAX-RAM") == AL_TRUE) +// X-RAM Extension found +// +////////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////////// +// X-RAM enum names +// +// "AL_EAX_RAM_SIZE" +// "AL_EAX_RAM_FREE" +// "AL_STORAGE_AUTOMATIC" +// "AL_STORAGE_HARDWARE" +// "AL_STORAGE_ACCESSIBLE" +// +// Query enum values using alGetEnumValue, for example +// +// long lRamSizeEnum = alGetEnumValue("AL_EAX_RAM_SIZE") +// +////////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////////// +// Query total amount of X-RAM +// +// long lTotalSize = alGetInteger(alGetEnumValue("AL_EAX_RAM_SIZE") +// +////////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////////// +// Query free X-RAM available +// +// long lFreeSize = alGetInteger(alGetEnumValue("AL_EAX_RAM_FREE") +// +////////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////////// +// Query X-RAM Function pointers +// +// Use typedefs defined above to get the X-RAM function pointers using +// alGetProcAddress +// +// EAXSetBufferMode eaxSetBufferMode; +// EAXGetBufferMode eaxGetBufferMode; +// +// eaxSetBufferMode = (EAXSetBufferMode)alGetProcAddress("EAXSetBufferMode"); +// eaxGetBufferMode = (EAXGetBufferMode)alGetProcAddress("EAXGetBufferMode"); +// +////////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////////// +// Force an Open AL Buffer into X-RAM (good for non-streaming buffers) +// +// ALuint uiBuffer; +// alGenBuffers(1, &uiBuffer); +// eaxSetBufferMode(1, &uiBuffer, alGetEnumValue("AL_STORAGE_HARDWARE")); +// alBufferData(...); +// +////////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////////// +// Force an Open AL Buffer into 'accessible' (currently host) RAM (good for streaming buffers) +// +// ALuint uiBuffer; +// alGenBuffers(1, &uiBuffer); +// eaxSetBufferMode(1, &uiBuffer, alGetEnumValue("AL_STORAGE_ACCESSIBLE")); +// alBufferData(...); +// +////////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////////// +// Put an Open AL Buffer into X-RAM if memory is available, otherwise use +// host RAM. This is the default mode. +// +// ALuint uiBuffer; +// alGenBuffers(1, &uiBuffer); +// eaxSetBufferMode(1, &uiBuffer, alGetEnumValue("AL_STORAGE_AUTOMATIC")); +// alBufferData(...); +// +////////////////////////////////////////////////////////////////////////////// \ No newline at end of file diff --git a/openAL/libs/Win32/EFX-Util_MT/EFX-Util.lib b/openAL/libs/Win32/EFX-Util_MT/EFX-Util.lib new file mode 100644 index 0000000000000000000000000000000000000000..f984bc78127a5a932de4d368d4714f27db178e6a GIT binary patch literal 9072 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 N(8)Fu`Zzi{`X8r19rXYJ literal 0 HcmV?d00001 diff --git a/openAL/libs/Win64/EFX-Util_MTDLL/EFX-Util.lib b/openAL/libs/Win64/EFX-Util_MTDLL/EFX-Util.lib new file mode 100644 index 0000000000000000000000000000000000000000..8a926e5c1949624d5c37d672f0b065040b30f996 GIT binary patch literal 15308 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 literal 0 HcmV?d00001 diff --git a/openAL/libs/Win64/OpenAL32.lib b/openAL/libs/Win64/OpenAL32.lib new file mode 100644 index 0000000000000000000000000000000000000000..17663e0a388887093e8cff00a892b0c8c4851360 GIT binary patch literal 19858 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 literal 0 HcmV?d00001