ALboolean ALFWIsXRAMSupported()
{
ALboolean bXRAM = AL_FALSE;
if (alIsExtensionPresent("EAX-RAM") == AL_TRUE)
{
// Get X-RAM Function pointers
eaxSetBufferMode = (EAXSetBufferMode)alGetProcAddress("EAXSetBufferMode");
eaxGetBufferMode = (EAXGetBufferMode)alGetProcAddress("EAXGetBufferMode");
if (eaxSetBufferMode && eaxGetBufferMode)
{
eXRAMSize = alGetEnumValue("AL_EAX_RAM_SIZE");
eXRAMFree = alGetEnumValue("AL_EAX_RAM_FREE");
eXRAMAuto = alGetEnumValue("AL_STORAGE_AUTOMATIC");
eXRAMHardware = alGetEnumValue("AL_STORAGE_HARDWARE");
eXRAMAccessible = alGetEnumValue("AL_STORAGE_ACCESSIBLE");
if (eXRAMSize && eXRAMFree && eXRAMAuto && eXRAMHardware && eXRAMAccessible)
bXRAM = AL_TRUE;
}
}
return bXRAM;
}
int main(int argc, char **argv)
{
StreamPlayer *player;
int i;
/* Print out usage if no file was specified */
if(argc < 2)
{
fprintf(stderr, "Usage: %s <filenames...>\n", argv[0]);
return 1;
}
if(InitAL() != 0)
return 1;
if(alIsExtensionPresent("AL_SOFT_buffer_samples"))
{
printf("AL_SOFT_buffer_samples supported!\n");
alBufferSamplesSOFT = alGetProcAddress("alBufferSamplesSOFT");
alIsBufferFormatSupportedSOFT = alGetProcAddress("alIsBufferFormatSupportedSOFT");
}
else
printf("AL_SOFT_buffer_samples not supported\n");
player = NewPlayer();
/* Play each file listed on the command line */
for(i = 1;i < argc;i++)
{
if(!OpenPlayerFile(player, argv[i]))
continue;
printf("Playing %s (%s, %s, %dhz)\n", argv[i],
TypeName(player->type), ChannelsName(player->channels),
player->rate);
fflush(stdout);
if(!StartPlayer(player))
{
ClosePlayerFile(player);
continue;
}
while(UpdatePlayer(player))
Sleep(10);
/* All done with this file. Close it and go to the next */
ClosePlayerFile(player);
}
printf("Done.\n");
/* All files done. Delete the player, and close OpenAL */
DeletePlayer(player);
player = NULL;
CloseAL();
return 0;
}
hsBool plEAXListener::Init( void )
{
#ifdef EAX_SDK_AVAILABLE
if( fInited )
return true;
if(!alIsExtensionPresent((ALchar *)"EAX4.0")) // is eax 4 supported
{
if(!alIsExtensionPresent((ALchar *) "EAX4.0Emulated")) // is an earlier version of eax supported
{
plStatusLog::AddLineS("audio.log", "EAX not supported");
return false;
}
else
{
plStatusLog::AddLineS("audio.log", "EAX 4 Emulated supported");
}
}
else
{
plStatusLog::AddLineS("audio.log", "EAX 4 available");
}
// EAX is supported
s_EAXGet = (EAXGet)alGetProcAddress((ALchar *)"EAXGet");
s_EAXSet = (EAXSet)alGetProcAddress((ALchar *)"EAXSet");
if(!s_EAXGet || ! s_EAXSet)
{
IFail( "EAX initialization failed", true );
return false;
}
fInited = true;
#if 1
try
{
// Make an EAX call here to prevent problems on WDM driver
unsigned int lRoom = -10000;
SetGlobalEAXProperty(DSPROPSETID_EAX_ListenerProperties, DSPROPERTY_EAXLISTENER_ROOM, &lRoom, sizeof( unsigned int ));
}
catch ( ... )
{
plStatusLog::AddLineS("audio.log", "Unable to set EAX Property Set, disabling EAX...");
plgAudioSys::EnableEAX(false);
return false;
}
#endif
ClearProcessCache();
return true;
#else /* !EAX_SDK_AVAILABLE */
plStatusLog::AddLineS("audio.log", "EAX disabled in this build");
return false;
#endif
}
static void loadExtensions(void)
{
#ifdef WIN32
// Check for EAX 2.0.
hasEAX = alIsExtensionPresent((ALchar*) "EAX2.0");
if(hasEAX)
{
EAXGet = (ALenum (*)(const struct _GUID*, ALuint, ALuint, ALvoid*, ALuint))alGetProcAddress("EAXGet");
EAXSet = (ALenum (*)(const struct _GUID*, ALuint, ALuint, ALvoid*, ALuint))alGetProcAddress("EAXSet");
if(!EAXGet || !EAXSet)
hasEAX = false;
}
#else
hasEAX = false;
#endif
}
/*! Get a function address for an OpenAL extension function and bind it
* to it's function pointer
*/
static bool bindExtensionFunction( void *&fnAddress, const char *name )
{
fnAddress = alGetProcAddress( (ALubyte*)name );
if( !fnAddress )
Con::errorf(ConsoleLogEntry::General, " Missing OpenAL Extension function '%s'", name);
return (fnAddress != NULL);
}
static
void* get_proc(const char *namez) {
void* proc = (void*)alGetProcAddress(namez);
if (!proc)
proc = (void*)alcGetProcAddress(device, namez);
return proc;
}
static Context *CreateContext(MFDevice *pDevice)
{
AudioDevice &device = *(AudioDevice*)pDevice->pInternal;
if(!device.pDevice)
device.pDevice = alcOpenDevice(pDevice->strings[MFDS_ID]);
if(!device.pDevice)
return NULL;
Context *pContext = (Context*)MFHeap_Alloc(sizeof(Context));
pContext->pContext = alcCreateContext(device.pDevice, NULL);
pContext->pDevice = pDevice;
pContext->pRender = &device;
Context *pOld = MakeCurrent(pContext);
const char *pVersion = alGetString(AL_VERSION);
const char *pExtensions = alGetString(AL_EXTENSIONS);
MFDebug_Log(0, MFStr("OpenAL Version: %s", pVersion));
MFDebug_Log(0, MFStr("OpenAL Extensions: %s", pExtensions));
pContext->ext.static_buffer = alIsExtensionPresent("ALC_EXT_STATIC_BUFFER") == AL_TRUE;
pContext->ext.offset = alIsExtensionPresent("AL_EXT_OFFSET") == AL_TRUE;
pContext->ext.float32 = alIsExtensionPresent("AL_EXT_float32") == AL_TRUE;
pContext->ext.source_radius = alIsExtensionPresent("AL_EXT_SOURCE_RADIUS") == AL_TRUE;
pContext->ext.buffer_sub_data = alIsExtensionPresent("AL_SOFT_buffer_sub_data") == AL_TRUE;
pContext->ext.buffer_samples = alIsExtensionPresent("AL_SOFT_buffer_samples") == AL_TRUE;
if(pContext->ext.static_buffer)
alBufferDataStatic = (PFNALBUFFERDATASTATICPROC)alGetProcAddress("alBufferDataStatic");
if(pContext->ext.buffer_sub_data)
alBufferSubDataSOFT = (PFNALBUFFERSUBDATASOFTPROC)alGetProcAddress("alBufferSubDataSOFT");
alListener3f(AL_POSITION, 0, 0, 0);
alListener3f(AL_VELOCITY, 0, 0, 0);
alListener3f(AL_ORIENTATION, 0, 0, -1);
MakeCurrent(pOld);
return pContext;
}
ALvoid alBufferDataStaticProc(const ALint bid, ALenum format, ALvoid* data, ALsizei size, ALsizei freq)
{
static alBufferDataStaticProcPtr proc = NULL;
if (proc == NULL) {
proc = (alBufferDataStaticProcPtr) alGetProcAddress((const ALCchar*) "alBufferDataStatic");
}
if (proc)
proc(bid, format, data, size, freq);
return;
}
ALdouble alcMacOSXGetMixerOutputRate()
{
static alcMacOSXGetMixerOutputRateProcPtr the_proc = NULL;
if(NULL == the_proc)
{
the_proc = (alcMacOSXGetMixerOutputRateProcPtr) alGetProcAddress((const ALCchar*) "alcMacOSXGetMixerOutputRate");
}
if(NULL != the_proc)
{
return the_proc();
}
return 0.0;
}
ALvoid alBufferDataStatic(ALint buffer_id, ALenum al_format, ALvoid* pcm_data, ALsizei buffer_size, ALsizei sample_rate)
{
static alBufferDataStaticProcPtr the_proc = NULL;
if(NULL == the_proc)
{
the_proc = (alBufferDataStaticProcPtr) alGetProcAddress((ALCchar*) "alBufferDataStatic");
}
if(NULL != the_proc)
{
the_proc(buffer_id, al_format, pcm_data, buffer_size, sample_rate);
}
return;
}
ALvoid alcMacOSXMixerOutputRate(const ALdouble sample_rate)
{
static alcMacOSXMixerOutputRateProcPtr the_proc = NULL;
if(NULL == the_proc)
{
the_proc = (alcMacOSXMixerOutputRateProcPtr) alGetProcAddress((const ALCchar*) "alcMacOSXMixerOutputRate");
}
if(NULL != the_proc)
{
the_proc(sample_rate);
}
return;
}
//*****************************************************************************
// alGetProcAddress
//*****************************************************************************
//
ALAPI ALvoid* ALAPIENTRY alGetProcAddress(const ALCchar* fname)
{
// return router's address if available
ALsizei i=0;
ALvoid *pAddress;
while ((function[i].funcName)&&(strcmp((char *)function[i].funcName,(char *)fname)))
i++;
pAddress = function[i].address;
if (pAddress != NULL) {
return pAddress;
}
// router doesn't have this entry point, so go to the device...
AL_RESULT_FXN(alGetProcAddress(fname), ALvoid*, 0);
return pAddress;
}
ALvoid* CDECL wine_alGetProcAddress(const ALchar* funcname)
{
void *proc;
int i;
/* Make sure the host implementation has the requested function. This will
* also set the last AL error properly if the function should not be
* returned (eg. no current context). */
proc = alGetProcAddress(funcname);
if(!proc)
return NULL;
for(i = 0;ALFuncs[i].name;i++)
{
if(strcmp(funcname, ALFuncs[i].name) == 0)
return ALFuncs[i].proc;
}
FIXME("Could not find function in list: %s\n", funcname);
return NULL;
}
JNIEXPORT jlong JNICALL Java_org_lwjgl_openal_AL10_nalGetProcAddress(JNIEnv *__env, jclass clazz, jlong funcNameAddress, jlong __functionAddress) {
const ALchar *funcName = (const ALchar *)(intptr_t)funcNameAddress;
alGetProcAddressPROC alGetProcAddress = (alGetProcAddressPROC)(intptr_t)__functionAddress;
UNUSED_PARAMS(__env, clazz)
return (jlong)(intptr_t)alGetProcAddress(funcName);
}
/**
* @brief Enables the OpenAL EFX extension.
*
* @return 0 on success.
*/
static int al_enableEFX (void)
{
/* Get general information. */
alcGetIntegerv( al_device, ALC_MAX_AUXILIARY_SENDS, 1, &al_info.efx_auxSends );
alcGetIntegerv( al_device, ALC_EFX_MAJOR_VERSION, 1, &al_info.efx_major );
alcGetIntegerv( al_device, ALC_EFX_MINOR_VERSION, 1, &al_info.efx_minor );
/* Get function pointers. */
nalGenAuxiliaryEffectSlots = alGetProcAddress( "alGenAuxiliaryEffectSlots" );
nalDeleteAuxiliaryEffectSlots = alGetProcAddress( "alDeleteAuxiliaryEffectSlots" );
nalIsAuxiliaryEffectSlot = alGetProcAddress( "alIsAuxiliaryEffectSlot" );
nalAuxiliaryEffectSloti = alGetProcAddress( "alAuxiliaryEffectSloti" );
nalAuxiliaryEffectSlotiv = alGetProcAddress( "alAuxiliaryEffectSlotiv" );
nalAuxiliaryEffectSlotf = alGetProcAddress( "alAuxiliaryEffectSlotf" );
nalAuxiliaryEffectSlotfv = alGetProcAddress( "alAuxiliaryEffectSlotfv" );
nalGetAuxiliaryEffectSloti = alGetProcAddress( "alGetAuxiliaryEffectSloti" );
nalGetAuxiliaryEffectSlotiv = alGetProcAddress( "alGetAuxiliaryEffectSlotiv" );
nalGetAuxiliaryEffectSlotf = alGetProcAddress( "alGetAuxiliaryEffectSlotf" );
nalGetAuxiliaryEffectSlotfv = alGetProcAddress( "alGetAuxiliaryEffectSlotfv" );
nalGenFilters = alGetProcAddress( "alGenFilters" );
nalDeleteFilters = alGetProcAddress( "alDeleteFilters" );
nalFilteri = alGetProcAddress( "alFilteri" );
nalFilteriv = alGetProcAddress( "alFilteriv" );
nalFilterf = alGetProcAddress( "alFilterf" );
nalFilterfv = alGetProcAddress( "alFilterfv" );
nalGenEffects = alGetProcAddress( "alGenEffects" );
nalDeleteEffects = alGetProcAddress( "alDeleteEffects" );
nalEffecti = alGetProcAddress( "alEffecti" );
nalEffectiv = alGetProcAddress( "alEffectiv" );
nalEffectf = alGetProcAddress( "alEffectf" );
nalEffectfv = alGetProcAddress( "alEffectfv" );
if (!nalGenAuxiliaryEffectSlots || !nalDeleteAuxiliaryEffectSlots ||
!nalIsAuxiliaryEffectSlot ||
!nalAuxiliaryEffectSloti || !nalAuxiliaryEffectSlotiv ||
!nalAuxiliaryEffectSlotf || !nalAuxiliaryEffectSlotfv ||
!nalGetAuxiliaryEffectSloti || !nalGetAuxiliaryEffectSlotiv ||
!nalGetAuxiliaryEffectSlotf || !nalGetAuxiliaryEffectSlotfv ||
!nalGenFilters || !nalDeleteFilters ||
!nalFilteri || !nalFilteriv || !nalFilterf || !nalFilterfv ||
!nalGenEffects || !nalDeleteEffects ||
!nalEffecti || !nalEffectiv || !nalEffectf || !nalEffectfv) {
DEBUG("OpenAL EFX functions not found, disabling EFX.");
al_info.efx = AL_FALSE;
return -1;
}
/* Create auxiliary slot. */
nalGenAuxiliaryEffectSlots( 1, &efx_directSlot );
/* Create reverb effect. */
nalGenEffects( 1, &efx_reverb );
nalEffecti( efx_reverb, AL_EFFECT_TYPE, AL_EFFECT_REVERB );
if(alGetError() != AL_NO_ERROR) {
DEBUG("OpenAL Reverb not found, disabling.");
al_info.efx_reverb = AL_FALSE;
nalDeleteEffects( 1, &efx_reverb );
}
else {
al_info.efx_reverb = AL_TRUE;
/* Set Reverb parameters. */
/*nalEffectf( efx_reverb, AL_REVERB_DECAY_TIME, 15. );*/
}
/* Create echo effect. */
nalGenEffects( 1, &efx_echo );
nalEffecti( efx_echo, AL_EFFECT_TYPE, AL_EFFECT_ECHO );
if(alGetError() != AL_NO_ERROR) {
DEBUG("OpenAL Echo not found, disabling.");
al_info.efx_echo = AL_FALSE;
nalDeleteEffects( 1, &efx_echo );
}
else {
al_info.efx_echo = AL_TRUE;
/* Set Echo parameters. */
nalEffectf( efx_echo, AL_ECHO_DELAY, 0.207 );
}
/* Set up the listener. */
alListenerf( AL_METERS_PER_UNIT, 5. );
/* Check for errors. */
al_checkErr();
return 0;
}
int main (int argc, char **argv) {
#pragma region // --- my init ---
float pitchnow = 1.0;
alListener3f(AL_POSITION, 0.0, 0.0, 0.0);
#pragma endregion
#pragma region // --- al init ---
// alut の初期化
alutInit (&argc, argv);
// Hello World としゃべる音声の作成
ALuint helloBuffer = alutCreateBufferHelloWorld();
ALuint MusicBuffer = alutCreateBufferFromFile(FILENAME);
if(AL_NONE == helloBuffer) {
std::cerr<<"error:nofile"<<std::endl;
exit(1);
}
// ソースの作成
ALuint helloSource;
alGenSources (1, &helloSource);
ALuint MusicSource;
alGenSources (1, &MusicSource);
// ソースにバッファをバインド
alSourcei (helloSource, AL_BUFFER, helloBuffer);
alSourcei (MusicSource, AL_BUFFER, MusicBuffer);
#pragma endregion
#pragma region // --- effect init ---
ALCdevice *pDevice = alcOpenDevice(NULL);
if(!pDevice) {
std::cerr<<"error : device not found"<<std::endl;
exit(1);
}
LPALGENEFFECTS alGenEffects=(LPALGENEFFECTS)alGetProcAddress("alGenEffects");
#pragma region // --- set Reverb ---
ALuint Effect = 0;
alGenEffects(1, &Effect);
alEffecti(Effect, AL_EFFECT_TYPE, AL_EFFECT_REVERB);
#pragma endregion
#pragma endregion
cv::namedWindow("hoge");
alSourcePlay(MusicSource);
alSource3f(MusicSource, AL_POSITION, 100.0, 0.0, 0.0);
alSource3f(MusicSource, AL_VELOCITY, 10.0, 0.0, 0.0);
while(1) {
char key = cv::waitKey(1);
if(key=='s') {
alSourcePlay(helloSource);
//alutSleep(1);
}
if(key == 'p') {
int state;
alGetSourcei(MusicSource, AL_SOURCE_STATE, &state);
if(state ==AL_PAUSED)alSourcePlay(MusicSource);
else alSourcePause(MusicSource);
}
else if(key == 'q') {
std::cout<<"good bye"<<std::endl;
break;
}
else if(key == 'u') {
pitchnow *= 2;
alSourcef(MusicSource, AL_PITCH, pitchnow);
}
else if(key == 'd') {
pitchnow /= 2;
alSourcef(MusicSource, AL_PITCH, pitchnow);
}
// roop
int state;
alGetSourcei(MusicSource, AL_SOURCE_STATE, &state);
if(state != AL_PLAYING) alSourcePlay(MusicSource);
}
#pragma region --- release ---
// リソースを開放
alSourceStop(helloSource);
alDeleteSources( 1, &helloSource );
alDeleteBuffers( 1, &helloBuffer );
alSourceStop(MusicSource);
alDeleteSources( 1, &MusicSource );
alDeleteBuffers( 1, &MusicBuffer );
alutExit ();
#pragma endregion
return 0;
}
OPAL_SOUND_MGR bool SoundManager::init( void )
{
// It's an error to initialise twice OpenAl
if ( isInitialised ) return true;
// Open an audio device
mSoundDevice = alcOpenDevice( NULL ); // TODO ((ALubyte*) "DirectSound3D");
// mSoundDevice = alcOpenDevice( "DirectSound3D" );
// Check for errors
if ( !mSoundDevice )
{
printf( "SoundManager::init error : No sound device.\n");
return false;
}
mSoundContext = alcCreateContext( mSoundDevice, NULL );
// if ( checkAlError() || !mSoundContext ) // TODO seems not to work! why ?
if ( !mSoundContext )
{
printf( "SoundManager::init error : No sound context.\n");
return false;
}
// Make the context current and active
alcMakeContextCurrent( mSoundContext );
if ( checkALError( "Init()" ) )
{
printf( "SoundManager::init error : could not make sound context current and active.\n");
return false;
}
// Check for EAX 2.0 support and
// Retrieves function entry addresses to API ARB extensions, in this case,
// for the EAX extension. See Appendix 1 (Extensions) of
// http://www.openal.org/openal_webstf/specs/OpenAL1-1Spec_html/al11spec7.html
//
// TODO EAX fct not used anywhere in the code ... !!!
isEAXPresent = alIsExtensionPresent( "EAX2.0" );
if ( isEAXPresent )
{
printf( "EAX 2.0 Extension available\n" );
#ifdef _USEEAX
eaxSet = (EAXSet) alGetProcAddress( "EAXSet" );
if ( eaxSet == NULL )
isEAXPresent = false;
eaxGet = (EAXGet) alGetProcAddress( "EAXGet" );
if ( eaxGet == NULL )
isEAXPresent = false;
if ( !isEAXPresent )
checkALError( "Failed to get the EAX extension functions adresses.\n" );
#else
isEAXPresent = false;
printf( "... but not used.\n" );
#endif // _USEEAX
}
// Test if Ogg Vorbis extension is present
isOggExtensionPresent();
// Create the Audio Buffers
alGenBuffers( MAX_AUDIO_BUFFERS, mAudioBuffers );
if (checkALError("init::alGenBuffers:") )
return false;
// Generate Sources
alGenSources( MAX_AUDIO_SOURCES, mAudioSources );
if (checkALError( "init::alGenSources :") )
return false;
// Setup the initial listener parameters
// -> location
alListenerfv( AL_POSITION, position );
// -> velocity
alListenerfv( AL_VELOCITY, velocity );
// -> orientation
alListenerfv( AL_ORIENTATION, orientation );
// Gain
alListenerf( AL_GAIN, 1.0 );
// Initialise Doppler
alDopplerFactor( 1.0 ); // 1.2 = exaggerate the pitch shift by 20%
alDopplerVelocity( 343.0f ); // m/s this may need to be scaled at some point
// Ok
isInitialised = true;
isSoundOn = true;
printf( "SoundManager initialised.\n\n");
return true;
}
bool COALExtProvider::Create(ALCdevice* device, ALCcontext*& context)
{
ALint attribs[4] = { 0 };
bool efx = false;
//Try to load effect extension
if(ExtPresent(device, ALC_EXT_EFX_NAME))
{
attribs[0] = ALC_MAX_AUXILIARY_SENDS;
attribs[1] = 4;
context = alcCreateContext(device, attribs);
efx = true;
CON(MSG_INFO, _W(" Device supports Effect Extension"));
}
else
{
CON(MSG_INFO, _W(" Device doesn't support Effect Extension"));
context = alcCreateContext(device, NULL);
}
if(context == NULL)
return false;
alcMakeContextCurrent(context);
alcGetIntegerv(device, ALC_MAX_AUXILIARY_SENDS, 1, &m_maxAux);
CON(MSG_INFO, _W(" Device supports %d Aux Sends per Source"), m_maxAux);
if(efx)
{
alGenEffects = (LPALGENEFFECTS)alGetProcAddress("alGenEffects");
alDeleteEffects = (LPALDELETEEFFECTS )alGetProcAddress("alDeleteEffects");
alIsEffect = (LPALISEFFECT )alGetProcAddress("alIsEffect");
alEffecti = (LPALEFFECTI)alGetProcAddress("alEffecti");
alEffectiv = (LPALEFFECTIV)alGetProcAddress("alEffectiv");
alEffectf = (LPALEFFECTF)alGetProcAddress("alEffectf");
alEffectfv = (LPALEFFECTFV)alGetProcAddress("alEffectfv");
alGetEffecti = (LPALGETEFFECTI)alGetProcAddress("alGetEffecti");
alGetEffectiv = (LPALGETEFFECTIV)alGetProcAddress("alGetEffectiv");
alGetEffectf = (LPALGETEFFECTF)alGetProcAddress("alGetEffectf");
alGetEffectfv = (LPALGETEFFECTFV)alGetProcAddress("alGetEffectfv");
alGenFilters = (LPALGENFILTERS)alGetProcAddress("alGenFilters");
alDeleteFilters = (LPALDELETEFILTERS)alGetProcAddress("alDeleteFilters");
alIsFilter = (LPALISFILTER)alGetProcAddress("alIsFilter");
alFilteri = (LPALFILTERI)alGetProcAddress("alFilteri");
alFilteriv = (LPALFILTERIV)alGetProcAddress("alFilteriv");
alFilterf = (LPALFILTERF)alGetProcAddress("alFilterf");
alFilterfv = (LPALFILTERFV)alGetProcAddress("alFilterfv");
alGetFilteri = (LPALGETFILTERI )alGetProcAddress("alGetFilteri");
alGetFilteriv= (LPALGETFILTERIV )alGetProcAddress("alGetFilteriv");
alGetFilterf = (LPALGETFILTERF )alGetProcAddress("alGetFilterf");
alGetFilterfv= (LPALGETFILTERFV )alGetProcAddress("alGetFilterfv");
alGenAuxiliaryEffectSlots = (LPALGENAUXILIARYEFFECTSLOTS)alGetProcAddress("alGenAuxiliaryEffectSlots");
alDeleteAuxiliaryEffectSlots = (LPALDELETEAUXILIARYEFFECTSLOTS)alGetProcAddress("alDeleteAuxiliaryEffectSlots");
alIsAuxiliaryEffectSlot = (LPALISAUXILIARYEFFECTSLOT)alGetProcAddress("alIsAuxiliaryEffectSlot");
alAuxiliaryEffectSloti = (LPALAUXILIARYEFFECTSLOTI)alGetProcAddress("alAuxiliaryEffectSloti");
alAuxiliaryEffectSlotiv = (LPALAUXILIARYEFFECTSLOTIV)alGetProcAddress("alAuxiliaryEffectSlotiv");
alAuxiliaryEffectSlotf = (LPALAUXILIARYEFFECTSLOTF)alGetProcAddress("alAuxiliaryEffectSlotf");
alAuxiliaryEffectSlotfv = (LPALAUXILIARYEFFECTSLOTFV)alGetProcAddress("alAuxiliaryEffectSlotfv");
alGetAuxiliaryEffectSloti = (LPALGETAUXILIARYEFFECTSLOTI)alGetProcAddress("alGetAuxiliaryEffectSloti");
alGetAuxiliaryEffectSlotiv = (LPALGETAUXILIARYEFFECTSLOTIV)alGetProcAddress("alGetAuxiliaryEffectSlotiv");
alGetAuxiliaryEffectSlotf = (LPALGETAUXILIARYEFFECTSLOTF)alGetProcAddress("alGetAuxiliaryEffectSlotf");
alGetAuxiliaryEffectSlotfv = (LPALGETAUXILIARYEFFECTSLOTFV)alGetProcAddress("alGetAuxiliaryEffectSlotfv");
if(!(alGenEffects && alDeleteEffects && alIsEffect && alEffecti && alEffectiv && alEffectf &&
alEffectfv && alGetEffecti && alGetEffectiv && alGetEffectf && alGetEffectfv && alGenFilters &&
alDeleteFilters && alIsFilter && alFilteri && alFilteriv && alFilterf && alFilterfv &&
alGetFilteri && alGetFilteriv && alGetFilterf && alGetFilterfv && alGenAuxiliaryEffectSlots &&
alDeleteAuxiliaryEffectSlots && alIsAuxiliaryEffectSlot && alAuxiliaryEffectSloti &&
alAuxiliaryEffectSlotiv && alAuxiliaryEffectSlotf && alAuxiliaryEffectSlotfv &&
alGetAuxiliaryEffectSloti && alGetAuxiliaryEffectSlotiv && alGetAuxiliaryEffectSlotf &&
alGetAuxiliaryEffectSlotfv))
{
CON(MSG_INFO, _W(" Can't load EFX functions!"));
efx = false;
}
}
m_initialized = efx;
return efx;
}
int main( int argc, char* argv[] ) {
ALCdevice *dev;
FILE *fh;
struct stat sbuf;
void *data;
char *fname;
int size;
int i = 0;
dev = alcOpenDevice( NULL );
if( dev == NULL ) {
return 1;
}
/* Initialize ALUT. */
context_id = alcCreateContext( dev, NULL );
if(context_id == NULL) {
alcCloseDevice( dev );
return 1;
}
alcMakeContextCurrent( context_id );
fixup_function_pointers();
init( );
if(argc == 1) {
fname = VORBIS_FILE;
} else {
fname = argv[1];
}
if(stat(fname, &sbuf) == -1) {
perror(fname);
return errno;
}
size = sbuf.st_size;
data = malloc(size);
if(data == NULL) {
exit(1);
}
fh = fopen(fname, "rb");
if(fh == NULL) {
fprintf(stderr, "Could not open %s\n", fname);
free(data);
exit(1);
}
fread(data, size, 1, fh);
alutLoadVorbisp = (vorbisLoader *) alGetProcAddress((ALubyte *) VORBIS_FUNC);
if(alutLoadVorbisp == NULL) {
free(data);
fprintf(stderr, "Could not GetProc %s\n",
(ALubyte *) VORBIS_FUNC);
exit(-4);
}
if(alutLoadVorbisp(vorbbuf, data, size) != AL_TRUE) {
fprintf(stderr, "alutLoadVorbis failed\n");
exit(-2);
}
free(data);
alSourcePlay( vorbsource );
while(SourceIsPlaying(vorbsource) == AL_TRUE) {
sleep(1);
}
cleanup();
alcCloseDevice( dev );
return 0;
}
double lime_al_get_proc_address (HxString fname) {
return (intptr_t)alGetProcAddress (fname.__s);
}
int main( int argc, char* argv[] ) {
ALCdevice *dev;
FILE *fh;
time_t shouldend;
int blah = 0;
struct stat sbuf;
int speed;
void *data;
int size;
char *fname;
int i = 0;
dev = alcOpenDevice( NULL );
if( dev == NULL ) {
return 1;
}
/* Initialize ALUT. */
context_id = alcCreateContext( dev, NULL );
if(context_id == NULL) {
alcCloseDevice( dev );
return 1;
}
alcMakeContextCurrent( context_id );
fixup_function_pointers();
init( );
if(argc == 1) {
fname = MP3_FILE;
} else {
fname = argv[1];
}
if(stat(fname, &sbuf) == -1) {
perror(fname);
return errno;
}
size = sbuf.st_size;
data = malloc(size);
if(data == NULL) {
exit(1);
}
fh = fopen(fname, "rb");
if(fh == NULL) {
fprintf(stderr, "Could not open %s\n", fname);
free(data);
exit(1);
}
fread(data, 1, size, fh);
alutLoadMP3p = (mp3Loader *) alGetProcAddress((ALubyte *) MP3_FUNC);
if(alutLoadMP3p == NULL) {
free(data);
fprintf(stderr, "Could not GetProc %s\n",
(ALubyte *) MP3_FUNC);
exit(-4);
}
for(i = 0; i < MAX_SOURCES; i++) {
if(alutLoadMP3p(mp3buf[i], data, size) != AL_TRUE) {
fprintf(stderr, "alutLoadMP3p failed\n");
exit(-2);
}
alSourcePlay(mp3source[i]);
micro_sleep(80000);
}
free( data );
while(SourceIsPlaying(mp3source[0]) == AL_TRUE) {
sleep(1);
}
cleanup();
alcCloseDevice( dev );
return 0;
}
bool init_efx_funcs() {
alGenEffects = (LPALGENEFFECTS)alGetProcAddress("alGenEffects");
alDeleteEffects = (LPALDELETEEFFECTS)alGetProcAddress("alDeleteEffects");
alIsEffect = (LPALISEFFECT)alGetProcAddress("alIsEffect");
alGenAuxiliaryEffectSlots = (LPALGENAUXILIARYEFFECTSLOTS)alGetProcAddress("alGenAuxiliaryEffectSlots");
alEffecti = (LPALEFFECTI)alGetProcAddress("alEffecti");
alEffectf = (LPALEFFECTF)alGetProcAddress("alEffectf");
alGenFilters = (LPALGENFILTERS)alGetProcAddress("alGenFilters");
alIsFilter = (LPALISFILTER)alGetProcAddress("alIsFilter");
alFilteri = (LPALFILTERI)alGetProcAddress("alFilteri");
alFilterf = (LPALFILTERF)alGetProcAddress("alFilterf");
alAuxiliaryEffectSloti = (LPALAUXILIARYEFFECTSLOTI)alGetProcAddress("alAuxiliaryEffectSloti");
alDeleteAuxiliaryEffectSlots = (LPALDELETEAUXILIARYEFFECTSLOTS)alGetProcAddress("alDeleteAuxiliaryEffectSlots");
alDeleteFilters = (LPALDELETEFILTERS)alGetProcAddress("alDeleteFilters");
const auto fail = [](const string& name) -> bool {
a2e_error("failed to get function pointer for \"%s\"!", name);
return false;
};
if(alGenEffects == nullptr) return fail("alGenEffects");
if(alDeleteEffects == nullptr) return fail("alDeleteEffects");
if(alIsEffect == nullptr) return fail("alIsEffect");
if(alGenAuxiliaryEffectSlots == nullptr) return fail("alGenAuxiliaryEffectSlots");
if(alEffecti == nullptr) return fail("alEffecti");
if(alEffectf == nullptr) return fail("alEffectf");
if(alGenFilters == nullptr) return fail("alGenFilters");
if(alIsFilter == nullptr) return fail("alIsFilter");
if(alFilteri == nullptr) return fail("alFilteri");
if(alFilterf == nullptr) return fail("alFilterf");
if(alAuxiliaryEffectSloti == nullptr) return fail("alAuxiliaryEffectSloti");
if(alDeleteAuxiliaryEffectSlots == nullptr) return fail("alDeleteAuxiliaryEffectSlots");
if(alDeleteFilters == nullptr) return fail("alDeleteFilters");
return true;
}
ALboolean QOpenALEngine::ALFWIsEFXSupported()
{
ALCdevice *pDevice = NULL;
ALCcontext *pContext = NULL;
ALboolean bEFXSupport = AL_FALSE;
pContext = alcGetCurrentContext();
pDevice = alcGetContextsDevice(pContext);
if (alcIsExtensionPresent(pDevice, (ALCchar*)ALC_EXT_EFX_NAME))
{
// Get function pointers
alGenEffects = (LPALGENEFFECTS)alGetProcAddress("alGenEffects");
alDeleteEffects = (LPALDELETEEFFECTS )alGetProcAddress("alDeleteEffects");
alIsEffect = (LPALISEFFECT )alGetProcAddress("alIsEffect");
alEffecti = (LPALEFFECTI)alGetProcAddress("alEffecti");
alEffectiv = (LPALEFFECTIV)alGetProcAddress("alEffectiv");
alEffectf = (LPALEFFECTF)alGetProcAddress("alEffectf");
alEffectfv = (LPALEFFECTFV)alGetProcAddress("alEffectfv");
alGetEffecti = (LPALGETEFFECTI)alGetProcAddress("alGetEffecti");
alGetEffectiv = (LPALGETEFFECTIV)alGetProcAddress("alGetEffectiv");
alGetEffectf = (LPALGETEFFECTF)alGetProcAddress("alGetEffectf");
alGetEffectfv = (LPALGETEFFECTFV)alGetProcAddress("alGetEffectfv");
alGenFilters = (LPALGENFILTERS)alGetProcAddress("alGenFilters");
alDeleteFilters = (LPALDELETEFILTERS)alGetProcAddress("alDeleteFilters");
alIsFilter = (LPALISFILTER)alGetProcAddress("alIsFilter");
alFilteri = (LPALFILTERI)alGetProcAddress("alFilteri");
alFilteriv = (LPALFILTERIV)alGetProcAddress("alFilteriv");
alFilterf = (LPALFILTERF)alGetProcAddress("alFilterf");
alFilterfv = (LPALFILTERFV)alGetProcAddress("alFilterfv");
alGetFilteri = (LPALGETFILTERI )alGetProcAddress("alGetFilteri");
alGetFilteriv= (LPALGETFILTERIV )alGetProcAddress("alGetFilteriv");
alGetFilterf = (LPALGETFILTERF )alGetProcAddress("alGetFilterf");
alGetFilterfv= (LPALGETFILTERFV )alGetProcAddress("alGetFilterfv");
alGenAuxiliaryEffectSlots = (LPALGENAUXILIARYEFFECTSLOTS)alGetProcAddress("alGenAuxiliaryEffectSlots");
alDeleteAuxiliaryEffectSlots = (LPALDELETEAUXILIARYEFFECTSLOTS)alGetProcAddress("alDeleteAuxiliaryEffectSlots");
alIsAuxiliaryEffectSlot = (LPALISAUXILIARYEFFECTSLOT)alGetProcAddress("alIsAuxiliaryEffectSlot");
alAuxiliaryEffectSloti = (LPALAUXILIARYEFFECTSLOTI)alGetProcAddress("alAuxiliaryEffectSloti");
alAuxiliaryEffectSlotiv = (LPALAUXILIARYEFFECTSLOTIV)alGetProcAddress("alAuxiliaryEffectSlotiv");
alAuxiliaryEffectSlotf = (LPALAUXILIARYEFFECTSLOTF)alGetProcAddress("alAuxiliaryEffectSlotf");
alAuxiliaryEffectSlotfv = (LPALAUXILIARYEFFECTSLOTFV)alGetProcAddress("alAuxiliaryEffectSlotfv");
alGetAuxiliaryEffectSloti = (LPALGETAUXILIARYEFFECTSLOTI)alGetProcAddress("alGetAuxiliaryEffectSloti");
alGetAuxiliaryEffectSlotiv = (LPALGETAUXILIARYEFFECTSLOTIV)alGetProcAddress("alGetAuxiliaryEffectSlotiv");
alGetAuxiliaryEffectSlotf = (LPALGETAUXILIARYEFFECTSLOTF)alGetProcAddress("alGetAuxiliaryEffectSlotf");
alGetAuxiliaryEffectSlotfv = (LPALGETAUXILIARYEFFECTSLOTFV)alGetProcAddress("alGetAuxiliaryEffectSlotfv");
if (alGenEffects && alDeleteEffects && alIsEffect && alEffecti && alEffectiv && alEffectf &&
alEffectfv && alGetEffecti && alGetEffectiv && alGetEffectf && alGetEffectfv && alGenFilters &&
alDeleteFilters && alIsFilter && alFilteri && alFilteriv && alFilterf && alFilterfv &&
alGetFilteri && alGetFilteriv && alGetFilterf && alGetFilterfv && alGenAuxiliaryEffectSlots &&
alDeleteAuxiliaryEffectSlots && alIsAuxiliaryEffectSlot && alAuxiliaryEffectSloti &&
alAuxiliaryEffectSlotiv && alAuxiliaryEffectSlotf && alAuxiliaryEffectSlotfv &&
alGetAuxiliaryEffectSloti && alGetAuxiliaryEffectSlotiv && alGetAuxiliaryEffectSlotf &&
alGetAuxiliaryEffectSlotfv)
bEFXSupport = AL_TRUE;
}
return bEFXSupport;
}
bool InitEfxApi() {
ALCcontext *pContext = alcGetCurrentContext();
ALCdevice *pDevice = alcGetContextsDevice(pContext);
if ( !alcIsExtensionPresent(pDevice, (ALCchar*)ALC_EXT_EFX_NAME) )
return false;
// Get function pointers
alGenEffects = (LPALGENEFFECTS)alGetProcAddress("alGenEffects");
alDeleteEffects = (LPALDELETEEFFECTS )alGetProcAddress("alDeleteEffects");
alIsEffect = (LPALISEFFECT )alGetProcAddress("alIsEffect");
alEffecti = (LPALEFFECTI)alGetProcAddress("alEffecti");
alEffectiv = (LPALEFFECTIV)alGetProcAddress("alEffectiv");
alEffectf = (LPALEFFECTF)alGetProcAddress("alEffectf");
alEffectfv = (LPALEFFECTFV)alGetProcAddress("alEffectfv");
alGetEffecti = (LPALGETEFFECTI)alGetProcAddress("alGetEffecti");
alGetEffectiv = (LPALGETEFFECTIV)alGetProcAddress("alGetEffectiv");
alGetEffectf = (LPALGETEFFECTF)alGetProcAddress("alGetEffectf");
alGetEffectfv = (LPALGETEFFECTFV)alGetProcAddress("alGetEffectfv");
alGenFilters = (LPALGENFILTERS)alGetProcAddress("alGenFilters");
alDeleteFilters = (LPALDELETEFILTERS)alGetProcAddress("alDeleteFilters");
alIsFilter = (LPALISFILTER)alGetProcAddress("alIsFilter");
alFilteri = (LPALFILTERI)alGetProcAddress("alFilteri");
alFilteriv = (LPALFILTERIV)alGetProcAddress("alFilteriv");
alFilterf = (LPALFILTERF)alGetProcAddress("alFilterf");
alFilterfv = (LPALFILTERFV)alGetProcAddress("alFilterfv");
alGetFilteri = (LPALGETFILTERI )alGetProcAddress("alGetFilteri");
alGetFilteriv= (LPALGETFILTERIV )alGetProcAddress("alGetFilteriv");
alGetFilterf = (LPALGETFILTERF )alGetProcAddress("alGetFilterf");
alGetFilterfv= (LPALGETFILTERFV )alGetProcAddress("alGetFilterfv");
alGenAuxiliaryEffectSlots = (LPALGENAUXILIARYEFFECTSLOTS)alGetProcAddress("alGenAuxiliaryEffectSlots");
alDeleteAuxiliaryEffectSlots = (LPALDELETEAUXILIARYEFFECTSLOTS)alGetProcAddress("alDeleteAuxiliaryEffectSlots");
alIsAuxiliaryEffectSlot = (LPALISAUXILIARYEFFECTSLOT)alGetProcAddress("alIsAuxiliaryEffectSlot");
alAuxiliaryEffectSloti = (LPALAUXILIARYEFFECTSLOTI)alGetProcAddress("alAuxiliaryEffectSloti");
alAuxiliaryEffectSlotiv = (LPALAUXILIARYEFFECTSLOTIV)alGetProcAddress("alAuxiliaryEffectSlotiv");
alAuxiliaryEffectSlotf = (LPALAUXILIARYEFFECTSLOTF)alGetProcAddress("alAuxiliaryEffectSlotf");
alAuxiliaryEffectSlotfv = (LPALAUXILIARYEFFECTSLOTFV)alGetProcAddress("alAuxiliaryEffectSlotfv");
alGetAuxiliaryEffectSloti = (LPALGETAUXILIARYEFFECTSLOTI)alGetProcAddress("alGetAuxiliaryEffectSloti");
alGetAuxiliaryEffectSlotiv = (LPALGETAUXILIARYEFFECTSLOTIV)alGetProcAddress("alGetAuxiliaryEffectSlotiv");
alGetAuxiliaryEffectSlotf = (LPALGETAUXILIARYEFFECTSLOTF)alGetProcAddress("alGetAuxiliaryEffectSlotf");
alGetAuxiliaryEffectSlotfv = (LPALGETAUXILIARYEFFECTSLOTFV)alGetProcAddress("alGetAuxiliaryEffectSlotfv");
return alGenEffects && alDeleteEffects && alIsEffect && alEffecti && alEffectiv && alEffectf &&
alEffectfv && alGetEffecti && alGetEffectiv && alGetEffectf && alGetEffectfv && alGenFilters &&
alDeleteFilters && alIsFilter && alFilteri && alFilteriv && alFilterf && alFilterfv &&
alGetFilteri && alGetFilteriv && alGetFilterf && alGetFilterfv && alGenAuxiliaryEffectSlots &&
alDeleteAuxiliaryEffectSlots && alIsAuxiliaryEffectSlot && alAuxiliaryEffectSloti &&
alAuxiliaryEffectSlotiv && alAuxiliaryEffectSlotf && alAuxiliaryEffectSlotfv &&
alGetAuxiliaryEffectSloti && alGetAuxiliaryEffectSlotiv && alGetAuxiliaryEffectSlotf &&
alGetAuxiliaryEffectSlotfv;
}
