Merge pull request #843 from marauder2k9-torque/OpenAL-Loading

OpenAL enumeration fix

Engine/source/sfx/openal/LoadOAL.h

@@ -165,6 +165,13 @@ typedef void			  (ALAPIENTRY *LPALGETAUXILIARYEFFECTSLOTIV)(ALuint effectslot, A
 typedef void			  (ALAPIENTRY *LPALGETAUXILIARYEFFECTSLOTF)(ALuint effectslot, ALenum param, ALfloat *value);
 typedef void			  (ALAPIENTRY *LPALGETAUXILIARYEFFECTSLOTFV)(ALuint effectslot, ALenum param, ALfloat *values);
 typedef void			  (ALAPIENTRY *LPALSOURCE3I)(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3);
+// Changes for Filters.
+typedef void           (ALAPIENTRY* LPALGENFILTERS)(ALsizei n, ALuint* filter);
+typedef void			  (ALAPIENTRY* LPALDELETEFILTERS)(ALsizei n, const ALuint* filters);
+typedef void			  (ALAPIENTRY* LPALFILTERI)(ALuint filter , ALenum param, ALint value);
+// Changes for HRTF
+typedef const ALCchar* (ALCAPIENTRY* LPALCGETSTRINGISOFT)(ALCdevice* device, ALCenum param, ALint value1);
+
 
 typedef struct
 {
@@ -261,6 +268,12 @@ typedef struct
    LPALGETAUXILIARYEFFECTSLOTF			alGetAuxiliaryEffectSlotf;
    LPALGETAUXILIARYEFFECTSLOTFV			alGetAuxiliaryEffectSlotfv;
 #endif
+   LPALGENFILTERS         alGenFilters;
+   LPALDELETEFILTERS      alDeleteFilters;
+   LPALFILTERI            alFilteri;
+
+   LPALCGETSTRINGISOFT alcGetStringiSOFT;
+
 } OPENALFNTABLE, *LPOPENALFNTABLE;
 #endif
 

Engine/source/sfx/openal/aldlist.cpp

@@ -44,7 +44,6 @@ ALDeviceList::ALDeviceList( const OPENALFNTABLE &oalft )
 	char *devices;
 	int index;
 	const char *defaultDeviceName;
-   const char *actualDeviceName;
 
    dMemcpy( &ALFunction, &oalft, sizeof( OPENALFNTABLE ) );
 
@@ -55,88 +54,52 @@ ALDeviceList::ALDeviceList( const OPENALFNTABLE &oalft )
    defaultDeviceIndex = 0;
 
    // grab function pointers for 1.0-API functions, and if successful proceed to enumerate all devices
-   const bool enumerationExtensionPresent = ALFunction.alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT");
-   const bool enumerateAllExtensionPresent = ALFunction.alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT");
-   if (enumerateAllExtensionPresent || enumerationExtensionPresent) {
-      if (enumerateAllExtensionPresent)
-      {
+   if (ALFunction.alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT")) {
           devices = (char *)ALFunction.alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);
           defaultDeviceName = (char *)ALFunction.alcGetString(NULL, ALC_DEFAULT_ALL_DEVICES_SPECIFIER);
-      }
-      else
-      {
-          devices = (char *)ALFunction.alcGetString(NULL, ALC_DEVICE_SPECIFIER);
-          defaultDeviceName = (char *)ALFunction.alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
-      }
+   }
+   else
+   {
+       devices = (char *)ALFunction.alcGetString(NULL, ALC_DEVICE_SPECIFIER);
+       defaultDeviceName = (char *)ALFunction.alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
+   }
 
-      index = 0;
+   index = 0;
       // go through device list (each device terminated with a single NULL, list terminated with double NULL)
-      while (*devices != 0) {
-         if (String::compare(defaultDeviceName, devices) == 0) {
-            defaultDeviceIndex = index;
+   while (*devices != 0) {
+      if (String::compare(defaultDeviceName, devices) == 0) {
+         defaultDeviceIndex = index;
+      }
+
+      bool bNewName = true;
+      for (int i = 0; i < GetNumDevices(); i++) {
+         if (String::compare(GetDeviceName(i), devices) == 0) {
+            bNewName = false;
          }
-         ALCdevice *device = ALFunction.alcOpenDevice(devices);
-         if (device) {
-            ALCcontext *context = ALFunction.alcCreateContext(device, NULL);
-            if (context) {
-               ALFunction.alcMakeContextCurrent(context);
-               // if new actual device name isn't already in the list, then add it...
-               actualDeviceName = devices;
-               bool bNewName = true;
-               for (int i = 0; i < GetNumDevices(); i++) {
-                  if (String::compare(GetDeviceName(i), actualDeviceName) == 0) {
-                     bNewName = false;
-                  }
-               }
-               if ((bNewName) && (actualDeviceName != NULL) && (dStrlen(actualDeviceName) > 0)) {
-                  dMemset(&ALDeviceInfo, 0, sizeof(ALDEVICEINFO));
-                  ALDeviceInfo.bSelected = true;
-                  dStrncpy(ALDeviceInfo.strDeviceName, actualDeviceName, sizeof(ALDeviceInfo.strDeviceName));
-                  ALFunction.alcGetIntegerv(device, ALC_MAJOR_VERSION, sizeof(int), &ALDeviceInfo.iMajorVersion);
-                  ALFunction.alcGetIntegerv(device, ALC_MINOR_VERSION, sizeof(int), &ALDeviceInfo.iMinorVersion);
-
-                  ALDeviceInfo.iCapsFlags = 0;
-
-                  // Check for ALC Extensions
-                  if (ALFunction.alcIsExtensionPresent(device, "ALC_EXT_CAPTURE") == AL_TRUE)
-                     ALDeviceInfo.iCapsFlags |= SFXALCapture;
-                  if (ALFunction.alcIsExtensionPresent(device, "ALC_EXT_EFX") == AL_TRUE)
-                     ALDeviceInfo.iCapsFlags |= SFXALEFX;
-
-                  // Check for AL Extensions
-                  if (ALFunction.alIsExtensionPresent("AL_EXT_OFFSET") == AL_TRUE)
-                     ALDeviceInfo.iCapsFlags |= SFXALOffset;
-
-                  if (ALFunction.alIsExtensionPresent("AL_EXT_LINEAR_DISTANCE") == AL_TRUE)
-                     ALDeviceInfo.iCapsFlags |= SFXALLinearDistance;
-                  if (ALFunction.alIsExtensionPresent("AL_EXT_EXPONENT_DISTANCE") == AL_TRUE)
-                     ALDeviceInfo.iCapsFlags |= SFXALExponentDistance;
-
-                  if (ALFunction.alIsExtensionPresent("EAX2.0") == AL_TRUE)
-                     ALDeviceInfo.iCapsFlags |= SFXALEAX2;
-                  if (ALFunction.alIsExtensionPresent("EAX3.0") == AL_TRUE)
-                     ALDeviceInfo.iCapsFlags |= SFXALEAX3;
-                  if (ALFunction.alIsExtensionPresent("EAX4.0") == AL_TRUE)
-                     ALDeviceInfo.iCapsFlags |= SFXALEAX4;
-                  if (ALFunction.alIsExtensionPresent("EAX5.0") == AL_TRUE)
-                     ALDeviceInfo.iCapsFlags |= SFXALEAX5;
-
-                  if (ALFunction.alIsExtensionPresent("EAX-RAM") == AL_TRUE)
-                     ALDeviceInfo.iCapsFlags |= SFXALEAXRAM;
-
-                  // Get Source Count
-                  ALDeviceInfo.uiSourceCount = GetMaxNumSources();
-
-                  vDeviceInfo.push_back(ALDeviceInfo);
-               }
-               ALFunction.alcMakeContextCurrent(NULL);
-               ALFunction.alcDestroyContext(context);
-            }
-            ALFunction.alcCloseDevice(device);
+      }
+
+      if ((bNewName) && (devices != NULL) && (dStrlen(devices) > 0))
+      {
+         dMemset(&ALDeviceInfo, 0, sizeof(ALDEVICEINFO));
+         ALDeviceInfo.bSelected = true;
+         dStrncpy(ALDeviceInfo.strInternalDeviceName, devices, sizeof(ALDeviceInfo.strInternalDeviceName));
+         char* openFind = dStrchr(devices, '(');
+         if (openFind)
+         {
+            devices = openFind + 1;
+            char* closeFind = dStrchr(devices, ')');
+            if (closeFind)
+               (*closeFind) = '\0';
+
+            dStrncpy(ALDeviceInfo.strDeviceName, devices, sizeof(ALDeviceInfo.strDeviceName));
+
          }
-         devices += dStrlen(devices) + 1;
-         index += 1;
+
+         vDeviceInfo.push_back(ALDeviceInfo);
       }
+
+      devices += dStrlen(devices) + 1;
+      index += 1;
    }
 
 	ResetFilters();
@@ -160,14 +123,23 @@ int ALDeviceList::GetNumDevices()
 /* 
  * Returns the device name at an index in the complete device list
  */
-const char *ALDeviceList::GetDeviceName(int index)
+const char *ALDeviceList::GetInternalDeviceName(int index)
 {
 	if (index < GetNumDevices())
-		return vDeviceInfo[index].strDeviceName;
+		return vDeviceInfo[index].strInternalDeviceName;
 	else
 		return NULL;
 }
 
+const char* ALDeviceList::GetDeviceName(int index)
+{
+   if (index < GetNumDevices())
+      return vDeviceInfo[index].strDeviceName;
+   else
+      return NULL;
+}
+
+
 /*
  * Returns the major and minor version numbers for a device at a specified index in the complete list
  */

Engine/source/sfx/openal/aldlist.h

@@ -32,11 +32,12 @@
 typedef struct
 {
 	char           strDeviceName[256];
+	char           strInternalDeviceName[256];
 	S32				iMajorVersion;
 	S32				iMinorVersion;
-   U32	uiSourceCount;
-	S32 iCapsFlags;
-	bool			bSelected;
+   U32	         uiSourceCount;
+	S32            iCapsFlags;
+	bool			   bSelected;
 } ALDEVICEINFO, *LPALDEVICEINFO;
 
 class ALDeviceList
@@ -52,6 +53,7 @@ public:
 	~ALDeviceList ();
 	S32 GetNumDevices();
 	const char *GetDeviceName(S32 index);
+	const char *GetInternalDeviceName(S32 index);
 	void GetDeviceVersion(S32 index, S32 *major, S32 *minor);
    U32 GetMaxNumSources(S32 index);
 	bool IsExtensionSupported(S32 index, SFXALCaps caps);

Engine/source/sfx/openal/sfxALDevice.cpp

@@ -24,6 +24,201 @@
 #include "sfx/openal/sfxALBuffer.h"
 #include "platform/async/asyncUpdate.h"
 
+//----------------------------------------------------------------------------
+// STATIC OPENAL FUNCTIONS
+//----------------------------------------------------------------------------
+void SFXALDevice::printALInfo(ALCdevice* device)
+{
+   ALCint major, minor;
+   if (device)
+   {
+      const ALCchar* devname = NULL;
+      Con::printBlankLine();
+
+      if (mOpenAL.alcIsExtensionPresent(device, "ALC_ENUMERATE_ALL_EXT") != AL_FALSE)
+      {
+         devname = mOpenAL.alcGetString(device, ALC_ALL_DEVICES_SPECIFIER);
+      }
+      else
+      {
+         devname = mOpenAL.alcGetString(device, ALC_DEVICE_SPECIFIER);
+      }
+
+      Con::printf("| Device info for: %s ", devname);
+   }
+
+   mOpenAL.alcGetIntegerv(device, ALC_MAJOR_VERSION, 1, &major);
+   mOpenAL.alcGetIntegerv(device, ALC_MINOR_VERSION, 1, &minor);
+   Con::printf("| OpenAL Version: %d.%d", major, minor);
+
+   if (device)
+   {
+      Con::printf("%s", mOpenAL.alcGetString(device, ALC_EXTENSIONS));
+
+      U32 err = mOpenAL.alcGetError(device);
+      if (err != ALC_NO_ERROR)
+         Con::errorf("SFXALDevice - Error Retrieving ALC Extensions: %s", mOpenAL.alcGetString(device, err));
+   }
+  
+}
+
+void SFXALDevice::printHRTFInfo(ALCdevice* device)
+{
+   if (mOpenAL.alcIsExtensionPresent(device, "ALC_SOFT_HRTF") == AL_FALSE)
+   {
+      Con::printf("HRTF Extensions not compatible");
+      return;
+   }
+
+   ALCint numHrtfs;
+
+   mOpenAL.alcGetIntegerv(device, ALC_NUM_HRTF_SPECIFIERS_SOFT, 1, &numHrtfs);
+   if (!numHrtfs)
+      Con::printf("No HRTFs Found");
+   else
+   {
+      Con::printf("Available HRTFs");
+      for (U32 i = 0; i < numHrtfs; ++i)
+      {
+         const ALCchar* name = mOpenAL.alcGetStringiSOFT(device, ALC_HRTF_SPECIFIER_SOFT, i);
+         printf("   %s", name);
+      }
+   }
+
+   U32 err = mOpenAL.alcGetError(device);
+   if (err != ALC_NO_ERROR)
+      Con::errorf("SFXALDevice - Error Retrieving HRTF info: %s", mOpenAL.alcGetString(device, err));
+
+}
+
+void SFXALDevice::getEFXInfo(ALCdevice *device)
+{
+   static const ALint filters[] = {
+        AL_FILTER_LOWPASS, AL_FILTER_HIGHPASS, AL_FILTER_BANDPASS,
+        AL_FILTER_NULL
+   };
+
+   char filterNames[] = "Low-pass,High-pass,Band-pass,";
+   static const ALint effects[] = {
+       AL_EFFECT_EAXREVERB, AL_EFFECT_REVERB, AL_EFFECT_CHORUS,
+       AL_EFFECT_DISTORTION, AL_EFFECT_ECHO, AL_EFFECT_FLANGER,
+       AL_EFFECT_FREQUENCY_SHIFTER, AL_EFFECT_VOCAL_MORPHER,
+       AL_EFFECT_PITCH_SHIFTER, AL_EFFECT_RING_MODULATOR,
+       AL_EFFECT_AUTOWAH, AL_EFFECT_COMPRESSOR, AL_EFFECT_EQUALIZER,
+       AL_EFFECT_NULL
+   };
+   static const ALint dedeffects[] = {
+       AL_EFFECT_DEDICATED_DIALOGUE, AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT,
+       AL_EFFECT_NULL
+   };
+   char effectNames[] = "EAX Reverb,Reverb,Chorus,Distortion,Echo,Flanger,"
+      "Frequency Shifter,Vocal Morpher,Pitch Shifter,Ring Modulator,Autowah,"
+      "Compressor,Equalizer,Dedicated Dialog,Dedicated LFE,";
+
+   ALCint major, minor, sends;
+   ALuint obj;
+
+   char* current;
+   U32 i;
+
+   if (mOpenAL.alcIsExtensionPresent(device, "ALC_EXT_EFX") == AL_FALSE)
+   {
+      Con::printf("SFXALDevice - EFX Not available.");
+      return;
+   }
+
+   mOpenAL.alcGetIntegerv(device, ALC_EFX_MAJOR_VERSION, 1, &major);
+   mOpenAL.alcGetIntegerv(device, ALC_EFX_MINOR_VERSION, 1, &minor);
+   U32 err = mOpenAL.alcGetError(device);
+   if (err != ALC_NO_ERROR)
+      Con::errorf("SFXALDevice - Error Retrieving EFX Version: %s", mOpenAL.alcGetString(device, err));
+   else
+   {
+      Con::printf("| EFX Version: %d.%d", major, minor);
+   }
+
+   mOpenAL.alcGetIntegerv(device, ALC_MAX_AUXILIARY_SENDS, 1, &sends);
+   err = mOpenAL.alcGetError(device);
+   if (err != ALC_NO_ERROR)
+      Con::errorf("SFXALDevice - Error Retrieving Auxiliary Sends: %s", mOpenAL.alcGetString(device, err));
+   else
+   {
+      Con::printf("| Max Aux Sends: %d", sends);
+   }
+
+   mOpenAL.alGenFilters(1, &obj);
+   err = mOpenAL.alcGetError(device);
+   if (err != ALC_NO_ERROR)
+      Con::errorf("SFXALDevice - Error Generating filter: %s", mOpenAL.alcGetString(device, err));
+
+   current = filterNames;
+   for (i = 0; filters[i] != AL_FILTER_NULL; i++)
+   {
+      char* next = dStrchr(current, ',');
+
+      mOpenAL.alFilteri(obj, AL_FILTER_TYPE, filters[i]);
+      if (mOpenAL.alGetError() != AL_NO_ERROR)
+         dMemmove(current, next + 1, strlen(next));
+      else
+         current = next + 1;
+   }
+
+   Con::printf("| Supported Filters: %s", filterNames);
+
+   mOpenAL.alDeleteFilters(1, &obj);
+
+   mOpenAL.alGenEffects(1, &obj);
+   err = mOpenAL.alcGetError(device);
+   if (err != ALC_NO_ERROR)
+      Con::errorf("SFXALDevice - Error Generating effects: %s", mOpenAL.alcGetString(device, err));
+
+   current = effectNames;
+   for (i = 0; effects[i] != AL_EFFECT_NULL; i++)
+   {
+      char* next = dStrchr(current, ',');
+      mOpenAL.alEffecti(obj, AL_FILTER_TYPE, effects[i]);
+      if (mOpenAL.alGetError() != AL_NO_ERROR)
+         dMemmove(current, next + 1, strlen(next));
+      else
+         current = next + 1;
+   }
+
+   if (mOpenAL.alcIsExtensionPresent(device, "ALC_EXT_DEDICATED"))
+   {
+      for (i = 0; dedeffects[i] != AL_EFFECT_NULL; i++)
+      {
+         char* next = dStrchr(current, ',');
+         mOpenAL.alEffecti(obj, AL_FILTER_TYPE, dedeffects[i]);
+         if (mOpenAL.alGetError() != AL_NO_ERROR)
+            dMemmove(current, next + 1, strlen(next));
+         else
+            current = next + 1;
+      }
+   }
+   else
+   {
+      for (i = 0; dedeffects[i] != AL_EFFECT_NULL; i++)
+      {
+         char* next = dStrchr(current, ',');
+         dMemmove(current, next + 1, strlen(next));
+      }
+   }
+
+   Con::printf("| Supported Effects: %s", effectNames);
+
+   mOpenAL.alDeleteEffects(1, &obj);
+}
+
+S32 SFXALDevice::getMaxSources()
+{
+   // Clear AL Error Code
+   mOpenAL.alGetError();
+
+   ALCint nummono;
+   mOpenAL.alcGetIntegerv(mDevice, ALC_MONO_SOURCES, 1, &nummono);
+
+   return nummono;
+}
 
 //-----------------------------------------------------------------------------
 
@@ -53,21 +248,27 @@ SFXALDevice::SFXALDevice(  SFXProvider *provider,
 #endif
    attribs[1] = 4;
 
+   printALInfo(NULL);
+
    mDevice = mOpenAL.alcOpenDevice( name );
-   mOpenAL.alcGetError( mDevice );
+   U32 err = mOpenAL.alcGetError(mDevice);
+   if (err != ALC_NO_ERROR)
+      Con::errorf("SFXALDevice - Device Initialization Error: %s", mOpenAL.alcGetString(mDevice, err));
+
    if( mDevice ) 
    {
       mContext = mOpenAL.alcCreateContext( mDevice, attribs );
 
       if( mContext ) 
          mOpenAL.alcMakeContextCurrent( mContext );
+
 #if defined(AL_ALEXT_PROTOTYPES)
        mOpenAL.alcGetIntegerv(mDevice, ALC_MAX_AUXILIARY_SENDS, 1, &iSends);
 #endif
        U32 err = mOpenAL.alcGetError( mDevice );
       
       if( err != ALC_NO_ERROR )
-         Con::errorf( "SFXALDevice - Initialization Error: %s", mOpenAL.alcGetString( mDevice, err ) );
+         Con::errorf( "SFXALDevice - Context Initialization Error: %s", mOpenAL.alcGetString( mDevice, err ) );
    }
 
    AssertFatal( mDevice != NULL && mContext != NULL, "Failed to create OpenAL device and/or context!" );
@@ -89,6 +290,16 @@ SFXALDevice::SFXALDevice(  SFXProvider *provider,
    dMemset(effect, 0, sizeof(effect));
    uLoop = 0;
 #endif
+
+   printALInfo(mDevice);
+   printHRTFInfo(mDevice);
+   getEFXInfo(mDevice);
+
+   mMaxBuffers = getMaxSources();
+
+   // this should be max sources.
+   Con::printf("| Max Sources: %d", mMaxBuffers);
+
 }
 
 //-----------------------------------------------------------------------------

Engine/source/sfx/openal/sfxALDevice.h

@@ -53,7 +53,12 @@ class SFXALDevice : public SFXDevice
       typedef SFXDevice Parent;
       friend class SFXALVoice; // mDistanceFactor, mRolloffFactor
 
-      SFXALDevice(   SFXProvider *provider, 
+      void printALInfo(ALCdevice* device);
+      void printHRTFInfo(ALCdevice* device);
+      void getEFXInfo(ALCdevice* device);
+      S32 getMaxSources();
+
+      SFXALDevice(   SFXProvider *provider,
                      const OPENALFNTABLE &openal, 
                      String name, 
                      bool useHardware, 

Engine/source/sfx/openal/sfxALProvider.cpp

@@ -98,28 +98,9 @@ void SFXALProvider::init()
    {
       ALDeviceInfo* info = new ALDeviceInfo;
       
+      info->internalName = String( mALDL->GetInternalDeviceName( i ) );
       info->name = String( mALDL->GetDeviceName( i ) );
 
-      S32 major, minor, eax = 0;
-
-      mALDL->GetDeviceVersion( i, &major, &minor );
-
-      // Apologies for the blatent enum hack -patw
-      for( S32 j = SFXALEAX2; j < SFXALEAXRAM; j++ )
-         eax += (int)mALDL->IsExtensionSupported( i, (SFXALCaps)j );
-
-      if( eax > 0 )
-      {
-         eax += 2; // EAX support starts at 2.0
-         dSprintf( temp, sizeof( temp ), "[EAX %d.0] %s", eax, ( mALDL->IsExtensionSupported( i, SFXALEAXRAM ) ? "EAX-RAM" : "" ) );
-      }
-      else
-         dStrcpy( temp, "", 256 );
-
-      info->driver = String::ToString( deviceFormat, major, minor, temp );
-      info->hasHardware = eax > 0;
-      info->maxBuffers = mALDL->GetMaxNumSources( i );
-
       mDeviceInfo.push_back( info );
    }
 
@@ -141,7 +122,7 @@ SFXDevice *SFXALProvider::createDevice( const String& deviceName, bool useHardwa
 
    // Do we find one to create?
    if (info)
-      return new SFXALDevice(this, mOpenAL, info->name, useHardware, maxBuffers);
+      return new SFXALDevice(this, mOpenAL, info->internalName, useHardware, maxBuffers);
 
    return NULL;
 }

Engine/source/sfx/openal/win32/LoadOAL.cpp

@@ -552,6 +552,35 @@ ALboolean LoadOAL10Library(char *szOALFullPathName, LPOPENALFNTABLE lpOALFnTable
       OutputDebugStringA("Failed to retrieve 'alGetAuxiliaryEffectSlotiv' function address\n");
    }
    lpOALFnTable->alSource3i = (LPALSOURCE3I)GetProcAddress(g_hOpenALDLL, "alSource3i");
+
+   lpOALFnTable->alGenFilters = (LPALGENFILTERS)GetProcAddress(g_hOpenALDLL, "alGenFilters");
+   if (lpOALFnTable->alGenFilters == NULL)
+   {
+      OutputDebugStringA("Failed to retrieve 'alGenFilters' function address\n");
+      return AL_FALSE;
+   }
+
+   lpOALFnTable->alDeleteFilters = (LPALDELETEFILTERS)GetProcAddress(g_hOpenALDLL, "alDeleteFilters");
+   if (lpOALFnTable->alGenFilters == NULL)
+   {
+      OutputDebugStringA("Failed to retrieve 'alDeleteFilters' function address\n");
+      return AL_FALSE;
+   }
+
+   lpOALFnTable->alFilteri = (LPALFILTERI)GetProcAddress(g_hOpenALDLL, "alFilteri");
+   if (lpOALFnTable->alGenFilters == NULL)
+   {
+      OutputDebugStringA("Failed to retrieve 'alFilteri' function address\n");
+      return AL_FALSE;
+   }
+   
+   lpOALFnTable->alcGetStringiSOFT = (LPALCGETSTRINGISOFT)GetProcAddress(g_hOpenALDLL, "alcGetStringiSOFT");
+   if (lpOALFnTable->alcGetStringiSOFT == NULL)
+   {
+      OutputDebugStringA("Failed to retrieve 'alcGetStringiSOFT' function address\n");
+      return AL_FALSE;
+   }
+
 #endif
 	return AL_TRUE;
 }

Engine/source/sfx/sfxProvider.h

@@ -35,6 +35,7 @@ class SFXDevice;
 struct SFXDeviceInfo
 {
    String   driver;
+   String   internalName;
    String   name;
    bool     hasHardware;
    S32      maxBuffers;
@@ -121,4 +122,4 @@ class SFXProvider
 };
 
 
-#endif // _SFXPROVIDER_H_
+#endif // _SFXPROVIDER_H_

Engine/source/sfx/sfxSystem.cpp

@@ -1264,7 +1264,8 @@ DefineEngineFunction( sfxGetAvailableDevices, const char*, (),,
       {
          const SFXDeviceInfo* info = deviceInfo[d];
          const char *providerName = provider->getName().c_str();
-         const char *infoName = info->name.c_str();
+         char *infoName = (char*)info->name.c_str();
+         
          dSprintf(ptr, len, "%s\t%s\t%s\t%i\n", providerName, infoName, info->hasHardware ? "1" : "0", info->maxBuffers);
 
          ptr += dStrlen(ptr);