a3x/re3
1
0
Fork 0
mirror of https://git.rip/DMCA_FUCKER/re3.git synced 2024-12-22 23:40:01 +00:00
Code Issues Projects Releases Wiki Activity

oal upd

Browse source
This commit is contained in:
Fire-Head 2020-05-04 20:33:48 +03:00
parent 1180cc2947
commit 8aac6060d3
22 changed files with 2850 additions and 2125 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/audio/AudioManager.cpp
View file

@ -9361,7 +9361,7 @@ cAudioManager::ResetTimers(uint32 time)
SampleManager.SetEffectsFadeVolume(0);
SampleManager.SetMusicFadeVolume(0);
MusicManager.ResetMusicAfterReload();
#ifdef OPENAL
#ifdef AUDIO_OAL
SampleManager.Service();
#endif
}
@ -9419,7 +9419,7 @@ cAudioManager::ServiceSoundEffects()
ProcessMissionAudio();
AdjustSamplesVolume();
ProcessActiveQueues();
#ifdef OPENAL
#ifdef AUDIO_OAL
SampleManager.Service();
#endif
for(int32 i = 0; i < m_sAudioScriptObjectManager.m_nScriptObjectEntityTotal; ++i) {

4
src/audio/AudioManager.h
View file

@ -600,6 +600,8 @@ public:
uint8 ComputeEmittingVolume(uint8 emittingVolume, float intensity, float dist);
};
//dstatic_assert(sizeof(cAudioManager) == 19220, "cAudioManager: error");
#ifdef AUDIO_MSS
static_assert(sizeof(cAudioManager) == 19220, "cAudioManager: error");
#endif
extern cAudioManager AudioManager;

23
src/audio/DMAudio.cpp
View file

@ -5,6 +5,7 @@
#include "AudioManager.h"
#include "AudioScriptObject.h"
#include "sampman.h"
#include "Text.h"
cDMAudio DMAudio;
@ -104,6 +105,28 @@ cDMAudio::Get3DProviderName(uint8 id)
return AudioManager.Get3DProviderName(id);
}
int8 cDMAudio::AutoDetect3DProviders(void)
{
for ( int32 i = 0; i < GetNum3DProvidersAvailable(); i++ )
{
wchar buff[64];
char *name = Get3DProviderName(i);
AsciiToUnicode(name, buff);
char *providername = UnicodeToAscii(buff);
strupr(providername);
#if defined(AUDIO_MSS)
if ( !strcmp(providername, "MILES FAST 2D POSITIONAL AUDIO") )
return i;
#elif defined(AUDIO_OAL)
if ( !strcmp(providername, "OPEANAL SOFT") )
return i;
#endif
}
return -1;
}
int8
cDMAudio::GetCurrent3DProviderIndex(void)
{

2
src/audio/DMAudio.h
View file

@ -205,6 +205,8 @@ public:
uint8 GetNum3DProvidersAvailable(void);
char *Get3DProviderName(uint8 id);
int8 AutoDetect3DProviders(void);
int8 GetCurrent3DProviderIndex(void);
int8 SetCurrent3DProvider(uint8 which);

339
src/audio/miles/sampman_mss.h
View file

@ -1,339 +0,0 @@
#pragma once
#include "common.h"
#include "AudioSamples.h"
#define MAX_VOLUME 127
struct tSample {
int32 nOffset;
uint32 nSize;
int32 nFrequency;
int32 nLoopStart;
int32 nLoopEnd;
};
enum
{
SAMPLEBANK_MAIN,
SAMPLEBANK_PED,
MAX_SAMPLEBANKS,
SAMPLEBANK_INVALID
};
#define MAX_PEDSFX 7
#define PED_BLOCKSIZE 79000
#define MAXPROVIDERS 64
#define MAXCHANNELS 28
#define MAXCHANNELS_SURROUND 24
#define MAX2DCHANNELS 1
#define CHANNEL2D MAXCHANNELS
#define MAX_MP3STREAMS 2
#define DIGITALRATE 32000
#define DIGITALBITS 16
#define DIGITALCHANNELS 2
#define MAX_DIGITAL_MIXER_CHANNELS 32
class cSampleManager
{
uint8 m_nEffectsVolume;
uint8 m_nMusicVolume;
uint8 m_nEffectsFadeVolume;
uint8 m_nMusicFadeVolume;
uint8 m_nMonoMode;
char unk;
char m_szCDRomRootPath[80];
bool m_bInitialised;
uint8 m_nNumberOfProviders;
char *m_aAudioProviders[MAXPROVIDERS];
tSample m_aSamples[TOTAL_AUDIO_SAMPLES];
public:
cSampleManager(void) :
m_nNumberOfProviders(0)
{ }
~cSampleManager(void)
{ }
void SetSpeakerConfig(int32 nConfig);
uint32 GetMaximumSupportedChannels(void);
uint32 GetNum3DProvidersAvailable() { return m_nNumberOfProviders; }
void SetNum3DProvidersAvailable(uint32 num) { m_nNumberOfProviders = num; }
char *Get3DProviderName(uint8 id) { return m_aAudioProviders[id]; }
void Set3DProviderName(uint8 id, char *name) { m_aAudioProviders[id] = name; }
int8 GetCurrent3DProviderIndex(void);
int8 SetCurrent3DProvider(uint8 which);
bool IsMP3RadioChannelAvailable(void);
void ReleaseDigitalHandle (void);
void ReacquireDigitalHandle(void);
bool Initialise(void);
void Terminate (void);
bool CheckForAnAudioFileOnCD(void);
char GetCDAudioDriveLetter (void);
void UpdateEffectsVolume(void);
void SetEffectsMasterVolume(uint8 nVolume);
void SetMusicMasterVolume (uint8 nVolume);
void SetEffectsFadeVolume (uint8 nVolume);
void SetMusicFadeVolume (uint8 nVolume);
bool LoadSampleBank (uint8 nBank);
void UnloadSampleBank (uint8 nBank);
bool IsSampleBankLoaded(uint8 nBank);
bool IsPedCommentLoaded(uint32 nComment);
bool LoadPedComment (uint32 nComment);
int32 _GetPedCommentSlot(uint32 nComment);
int32 GetSampleBaseFrequency (uint32 nSample);
int32 GetSampleLoopStartOffset(uint32 nSample);
int32 GetSampleLoopEndOffset (uint32 nSample);
uint32 GetSampleLength (uint32 nSample);
bool UpdateReverb(void);
void SetChannelReverbFlag (uint32 nChannel, uint8 nReverbFlag);
bool InitialiseChannel (uint32 nChannel, uint32 nSfx, uint8 nBank);
void SetChannelEmittingVolume(uint32 nChannel, uint32 nVolume);
void SetChannel3DPosition (uint32 nChannel, float fX, float fY, float fZ);
void SetChannel3DDistances (uint32 nChannel, float fMax, float fMin);
void SetChannelVolume (uint32 nChannel, uint32 nVolume);
void SetChannelPan (uint32 nChannel, uint32 nPan);
void SetChannelFrequency (uint32 nChannel, uint32 nFreq);
void SetChannelLoopPoints (uint32 nChannel, uint32 nLoopStart, int32 nLoopEnd);
void SetChannelLoopCount (uint32 nChannel, uint32 nLoopCount);
bool GetChannelUsedFlag (uint32 nChannel);
void StartChannel (uint32 nChannel);
void StopChannel (uint32 nChannel);
void PreloadStreamedFile (uint8 nFile, uint8 nStream);
void PauseStream (uint8 nPauseFlag, uint8 nStream);
void StartPreloadedStreamedFile (uint8 nStream);
bool StartStreamedFile (uint8 nFile, uint32 nPos, uint8 nStream);
void StopStreamedFile (uint8 nStream);
int32 GetStreamedFilePosition (uint8 nStream);
void SetStreamedVolumeAndPan(uint8 nVolume, uint8 nPan, uint8 nEffectFlag, uint8 nStream);
int32 GetStreamedFileLength (uint8 nStream);
bool IsStreamPlaying (uint8 nStream);
bool InitialiseSampleBanks(void);
};
extern cSampleManager SampleManager;
extern int32 BankStartOffset[MAX_SAMPLEBANKS];
static char StreamedNameTable[][25]=
{
"AUDIO\\HEAD.WAV",
"AUDIO\\CLASS.WAV",
"AUDIO\\KJAH.WAV",
"AUDIO\\RISE.WAV",
"AUDIO\\LIPS.WAV",
"AUDIO\\GAME.WAV",
"AUDIO\\MSX.WAV",
"AUDIO\\FLASH.WAV",
"AUDIO\\CHAT.WAV",
"AUDIO\\HEAD.WAV",
"AUDIO\\POLICE.WAV",
"AUDIO\\CITY.WAV",
"AUDIO\\WATER.WAV",
"AUDIO\\COMOPEN.WAV",
"AUDIO\\SUBOPEN.WAV",
"AUDIO\\JB.MP3",
"AUDIO\\BET.MP3",
"AUDIO\\L1_LG.MP3",
"AUDIO\\L2_DSB.MP3",
"AUDIO\\L3_DM.MP3",
"AUDIO\\L4_PAP.MP3",
"AUDIO\\L5_TFB.MP3",
"AUDIO\\J0_DM2.MP3",
"AUDIO\\J1_LFL.MP3",
"AUDIO\\J2_KCL.MP3",
"AUDIO\\J3_VH.MP3",
"AUDIO\\J4_ETH.MP3",
"AUDIO\\J5_DST.MP3",
"AUDIO\\J6_TBJ.MP3",
"AUDIO\\T1_TOL.MP3",
"AUDIO\\T2_TPU.MP3",
"AUDIO\\T3_MAS.MP3",
"AUDIO\\T4_TAT.MP3",
"AUDIO\\T5_BF.MP3",
"AUDIO\\S0_MAS.MP3",
"AUDIO\\S1_PF.MP3",
"AUDIO\\S2_CTG.MP3",
"AUDIO\\S3_RTC.MP3",
"AUDIO\\S5_LRQ.MP3",
"AUDIO\\S4_BDBA.MP3",
"AUDIO\\S4_BDBB.MP3",
"AUDIO\\S2_CTG2.MP3",
"AUDIO\\S4_BDBD.MP3",
"AUDIO\\S5_LRQB.MP3",
"AUDIO\\S5_LRQC.MP3",
"AUDIO\\A1_SSO.WAV",
"AUDIO\\A2_PP.WAV",
"AUDIO\\A3_SS.WAV",
"AUDIO\\A4_PDR.WAV",
"AUDIO\\A5_K2FT.WAV",
"AUDIO\\K1_KBO.MP3",
"AUDIO\\K2_GIS.MP3",
"AUDIO\\K3_DS.MP3",
"AUDIO\\K4_SHI.MP3",
"AUDIO\\K5_SD.MP3",
"AUDIO\\R0_PDR2.MP3",
"AUDIO\\R1_SW.MP3",
"AUDIO\\R2_AP.MP3",
"AUDIO\\R3_ED.MP3",
"AUDIO\\R4_GF.MP3",
"AUDIO\\R5_PB.MP3",
"AUDIO\\R6_MM.MP3",
"AUDIO\\D1_STOG.MP3",
"AUDIO\\D2_KK.MP3",
"AUDIO\\D3_ADO.MP3",
"AUDIO\\D5_ES.MP3",
"AUDIO\\D7_MLD.MP3",
"AUDIO\\D4_GTA.MP3",
"AUDIO\\D4_GTA2.MP3",
"AUDIO\\D6_STS.MP3",
"AUDIO\\A6_BAIT.WAV",
"AUDIO\\A7_ETG.WAV",
"AUDIO\\A8_PS.WAV",
"AUDIO\\A9_ASD.WAV",
"AUDIO\\K4_SHI2.MP3",
"AUDIO\\C1_TEX.MP3",
"AUDIO\\EL_PH1.MP3",
"AUDIO\\EL_PH2.MP3",
"AUDIO\\EL_PH3.MP3",
"AUDIO\\EL_PH4.MP3",
"AUDIO\\YD_PH1.MP3",
"AUDIO\\YD_PH2.MP3",
"AUDIO\\YD_PH3.MP3",
"AUDIO\\YD_PH4.MP3",
"AUDIO\\HD_PH1.MP3",
"AUDIO\\HD_PH2.MP3",
"AUDIO\\HD_PH3.MP3",
"AUDIO\\HD_PH4.MP3",
"AUDIO\\HD_PH5.MP3",
"AUDIO\\MT_PH1.MP3",
"AUDIO\\MT_PH2.MP3",
"AUDIO\\MT_PH3.MP3",
"AUDIO\\MT_PH4.MP3",
"AUDIO\\MISCOM.WAV",
"AUDIO\\END.MP3",
"AUDIO\\lib_a1.WAV",
"AUDIO\\lib_a2.WAV",
"AUDIO\\lib_a.WAV",
"AUDIO\\lib_b.WAV",
"AUDIO\\lib_c.WAV",
"AUDIO\\lib_d.WAV",
"AUDIO\\l2_a.WAV",
"AUDIO\\j4t_1.WAV",
"AUDIO\\j4t_2.WAV",
"AUDIO\\j4t_3.WAV",
"AUDIO\\j4t_4.WAV",
"AUDIO\\j4_a.WAV",
"AUDIO\\j4_b.WAV",
"AUDIO\\j4_c.WAV",
"AUDIO\\j4_d.WAV",
"AUDIO\\j4_e.WAV",
"AUDIO\\j4_f.WAV",
"AUDIO\\j6_1.WAV",
"AUDIO\\j6_a.WAV",
"AUDIO\\j6_b.WAV",
"AUDIO\\j6_c.WAV",
"AUDIO\\j6_d.WAV",
"AUDIO\\t4_a.WAV",
"AUDIO\\s1_a.WAV",
"AUDIO\\s1_a1.WAV",
"AUDIO\\s1_b.WAV",
"AUDIO\\s1_c.WAV",
"AUDIO\\s1_c1.WAV",
"AUDIO\\s1_d.WAV",
"AUDIO\\s1_e.WAV",
"AUDIO\\s1_f.WAV",
"AUDIO\\s1_g.WAV",
"AUDIO\\s1_h.WAV",
"AUDIO\\s1_i.WAV",
"AUDIO\\s1_j.WAV",
"AUDIO\\s1_k.WAV",
"AUDIO\\s1_l.WAV",
"AUDIO\\s3_a.WAV",
"AUDIO\\s3_b.WAV",
"AUDIO\\el3_a.WAV",
"AUDIO\\mf1_a.WAV",
"AUDIO\\mf2_a.WAV",
"AUDIO\\mf3_a.WAV",
"AUDIO\\mf3_b.WAV",
"AUDIO\\mf3_b1.WAV",
"AUDIO\\mf3_c.WAV",
"AUDIO\\mf4_a.WAV",
"AUDIO\\mf4_b.WAV",
"AUDIO\\mf4_c.WAV",
"AUDIO\\a1_a.WAV",
"AUDIO\\a3_a.WAV",
"AUDIO\\a5_a.WAV",
"AUDIO\\a4_a.WAV",
"AUDIO\\a4_b.WAV",
"AUDIO\\a4_c.WAV",
"AUDIO\\a4_d.WAV",
"AUDIO\\k1_a.WAV",
"AUDIO\\k3_a.WAV",
"AUDIO\\r1_a.WAV",
"AUDIO\\r2_a.WAV",
"AUDIO\\r2_b.WAV",
"AUDIO\\r2_c.WAV",
"AUDIO\\r2_d.WAV",
"AUDIO\\r2_e.WAV",
"AUDIO\\r2_f.WAV",
"AUDIO\\r2_g.WAV",
"AUDIO\\r2_h.WAV",
"AUDIO\\r5_a.WAV",
"AUDIO\\r6_a.WAV",
"AUDIO\\r6_a1.WAV",
"AUDIO\\r6_b.WAV",
"AUDIO\\lo2_a.WAV",
"AUDIO\\lo6_a.WAV",
"AUDIO\\yd2_a.WAV",
"AUDIO\\yd2_b.WAV",
"AUDIO\\yd2_c.WAV",
"AUDIO\\yd2_c1.WAV",
"AUDIO\\yd2_d.WAV",
"AUDIO\\yd2_e.WAV",
"AUDIO\\yd2_f.WAV",
"AUDIO\\yd2_g.WAV",
"AUDIO\\yd2_h.WAV",
"AUDIO\\yd2_ass.WAV",
"AUDIO\\yd2_ok.WAV",
"AUDIO\\h5_a.WAV",
"AUDIO\\h5_b.WAV",
"AUDIO\\h5_c.WAV",
"AUDIO\\ammu_a.WAV",
"AUDIO\\ammu_b.WAV",
"AUDIO\\ammu_c.WAV",
"AUDIO\\door_1.WAV",
"AUDIO\\door_2.WAV",
"AUDIO\\door_3.WAV",
"AUDIO\\door_4.WAV",
"AUDIO\\door_5.WAV",
"AUDIO\\door_6.WAV",
"AUDIO\\t3_a.WAV",
"AUDIO\\t3_b.WAV",
"AUDIO\\t3_c.WAV",
"AUDIO\\k1_b.WAV",
"AUDIO\\cat1.WAV"
};

329
src/audio/oal/aldlist.cpp Normal file
View file

@ -0,0 +1,329 @@
/*
* Copyright (c) 2006, Creative Labs Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided
* that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this list of conditions and
* the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, this list of conditions
* and the following disclaimer in the documentation and/or other materials provided with the distribution.
* * Neither the name of Creative Labs Inc. nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include "aldlist.h"
#ifdef AUDIO_OAL
/*
* Init call
*/
ALDeviceList::ALDeviceList()
{
ALDEVICEINFO ALDeviceInfo;
char *devices;
int index;
const char *defaultDeviceName;
const char *actualDeviceName;
// DeviceInfo vector stores, for each enumerated device, it's device name, selection status, spec version #, and extension support
vDeviceInfo.empty();
vDeviceInfo.reserve(10);
defaultDeviceIndex = 0;
if (alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT")) {
devices = (char *)alcGetString(NULL, ALC_DEVICE_SPECIFIER);
defaultDeviceName = (char *)alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
index = 0;
// go through device list (each device terminated with a single NULL, list terminated with double NULL)
while (*devices != NULL) {
if (strcmp(defaultDeviceName, devices) == 0) {
defaultDeviceIndex = index;
}
ALCdevice *device = alcOpenDevice(devices);
if (device) {
ALCcontext *context = alcCreateContext(device, NULL);
if (context) {
alcMakeContextCurrent(context);
// if new actual device name isn't already in the list, then add it...
actualDeviceName = alcGetString(device, ALC_DEVICE_SPECIFIER);
bool bNewName = true;
for (int i = 0; i < GetNumDevices(); i++) {
if (strcmp(GetDeviceName(i), actualDeviceName) == 0) {
bNewName = false;
}
}
if ((bNewName) && (actualDeviceName != NULL) && (strlen(actualDeviceName) > 0)) {
memset(&ALDeviceInfo, 0, sizeof(ALDEVICEINFO));
ALDeviceInfo.bSelected = true;
ALDeviceInfo.strDeviceName = std::string(actualDeviceName, strlen(actualDeviceName));
alcGetIntegerv(device, ALC_MAJOR_VERSION, sizeof(int), &ALDeviceInfo.iMajorVersion);
alcGetIntegerv(device, ALC_MINOR_VERSION, sizeof(int), &ALDeviceInfo.iMinorVersion);
ALDeviceInfo.pvstrExtensions = new std::vector<std::string>;
// Check for ALC Extensions
if (alcIsExtensionPresent(device, "ALC_EXT_CAPTURE") == AL_TRUE)
ALDeviceInfo.pvstrExtensions->push_back("ALC_EXT_CAPTURE");
if (alcIsExtensionPresent(device, "ALC_EXT_EFX") == AL_TRUE)
ALDeviceInfo.pvstrExtensions->push_back("ALC_EXT_EFX");
// Check for AL Extensions
if (alIsExtensionPresent("AL_EXT_OFFSET") == AL_TRUE)
ALDeviceInfo.pvstrExtensions->push_back("AL_EXT_OFFSET");
if (alIsExtensionPresent("AL_EXT_LINEAR_DISTANCE") == AL_TRUE)
ALDeviceInfo.pvstrExtensions->push_back("AL_EXT_LINEAR_DISTANCE");
if (alIsExtensionPresent("AL_EXT_EXPONENT_DISTANCE") == AL_TRUE)
ALDeviceInfo.pvstrExtensions->push_back("AL_EXT_EXPONENT_DISTANCE");
if (alIsExtensionPresent("EAX2.0") == AL_TRUE)
ALDeviceInfo.pvstrExtensions->push_back("EAX2.0");
if (alIsExtensionPresent("EAX3.0") == AL_TRUE)
ALDeviceInfo.pvstrExtensions->push_back("EAX3.0");
if (alIsExtensionPresent("EAX4.0") == AL_TRUE)
ALDeviceInfo.pvstrExtensions->push_back("EAX4.0");
if (alIsExtensionPresent("EAX5.0") == AL_TRUE)
ALDeviceInfo.pvstrExtensions->push_back("EAX5.0");
if (alIsExtensionPresent("EAX-RAM") == AL_TRUE)
ALDeviceInfo.pvstrExtensions->push_back("EAX-RAM");
// Get Source Count
ALDeviceInfo.uiSourceCount = GetMaxNumSources();
vDeviceInfo.push_back(ALDeviceInfo);
}
alcMakeContextCurrent(NULL);
alcDestroyContext(context);
}
alcCloseDevice(device);
}
devices += strlen(devices) + 1;
index += 1;
}
}
ResetFilters();
}
/*
* Exit call
*/
ALDeviceList::~ALDeviceList()
{
for (unsigned int i = 0; i < vDeviceInfo.size(); i++) {
if (vDeviceInfo[i].pvstrExtensions) {
vDeviceInfo[i].pvstrExtensions->empty();
delete vDeviceInfo[i].pvstrExtensions;
}
}
vDeviceInfo.empty();
}
/*
* Returns the number of devices in the complete device list
*/
int ALDeviceList::GetNumDevices()
{
return (int)vDeviceInfo.size();
}
/*
* Returns the device name at an index in the complete device list
*/
char * ALDeviceList::GetDeviceName(int index)
{
if (index < GetNumDevices())
return (char *)vDeviceInfo[index].strDeviceName.c_str();
else
return NULL;
}
/*
* Returns the major and minor version numbers for a device at a specified index in the complete list
*/
void ALDeviceList::GetDeviceVersion(int index, int *major, int *minor)
{
if (index < GetNumDevices()) {
if (major)
*major = vDeviceInfo[index].iMajorVersion;
if (minor)
*minor = vDeviceInfo[index].iMinorVersion;
}
return;
}
/*
* Returns the maximum number of Sources that can be generate on the given device
*/
unsigned int ALDeviceList::GetMaxNumSources(int index)
{
if (index < GetNumDevices())
return vDeviceInfo[index].uiSourceCount;
else
return 0;
}
/*
* Checks if the extension is supported on the given device
*/
bool ALDeviceList::IsExtensionSupported(int index, char *szExtName)
{
bool bReturn = false;
if (index < GetNumDevices()) {
for (unsigned int i = 0; i < vDeviceInfo[index].pvstrExtensions->size(); i++) {
if (!_stricmp(vDeviceInfo[index].pvstrExtensions->at(i).c_str(), szExtName)) {
bReturn = true;
break;
}
}
}
return bReturn;
}
/*
* returns the index of the default device in the complete device list
*/
int ALDeviceList::GetDefaultDevice()
{
return defaultDeviceIndex;
}
/*
* Deselects devices which don't have the specified minimum version
*/
void ALDeviceList::FilterDevicesMinVer(int major, int minor)
{
int dMajor, dMinor;
for (unsigned int i = 0; i < vDeviceInfo.size(); i++) {
GetDeviceVersion(i, &dMajor, &dMinor);
if ((dMajor < major) || ((dMajor == major) && (dMinor < minor))) {
vDeviceInfo[i].bSelected = false;
}
}
}
/*
* Deselects devices which don't have the specified maximum version
*/
void ALDeviceList::FilterDevicesMaxVer(int major, int minor)
{
int dMajor, dMinor;
for (unsigned int i = 0; i < vDeviceInfo.size(); i++) {
GetDeviceVersion(i, &dMajor, &dMinor);
if ((dMajor > major) || ((dMajor == major) && (dMinor > minor))) {
vDeviceInfo[i].bSelected = false;
}
}
}
/*
* Deselects device which don't support the given extension name
*/
void ALDeviceList::FilterDevicesExtension(char *szExtName)
{
bool bFound;
for (unsigned int i = 0; i < vDeviceInfo.size(); i++) {
bFound = false;
for (unsigned int j = 0; j < vDeviceInfo[i].pvstrExtensions->size(); j++) {
if (!_stricmp(vDeviceInfo[i].pvstrExtensions->at(j).c_str(), szExtName)) {
bFound = true;
break;
}
}
if (!bFound)
vDeviceInfo[i].bSelected = false;
}
}
/*
* Resets all filtering, such that all devices are in the list
*/
void ALDeviceList::ResetFilters()
{
for (int i = 0; i < GetNumDevices(); i++) {
vDeviceInfo[i].bSelected = true;
}
filterIndex = 0;
}
/*
* Gets index of first filtered device
*/
int ALDeviceList::GetFirstFilteredDevice()
{
int i;
for (i = 0; i < GetNumDevices(); i++) {
if (vDeviceInfo[i].bSelected == true) {
break;
}
}
filterIndex = i + 1;
return i;
}
/*
* Gets index of next filtered device
*/
int ALDeviceList::GetNextFilteredDevice()
{
int i;
for (i = filterIndex; i < GetNumDevices(); i++) {
if (vDeviceInfo[i].bSelected == true) {
break;
}
}
filterIndex = i + 1;
return i;
}
/*
* Internal function to detemine max number of Sources that can be generated
*/
unsigned int ALDeviceList::GetMaxNumSources()
{
ALuint uiSources[256];
unsigned int iSourceCount = 0;
// Clear AL Error Code
alGetError();
// Generate up to 256 Sources, checking for any errors
for (iSourceCount = 0; iSourceCount < 256; iSourceCount++)
{
alGenSources(1, &uiSources[iSourceCount]);
if (alGetError() != AL_NO_ERROR)
break;
}
// Release the Sources
alDeleteSources(iSourceCount, uiSources);
if (alGetError() != AL_NO_ERROR)
{
for (unsigned int i = 0; i < 256; i++)
{
alDeleteSources(1, &uiSources[i]);
}
}
return iSourceCount;
}
#endif

49
src/audio/oal/aldlist.h Normal file
View file

@ -0,0 +1,49 @@
#ifndef ALDEVICELIST_H
#define ALDEVICELIST_H
#include "oal_utils.h"
#ifdef AUDIO_OAL
#pragma warning(disable: 4786) //disable warning "identifier was truncated to '255' characters in the browser information"
#include <vector>
#include <string>
typedef struct
{
std::string strDeviceName;
int iMajorVersion;
int iMinorVersion;
unsigned int uiSourceCount;
std::vector<std::string> *pvstrExtensions;
bool bSelected;
} ALDEVICEINFO, *LPALDEVICEINFO;
class ALDeviceList
{
private:
std::vector<ALDEVICEINFO> vDeviceInfo;
int defaultDeviceIndex;
int filterIndex;
public:
ALDeviceList ();
~ALDeviceList ();
int GetNumDevices();
char *GetDeviceName(int index);
void GetDeviceVersion(int index, int *major, int *minor);
unsigned int GetMaxNumSources(int index);
bool IsExtensionSupported(int index, char *szExtName);
int GetDefaultDevice();
void FilterDevicesMinVer(int major, int minor);
void FilterDevicesMaxVer(int major, int minor);
void FilterDevicesExtension(char *szExtName);
void ResetFilters();
int GetFirstFilteredDevice();
int GetNextFilteredDevice();
private:
unsigned int GetMaxNumSources();
};
#endif
#endif // ALDEVICELIST_H

209
src/audio/oal/channel.cpp Normal file
View file

@ -0,0 +1,209 @@
#include "channel.h"
#ifdef AUDIO_OAL
#include "sampman.h"
extern bool IsFXSupported();
CChannel::CChannel()
{
alChannel = AL_NONE;
alFilter = AL_FILTER_NULL;
SetDefault();
}
void CChannel::SetDefault()
{
Buffer = AL_NONE;
Pitch = 1.0f;
Gain = 1.0f;
Mix = 0.0f;
Position[0] = 0.0f; Position[1] = 0.0f; Position[2] = 0.0f;
Distances[0] = 0.0f; Distances[1] = FLT_MAX;
LoopCount = 1;
LoopPoints[0] = 0; LoopPoints[1] = -1;
Frequency = MAX_FREQ;
}
void CChannel::Reset()
{
ClearBuffer();
SetDefault();
}
void CChannel::Init(bool Is2D)
{
ASSERT(!HasSource());
alGenSources(1, &alChannel);
if ( HasSource() )
{
alSourcei(alChannel, AL_SOURCE_RELATIVE, AL_TRUE);
if ( IsFXSupported() )
alSource3i(alChannel, AL_AUXILIARY_SEND_FILTER, AL_EFFECTSLOT_NULL, 0, AL_FILTER_NULL);
if ( Is2D )
{
alSource3f(alChannel, AL_POSITION, 0.0f, 0.0f, 0.0f);
alSourcef (alChannel, AL_GAIN, 1.0f);
}
else
{
if ( IsFXSupported() )
alGenFilters(1,&alFilter);
}
}
}
void CChannel::Term()
{
Stop();
if ( HasSource() )
{
if ( IsFXSupported() )
{
alSource3i(alChannel, AL_AUXILIARY_SEND_FILTER, AL_EFFECTSLOT_NULL, 0, AL_FILTER_NULL);
if(alFilter != AL_FILTER_NULL)
alDeleteFilters(1,&alFilter);
}
alDeleteSources(1, &alChannel);
}
alChannel = AL_NONE;
alFilter = AL_FILTER_NULL;
}
void CChannel::Start()
{
if ( !HasSource() ) return;
if ( LoopPoints[0] != 0 && LoopPoints[0] != -1 )
alBufferiv(Buffer, AL_LOOP_POINTS_SOFT, LoopPoints);
alSourcei (alChannel, AL_BUFFER, Buffer);
alSourcePlay(alChannel);
}
void CChannel::Stop()
{
if ( HasSource() )
alSourceStop(alChannel);
Reset();
}
bool CChannel::HasSource()
{
return alChannel != AL_NONE;
}
bool CChannel::IsUsed()
{
if ( HasSource() )
{
ALint sourceState;
alGetSourcei(alChannel, AL_SOURCE_STATE, &sourceState);
return sourceState == AL_PLAYING;
}
return false;
}
void CChannel::SetPitch(float pitch)
{
if ( !HasSource() ) return;
alSourcef(alChannel, AL_PITCH, pitch);
}
void CChannel::SetGain(float gain)
{
if ( !HasSource() ) return;
alSourcef(alChannel, AL_GAIN, gain);
}
void CChannel::SetVolume(int32 vol)
{
SetGain(ALfloat(vol) / MAX_VOLUME);
}
void CChannel::SetSampleID(uint32 nSfx)
{
Sample = nSfx;
}
void CChannel::SetFreq(int32 freq)
{
Frequency = freq;
}
void CChannel::SetCurrentFreq(uint32 freq)
{
SetPitch(ALfloat(freq) / Frequency);
}
void CChannel::SetLoopCount(int32 loopCount) // fake. TODO:
{
if ( !HasSource() ) return;
alSourcei(alChannel, AL_LOOPING, loopCount == 1 ? AL_FALSE : AL_TRUE);
}
void CChannel::SetLoopPoints(ALint start, ALint end)
{
LoopPoints[0] = start;
LoopPoints[1] = end;
}
void CChannel::SetPosition(float x, float y, float z)
{
if ( !HasSource() ) return;
alSource3f(alChannel, AL_POSITION, x, y, z);
}
void CChannel::SetDistances(float max, float min)
{
if ( !HasSource() ) return;
alSourcef (alChannel, AL_MAX_DISTANCE, max);
alSourcef (alChannel, AL_REFERENCE_DISTANCE, min);
alSourcef (alChannel, AL_MAX_GAIN, 1.0f);
alSourcef (alChannel, AL_ROLLOFF_FACTOR, 1.0f);
}
void CChannel::SetPan(uint32 pan)
{
SetPosition((pan-63)/64.0f, 0.0f, sqrtf(1.0f-SQR((pan-63)/64.0f)));
}
void CChannel::SetBuffer(ALuint buffer)
{
Buffer = buffer;
}
void CChannel::ClearBuffer()
{
if ( !HasSource() ) return;
SetBuffer(AL_NONE);
alSourcei(alChannel, AL_BUFFER, AL_NONE);
}
void CChannel::SetReverbMix(ALuint slot, float mix)
{
if ( !IsFXSupported() ) return;
if ( !HasSource() ) return;
if ( alFilter == AL_FILTER_NULL ) return;
Mix = mix;
EAX3_SetReverbMix(alFilter, mix);
alSource3i(alChannel, AL_AUXILIARY_SEND_FILTER, slot, 0, alFilter);
}
void CChannel::UpdateReverb(ALuint slot)
{
if ( !IsFXSupported() ) return;
if ( !HasSource() ) return;
if ( alFilter == AL_FILTER_NULL ) return;
EAX3_SetReverbMix(alFilter, Mix);
alSource3i(alChannel, AL_AUXILIARY_SEND_FILTER, slot, 0, alFilter);
}
#endif

51
src/audio/oal/channel.h Normal file
View file

@ -0,0 +1,51 @@
#pragma once
#include "common.h"
#ifdef AUDIO_OAL
#include "oal/oal_utils.h"
#include <AL/al.h>
#include <AL/alext.h>
#include <AL/efx.h>
class CChannel
{
ALuint alChannel;
ALuint alFilter;
ALuint Buffer;
float Pitch, Gain;
float Mix;
int32 Frequency;
float Position[3];
float Distances[2];
int32 LoopCount;
ALint LoopPoints[2];
uint32 Sample;
public:
CChannel();
void SetDefault();
void Reset();
void Init(bool Is2D = false);
void Term();
void Start();
void Stop();
bool HasSource();
bool IsUsed();
void SetPitch(float pitch);
void SetGain(float gain);
void SetVolume(int32 vol);
void SetSampleID(uint32 nSfx);
void SetFreq(int32 freq);
void SetCurrentFreq(uint32 freq);
void SetLoopCount(int32 loopCount); // fake
void SetLoopPoints(ALint start, ALint end);
void SetPosition(float x, float y, float z);
void SetDistances(float max, float min);
void SetPan(uint32 pan);
void SetBuffer(ALuint buffer);
void ClearBuffer();
void SetReverbMix(ALuint slot, float mix);
void UpdateReverb(ALuint slot);
};
#endif

176
src/audio/oal/oal_utils.cpp Normal file
View file

@ -0,0 +1,176 @@
#include "oal_utils.h"
#ifdef AUDIO_OAL
LPALGENEFFECTS alGenEffects;
LPALDELETEEFFECTS alDeleteEffects;
LPALISEFFECT alIsEffect;
LPALEFFECTI alEffecti;
LPALEFFECTIV alEffectiv;
LPALEFFECTF alEffectf;
LPALEFFECTFV alEffectfv;
LPALGETEFFECTI alGetEffecti;
LPALGETEFFECTIV alGetEffectiv;
LPALGETEFFECTF alGetEffectf;
LPALGETEFFECTFV alGetEffectfv;
LPALGENAUXILIARYEFFECTSLOTS alGenAuxiliaryEffectSlots;
LPALDELETEAUXILIARYEFFECTSLOTS alDeleteAuxiliaryEffectSlots;
LPALISAUXILIARYEFFECTSLOT alIsAuxiliaryEffectSlot;
LPALAUXILIARYEFFECTSLOTI alAuxiliaryEffectSloti;
LPALAUXILIARYEFFECTSLOTIV alAuxiliaryEffectSlotiv;
LPALAUXILIARYEFFECTSLOTF alAuxiliaryEffectSlotf;
LPALAUXILIARYEFFECTSLOTFV alAuxiliaryEffectSlotfv;
LPALGETAUXILIARYEFFECTSLOTI alGetAuxiliaryEffectSloti;
LPALGETAUXILIARYEFFECTSLOTIV alGetAuxiliaryEffectSlotiv;
LPALGETAUXILIARYEFFECTSLOTF alGetAuxiliaryEffectSlotf;
LPALGETAUXILIARYEFFECTSLOTFV alGetAuxiliaryEffectSlotfv;
LPALGENFILTERS alGenFilters;
LPALDELETEFILTERS alDeleteFilters;
LPALISFILTER alIsFilter;
LPALFILTERI alFilteri;
LPALFILTERIV alFilteriv;
LPALFILTERF alFilterf;
LPALFILTERFV alFilterfv;
LPALGETFILTERI alGetFilteri;
LPALGETFILTERIV alGetFilteriv;
LPALGETFILTERF alGetFilterf;
LPALGETFILTERFV alGetFilterfv;
void EFXInit()
{
if (alIsExtensionPresent((ALchar*)"EAX3.0"))
DEV("\nBIG EAX IN TOWN\n");
else
DEV("\nNO EAX\n");
/* Define a macro to help load the function pointers. */
#define LOAD_PROC(T, x) ((x) = (T)alGetProcAddress(#x))
LOAD_PROC(LPALGENEFFECTS, alGenEffects);
LOAD_PROC(LPALDELETEEFFECTS, alDeleteEffects);
LOAD_PROC(LPALISEFFECT, alIsEffect);
LOAD_PROC(LPALEFFECTI, alEffecti);
LOAD_PROC(LPALEFFECTIV, alEffectiv);
LOAD_PROC(LPALEFFECTF, alEffectf);
LOAD_PROC(LPALEFFECTFV, alEffectfv);
LOAD_PROC(LPALGETEFFECTI, alGetEffecti);
LOAD_PROC(LPALGETEFFECTIV, alGetEffectiv);
LOAD_PROC(LPALGETEFFECTF, alGetEffectf);
LOAD_PROC(LPALGETEFFECTFV, alGetEffectfv);
LOAD_PROC(LPALGENFILTERS, alGenFilters);
LOAD_PROC(LPALDELETEFILTERS, alDeleteFilters);
LOAD_PROC(LPALISFILTER, alIsFilter);
LOAD_PROC(LPALFILTERI, alFilteri);
LOAD_PROC(LPALFILTERIV, alFilteriv);
LOAD_PROC(LPALFILTERF, alFilterf);
LOAD_PROC(LPALFILTERFV, alFilterfv);
LOAD_PROC(LPALGETFILTERI, alGetFilteri);
LOAD_PROC(LPALGETFILTERIV, alGetFilteriv);
LOAD_PROC(LPALGETFILTERF, alGetFilterf);
LOAD_PROC(LPALGETFILTERFV, alGetFilterfv);
LOAD_PROC(LPALGENAUXILIARYEFFECTSLOTS, alGenAuxiliaryEffectSlots);
LOAD_PROC(LPALDELETEAUXILIARYEFFECTSLOTS, alDeleteAuxiliaryEffectSlots);
LOAD_PROC(LPALISAUXILIARYEFFECTSLOT, alIsAuxiliaryEffectSlot);
LOAD_PROC(LPALAUXILIARYEFFECTSLOTI, alAuxiliaryEffectSloti);
LOAD_PROC(LPALAUXILIARYEFFECTSLOTIV, alAuxiliaryEffectSlotiv);
LOAD_PROC(LPALAUXILIARYEFFECTSLOTF, alAuxiliaryEffectSlotf);
LOAD_PROC(LPALAUXILIARYEFFECTSLOTFV, alAuxiliaryEffectSlotfv);
LOAD_PROC(LPALGETAUXILIARYEFFECTSLOTI, alGetAuxiliaryEffectSloti);
LOAD_PROC(LPALGETAUXILIARYEFFECTSLOTIV, alGetAuxiliaryEffectSlotiv);
LOAD_PROC(LPALGETAUXILIARYEFFECTSLOTF, alGetAuxiliaryEffectSlotf);
LOAD_PROC(LPALGETAUXILIARYEFFECTSLOTFV, alGetAuxiliaryEffectSlotfv);
#undef LOAD_PROC
}
void SetEffectsLevel(ALuint uiFilter, float level)
{
alFilteri(uiFilter, AL_FILTER_TYPE, AL_FILTER_LOWPASS);
alFilterf(uiFilter, AL_LOWPASS_GAIN, 1.0f);
alFilterf(uiFilter, AL_LOWPASS_GAINHF, level);
}
static inline float gain_to_mB(float gain)
{
return (gain > 1e-5f) ? (float)(log10f(gain) * 2000.0f) : -10000l;
}
static inline float mB_to_gain(float millibels)
{
return (millibels > -10000.0f) ? powf(10.0f, millibels/2000.0f) : 0.0f;
}
static inline FLOAT clampF(FLOAT val, FLOAT minval, FLOAT maxval)
{
if(val >= maxval) return maxval;
if(val <= minval) return minval;
return val;
}
void EAX3_Set(ALuint effect, const EAXLISTENERPROPERTIES *props)
{
alEffecti (effect, AL_EFFECT_TYPE, AL_EFFECT_EAXREVERB);
alEffectf (effect, AL_EAXREVERB_DENSITY, clampF(powf(props->flEnvironmentSize, 3.0f) / 16.0f, 0.0f, 1.0f));
alEffectf (effect, AL_EAXREVERB_DIFFUSION, props->flEnvironmentDiffusion);
alEffectf (effect, AL_EAXREVERB_GAIN, mB_to_gain((float)props->lRoom));
alEffectf (effect, AL_EAXREVERB_GAINHF, mB_to_gain((float)props->lRoomHF));
alEffectf (effect, AL_EAXREVERB_GAINLF, mB_to_gain((float)props->lRoomLF));
alEffectf (effect, AL_EAXREVERB_DECAY_TIME, props->flDecayTime);
alEffectf (effect, AL_EAXREVERB_DECAY_HFRATIO, props->flDecayHFRatio);
alEffectf (effect, AL_EAXREVERB_DECAY_LFRATIO, props->flDecayLFRatio);
alEffectf (effect, AL_EAXREVERB_REFLECTIONS_GAIN, clampF(mB_to_gain((float)props->lReflections), AL_EAXREVERB_MIN_REFLECTIONS_GAIN, AL_EAXREVERB_MAX_REFLECTIONS_GAIN));
alEffectf (effect, AL_EAXREVERB_REFLECTIONS_DELAY, props->flReflectionsDelay);
alEffectfv(effect, AL_EAXREVERB_REFLECTIONS_PAN, &props->vReflectionsPan.x);
alEffectf (effect, AL_EAXREVERB_LATE_REVERB_GAIN, clampF(mB_to_gain((float)props->lReverb), AL_EAXREVERB_MIN_LATE_REVERB_GAIN, AL_EAXREVERB_MAX_LATE_REVERB_GAIN));
alEffectf (effect, AL_EAXREVERB_LATE_REVERB_DELAY, props->flReverbDelay);
alEffectfv(effect, AL_EAXREVERB_LATE_REVERB_PAN, &props->vReverbPan.x);
alEffectf (effect, AL_EAXREVERB_ECHO_TIME, props->flEchoTime);
alEffectf (effect, AL_EAXREVERB_ECHO_DEPTH, props->flEchoDepth);
alEffectf (effect, AL_EAXREVERB_MODULATION_TIME, props->flModulationTime);
alEffectf (effect, AL_EAXREVERB_MODULATION_DEPTH, props->flModulationDepth);
alEffectf (effect, AL_EAXREVERB_AIR_ABSORPTION_GAINHF, clampF(mB_to_gain(props->flAirAbsorptionHF), AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF, AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF));
alEffectf (effect, AL_EAXREVERB_HFREFERENCE, props->flHFReference);
alEffectf (effect, AL_EAXREVERB_LFREFERENCE, props->flLFReference);
alEffectf (effect, AL_EAXREVERB_ROOM_ROLLOFF_FACTOR, props->flRoomRolloffFactor);
alEffecti (effect, AL_EAXREVERB_DECAY_HFLIMIT, (props->ulFlags&EAXLISTENERFLAGS_DECAYHFLIMIT) ? AL_TRUE : AL_FALSE);
}
void EFX_Set(ALuint effect, const EAXLISTENERPROPERTIES *props)
{
alEffecti(effect, AL_EFFECT_TYPE, AL_EFFECT_REVERB);
alEffectf(effect, AL_REVERB_DENSITY, clampF(powf(props->flEnvironmentSize, 3.0f) / 16.0f, 0.0f, 1.0f));
alEffectf(effect, AL_REVERB_DIFFUSION, props->flEnvironmentDiffusion);
alEffectf(effect, AL_REVERB_GAIN, mB_to_gain((float)props->lRoom));
alEffectf(effect, AL_REVERB_GAINHF, mB_to_gain((float)props->lRoomHF));
alEffectf(effect, AL_REVERB_DECAY_TIME, props->flDecayTime);
alEffectf(effect, AL_REVERB_DECAY_HFRATIO, props->flDecayHFRatio);
alEffectf(effect, AL_REVERB_REFLECTIONS_GAIN, clampF(mB_to_gain((float)props->lReflections), AL_EAXREVERB_MIN_REFLECTIONS_GAIN, AL_EAXREVERB_MAX_REFLECTIONS_GAIN));
alEffectf(effect, AL_REVERB_REFLECTIONS_DELAY, props->flReflectionsDelay);
alEffectf(effect, AL_REVERB_LATE_REVERB_GAIN, clampF(mB_to_gain((float)props->lReverb), AL_EAXREVERB_MIN_LATE_REVERB_GAIN, AL_EAXREVERB_MAX_LATE_REVERB_GAIN));
alEffectf(effect, AL_REVERB_LATE_REVERB_DELAY, props->flReverbDelay);
alEffectf(effect, AL_REVERB_AIR_ABSORPTION_GAINHF, clampF(mB_to_gain(props->flAirAbsorptionHF), AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF, AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF));
alEffectf(effect, AL_REVERB_ROOM_ROLLOFF_FACTOR, props->flRoomRolloffFactor);
alEffecti(effect, AL_REVERB_DECAY_HFLIMIT, (props->ulFlags&EAXLISTENERFLAGS_DECAYHFLIMIT) ? AL_TRUE : AL_FALSE);
}
void EAX3_SetReverbMix(ALuint filter, float mix)
{
//long vol=(long)linear_to_dB(mix);
//DSPROPERTY_EAXBUFFER_ROOMHF,
//DSPROPERTY_EAXBUFFER_ROOM,
//DSPROPERTY_EAXBUFFER_REVERBMIX,
long mbvol = gain_to_mB(mix);
float mb = mbvol;
float mbhf = mbvol;
alFilteri(filter, AL_FILTER_TYPE, AL_FILTER_LOWPASS);
alFilterf(filter, AL_LOWPASS_GAIN, mB_to_gain(Min(mb, 0.0f)));
alFilterf(filter, AL_LOWPASS_GAINHF, mB_to_gain(mbhf));
}
#endif

48
src/audio/oal/oal_utils.h Normal file
View file

@ -0,0 +1,48 @@
#pragma once
#include "common.h"
#ifdef AUDIO_OAL
#include "eax.h"
#include "AL/efx.h"
void EFXInit();
void EAX3_Set(ALuint effect, const EAXLISTENERPROPERTIES *props);
void EFX_Set(ALuint effect, const EAXLISTENERPROPERTIES *props);
void EAX3_SetReverbMix(ALuint filter, float mix);
void SetEffectsLevel(ALuint uiFilter, float level);
extern LPALGENEFFECTS alGenEffects;
extern LPALDELETEEFFECTS alDeleteEffects;
extern LPALISEFFECT alIsEffect;
extern LPALEFFECTI alEffecti;
extern LPALEFFECTIV alEffectiv;
extern LPALEFFECTF alEffectf;
extern LPALEFFECTFV alEffectfv;
extern LPALGETEFFECTI alGetEffecti;
extern LPALGETEFFECTIV alGetEffectiv;
extern LPALGETEFFECTF alGetEffectf;
extern LPALGETEFFECTFV alGetEffectfv;
extern LPALGENAUXILIARYEFFECTSLOTS alGenAuxiliaryEffectSlots;
extern LPALDELETEAUXILIARYEFFECTSLOTS alDeleteAuxiliaryEffectSlots;
extern LPALISAUXILIARYEFFECTSLOT alIsAuxiliaryEffectSlot;
extern LPALAUXILIARYEFFECTSLOTI alAuxiliaryEffectSloti;
extern LPALAUXILIARYEFFECTSLOTIV alAuxiliaryEffectSlotiv;
extern LPALAUXILIARYEFFECTSLOTF alAuxiliaryEffectSlotf;
extern LPALAUXILIARYEFFECTSLOTFV alAuxiliaryEffectSlotfv;
extern LPALGETAUXILIARYEFFECTSLOTI alGetAuxiliaryEffectSloti;
extern LPALGETAUXILIARYEFFECTSLOTIV alGetAuxiliaryEffectSlotiv;
extern LPALGETAUXILIARYEFFECTSLOTF alGetAuxiliaryEffectSlotf;
extern LPALGETAUXILIARYEFFECTSLOTFV alGetAuxiliaryEffectSlotfv;
extern LPALGENFILTERS alGenFilters;
extern LPALDELETEFILTERS alDeleteFilters;
extern LPALISFILTER alIsFilter;
extern LPALFILTERI alFilteri;
extern LPALFILTERIV alFilteriv;
extern LPALFILTERF alFilterf;
extern LPALFILTERFV alFilterfv;
extern LPALGETFILTERI alGetFilteri;
extern LPALGETFILTERIV alGetFilteriv;
extern LPALGETFILTERF alGetFilterf;
extern LPALGETFILTERFV alGetFilterfv;
#endif

118
src/audio/oal/stream.cpp Normal file
View file

@ -0,0 +1,118 @@
#include "stream.h"
#include "common.h"
#ifdef AUDIO_OAL
void CStream::Initialise()
{
//mpg123_init();
}
void CStream::Terminate()
{
//mpg123_exit();
}
CStream::CStream(char *filename, ALuint &source, ALuint (&buffers)[NUM_STREAMBUFFERS]) :
m_alSource(source),
m_alBuffers(buffers),
m_nBitRate(0),
m_nFormat(0),
m_nFreq(0),
m_nLength(0),
m_nLengthMS(0),
m_nBufferSize(0),
m_pBuffer(NULL),
m_bIsOpened(false),
m_bPaused(true)
{
strcpy(m_aFilename, filename);
//DEV("Stream %s\n", m_aFilename);
/*
if ( true )
{
m_nBitRate = (wBitsPerSample * nChannels * wfex.nSamplesPerSec)/1000;
m_nLength = ulDataSize;
m_nLengthMS = m_nLength*8 / m_nBitRate;
m_nBufferSize = nAvgBytesPerSec >> 2;
m_nBufferSize -= (m_nLength % wfex.nBlockAlign);
m_pBuffer = malloc(m_nBufferSize);
m_bIsOpened = true;
return;
}*/
}
CStream::~CStream()
{
Delete();
}
void CStream::Delete()
{
if ( m_pBuffer )
{
free(m_pBuffer);
m_pBuffer = NULL;
}
}
bool CStream::IsOpened()
{
return m_bIsOpened;
}
bool CStream::IsPlaying()
{
return false;
}
void CStream::SetPause(bool bPause)
{
}
void CStream::SetVolume(uint32 nVol)
{
}
void CStream::SetPan(uint8 nPan)
{
}
void CStream::SetPos(uint32 nPos)
{
}
uint32 CStream::GetPos()
{
return 0;
}
uint32 CStream::GetLength()
{
return m_nLengthMS;
}
bool CStream::Setup()
{
if ( !IsOpened() )
return false;
return IsOpened();
}
void CStream::Start()
{
}
void CStream::Update()
{
if ( !IsOpened() )
return;
}
#endif

57
src/audio/oal/stream.h Normal file
View file

@ -0,0 +1,57 @@
#pragma once
#include "common.h"
#ifdef AUDIO_OAL
#include <AL/al.h>
#define NUM_STREAMBUFFERS 5
#define STREAMBUFFER_SIZE 0x4000
class CStream
{
char m_aFilename[128];
ALuint &m_alSource;
ALuint (&m_alBuffers)[NUM_STREAMBUFFERS];
bool m_bIsOpened;
bool m_bPaused;
uint32 m_nLength;
uint32 m_nLengthMS;
uint32 m_nBitRate;
unsigned long m_nFormat;
unsigned long m_nFreq;
uint32 m_nBufferSize;
void *m_pBuffer;
ALint iTotalBuffersProcessed;
bool FillBuffer(ALuint alBuffer);
int32 FillBuffers();
public:
static void Initialise();
static void Terminate();
CStream(char *filename, ALuint &source, ALuint (&buffers)[NUM_STREAMBUFFERS]);
~CStream();
void Delete();
bool IsOpened();
bool IsPlaying();
void SetPause (bool bPause);
void SetVolume(uint32 nVol);
void SetPan (uint8 nPan);
void SetPos (uint32 nPos);
uint32 GetPos();
uint32 GetLength();
bool Setup();
void Start();
void Update(void);
};
#endif

1404
src/audio/openal/samp_oal.cpp
View file

File diff suppressed because it is too large Load diff

340
src/audio/openal/samp_oal.h
View file

@ -1,340 +0,0 @@
#pragma once
#include "common.h"
#include "AudioSamples.h"
#define MAX_VOLUME 127
//#define MAX_FREQ 22050
#define MAX_FREQ 32000
struct tSample {
int32 nOffset;
uint32 nSize;
int32 nFrequency;
int32 nLoopStart;
int32 nLoopEnd;
};
enum
{
SAMPLEBANK_MAIN,
SAMPLEBANK_PED,
MAX_SAMPLEBANKS,
SAMPLEBANK_INVALID
};
#define MAX_PEDSFX 7
#define PED_BLOCKSIZE 79000
//#define MAXCHANNELS 21 android
#define MAXCHANNELS 28
#define MAX2DCHANNELS 1
#define CHANNEL2D MAXCHANNELS
#define MAX_STREAMS 2
struct ALCdevice_struct;
struct ALCcontext_struct;
typedef struct ALCdevice_struct ALCdevice;
typedef struct ALCcontext_struct ALCcontext;
class cSampleManager
{
int field_0;
ALCdevice *m_pDevice;
ALCcontext *m_pContext;
uint8 m_nEffectsVolume;
uint8 m_nMusicVolume;
uint8 m_nEffectsFadeVolume;
uint8 m_nMusicFadeVolume;
uint8 m_nMonoMode;
char _pad0[3];
tSample m_aSamples[TOTAL_AUDIO_SAMPLES];
public:
cSampleManager(void);
~cSampleManager(void);
void SetSpeakerConfig(int32 nConfig);
uint32 GetMaximumSupportedChannels(void);
uint32 GetNum3DProvidersAvailable();
void SetNum3DProvidersAvailable(uint32 num);
char *Get3DProviderName(uint8 id);
void Set3DProviderName(uint8 id, char *name);
int8 GetCurrent3DProviderIndex(void);
int8 SetCurrent3DProvider(uint8 which);
bool IsMP3RadioChannelAvailable(void);
void ReleaseDigitalHandle (void);
void ReacquireDigitalHandle(void);
bool Initialise(void);
void Terminate (void);
void UpdateSoundBuffers(void);
bool CheckForAnAudioFileOnCD(void);
char GetCDAudioDriveLetter (void);
void UpdateEffectsVolume(void);
void SetEffectsMasterVolume(uint8 nVolume);
void SetMusicMasterVolume (uint8 nVolume);
void SetEffectsFadeVolume (uint8 nVolume);
void SetMusicFadeVolume (uint8 nVolume);
void SetMonoMode (uint8 nMode);
bool LoadSampleBank (uint8 nBank);
void UnloadSampleBank (uint8 nBank);
bool IsSampleBankLoaded(uint8 nBank);
bool IsPedCommentLoaded(uint32 nComment);
bool LoadPedComment (uint32 nComment);
int32 GetBankContainingSound(uint32 offset);
int32 _GetPedCommentSlot(uint32 nComment);
int32 GetSampleBaseFrequency (uint32 nSample);
int32 GetSampleLoopStartOffset(uint32 nSample);
int32 GetSampleLoopEndOffset (uint32 nSample);
uint32 GetSampleLength (uint32 nSample);
bool UpdateReverb(void);
void SetChannelReverbFlag (uint32 nChannel, uint8 nReverbFlag);
bool InitialiseChannel (uint32 nChannel, uint32 nSfx, uint8 nBank);
void SetChannelEmittingVolume(uint32 nChannel, uint32 nVolume);
void SetChannel3DPosition (uint32 nChannel, float fX, float fY, float fZ);
void SetChannel3DDistances (uint32 nChannel, float fMax, float fMin);
void SetChannelVolume (uint32 nChannel, uint32 nVolume);
void SetChannelPan (uint32 nChannel, uint32 nPan);
void SetChannelFrequency (uint32 nChannel, uint32 nFreq);
void SetChannelLoopPoints (uint32 nChannel, uint32 nLoopStart, int32 nLoopEnd);
void SetChannelLoopCount (uint32 nChannel, uint32 nLoopCount);
bool GetChannelUsedFlag (uint32 nChannel);
void StartChannel (uint32 nChannel);
void StopChannel (uint32 nChannel);
void PreloadStreamedFile (uint8 nFile, uint8 nStream);
void PauseStream (uint8 nPauseFlag, uint8 nStream);
void StartPreloadedStreamedFile (uint8 nStream);
bool StartStreamedFile (uint8 nFile, uint32 nPos, uint8 nStream);
void StopStreamedFile (uint8 nStream);
int32 GetStreamedFilePosition (uint8 nStream);
void SetStreamedVolumeAndPan(uint8 nVolume, uint8 nPan, uint8 nEffectFlag, uint8 nStream);
int32 GetStreamedFileLength (uint8 nStream);
bool IsStreamPlaying (uint8 nStream);
void Service(void);
bool InitialiseSampleBanks(void);
};
extern cSampleManager SampleManager;
extern int32 BankStartOffset[MAX_SAMPLEBANKS];
static char StreamedNameTable[][25]=
{
"AUDIO\\HEAD.MP3",
"AUDIO\\CLASS.MP3",
"AUDIO\\KJAH.MP3",
"AUDIO\\RISE.MP3",
"AUDIO\\LIPS.MP3",
"AUDIO\\GAME.MP3",
"AUDIO\\MSX.MP3",
"AUDIO\\FLASH.MP3",
"AUDIO\\CHAT.MP3",
"AUDIO\\HEAD.MP3",
"AUDIO\\POLICE.MP3",
"AUDIO\\CITY.MP3",
"AUDIO\\WATER.MP3",
"AUDIO\\COMOPEN.MP3",
"AUDIO\\SUBOPEN.MP3",
"AUDIO\\JB.MP3",
"AUDIO\\BET.MP3",
"AUDIO\\L1_LG.MP3",
"AUDIO\\L2_DSB.MP3",
"AUDIO\\L3_DM.MP3",
"AUDIO\\L4_PAP.MP3",
"AUDIO\\L5_TFB.MP3",
"AUDIO\\J0_DM2.MP3",
"AUDIO\\J1_LFL.MP3",
"AUDIO\\J2_KCL.MP3",
"AUDIO\\J3_VH.MP3",
"AUDIO\\J4_ETH.MP3",
"AUDIO\\J5_DST.MP3",
"AUDIO\\J6_TBJ.MP3",
"AUDIO\\T1_TOL.MP3",
"AUDIO\\T2_TPU.MP3",
"AUDIO\\T3_MAS.MP3",
"AUDIO\\T4_TAT.MP3",
"AUDIO\\T5_BF.MP3",
"AUDIO\\S0_MAS.MP3",
"AUDIO\\S1_PF.MP3",
"AUDIO\\S2_CTG.MP3",
"AUDIO\\S3_RTC.MP3",
"AUDIO\\S5_LRQ.MP3",
"AUDIO\\S4_BDBA.MP3",
"AUDIO\\S4_BDBB.MP3",
"AUDIO\\S2_CTG2.MP3",
"AUDIO\\S4_BDBD.MP3",
"AUDIO\\S5_LRQB.MP3",
"AUDIO\\S5_LRQC.MP3",
"AUDIO\\A1_SSO.MP3",
"AUDIO\\A2_PP.MP3",
"AUDIO\\A3_SS.MP3",
"AUDIO\\A4_PDR.MP3",
"AUDIO\\A5_K2FT.MP3",
"AUDIO\\K1_KBO.MP3",
"AUDIO\\K2_GIS.MP3",
"AUDIO\\K3_DS.MP3",
"AUDIO\\K4_SHI.MP3",
"AUDIO\\K5_SD.MP3",
"AUDIO\\R0_PDR2.MP3",
"AUDIO\\R1_SW.MP3",
"AUDIO\\R2_AP.MP3",
"AUDIO\\R3_ED.MP3",
"AUDIO\\R4_GF.MP3",
"AUDIO\\R5_PB.MP3",
"AUDIO\\R6_MM.MP3",
"AUDIO\\D1_STOG.MP3",
"AUDIO\\D2_KK.MP3",
"AUDIO\\D3_ADO.MP3",
"AUDIO\\D5_ES.MP3",
"AUDIO\\D7_MLD.MP3",
"AUDIO\\D4_GTA.MP3",
"AUDIO\\D4_GTA2.MP3",
"AUDIO\\D6_STS.MP3",
"AUDIO\\A6_BAIT.MP3",
"AUDIO\\A7_ETG.MP3",
"AUDIO\\A8_PS.MP3",
"AUDIO\\A9_ASD.MP3",
"AUDIO\\K4_SHI2.MP3",
"AUDIO\\C1_TEX.MP3",
"AUDIO\\EL_PH1.MP3",
"AUDIO\\EL_PH2.MP3",
"AUDIO\\EL_PH3.MP3",
"AUDIO\\EL_PH4.MP3",
"AUDIO\\YD_PH1.MP3",
"AUDIO\\YD_PH2.MP3",
"AUDIO\\YD_PH3.MP3",
"AUDIO\\YD_PH4.MP3",
"AUDIO\\HD_PH1.MP3",
"AUDIO\\HD_PH2.MP3",
"AUDIO\\HD_PH3.MP3",
"AUDIO\\HD_PH4.MP3",
"AUDIO\\HD_PH5.MP3",
"AUDIO\\MT_PH1.MP3",
"AUDIO\\MT_PH2.MP3",
"AUDIO\\MT_PH3.MP3",
"AUDIO\\MT_PH4.MP3",
"AUDIO\\MISCOM.MP3",
"AUDIO\\END.MP3",
"AUDIO\\lib_a1.MP3",
"AUDIO\\lib_a2.MP3",
"AUDIO\\lib_a.MP3",
"AUDIO\\lib_b.MP3",
"AUDIO\\lib_c.MP3",
"AUDIO\\lib_d.MP3",
"AUDIO\\l2_a.MP3",
"AUDIO\\j4t_1.MP3",
"AUDIO\\j4t_2.MP3",
"AUDIO\\j4t_3.MP3",
"AUDIO\\j4t_4.MP3",
"AUDIO\\j4_a.MP3",
"AUDIO\\j4_b.MP3",
"AUDIO\\j4_c.MP3",
"AUDIO\\j4_d.MP3",
"AUDIO\\j4_e.MP3",
"AUDIO\\j4_f.MP3",
"AUDIO\\j6_1.MP3",
"AUDIO\\j6_a.MP3",
"AUDIO\\j6_b.MP3",
"AUDIO\\j6_c.MP3",
"AUDIO\\j6_d.MP3",
"AUDIO\\t4_a.MP3",
"AUDIO\\s1_a.MP3",
"AUDIO\\s1_a1.MP3",
"AUDIO\\s1_b.MP3",
"AUDIO\\s1_c.MP3",
"AUDIO\\s1_c1.MP3",
"AUDIO\\s1_d.MP3",
"AUDIO\\s1_e.MP3",
"AUDIO\\s1_f.MP3",
"AUDIO\\s1_g.MP3",
"AUDIO\\s1_h.MP3",
"AUDIO\\s1_i.MP3",
"AUDIO\\s1_j.MP3",
"AUDIO\\s1_k.MP3",
"AUDIO\\s1_l.MP3",
"AUDIO\\s3_a.MP3",
"AUDIO\\s3_b.MP3",
"AUDIO\\el3_a.MP3",
"AUDIO\\mf1_a.MP3",
"AUDIO\\mf2_a.MP3",
"AUDIO\\mf3_a.MP3",
"AUDIO\\mf3_b.MP3",
"AUDIO\\mf3_b1.MP3",
"AUDIO\\mf3_c.MP3",
"AUDIO\\mf4_a.MP3",
"AUDIO\\mf4_b.MP3",
"AUDIO\\mf4_c.MP3",
"AUDIO\\a1_a.MP3",
"AUDIO\\a3_a.MP3",
"AUDIO\\a5_a.MP3",
"AUDIO\\a4_a.MP3",
"AUDIO\\a4_b.MP3",
"AUDIO\\a4_c.MP3",
"AUDIO\\a4_d.MP3",
"AUDIO\\k1_a.MP3",
"AUDIO\\k3_a.MP3",
"AUDIO\\r1_a.MP3",
"AUDIO\\r2_a.MP3",
"AUDIO\\r2_b.MP3",
"AUDIO\\r2_c.MP3",
"AUDIO\\r2_d.MP3",
"AUDIO\\r2_e.MP3",
"AUDIO\\r2_f.MP3",
"AUDIO\\r2_g.MP3",
"AUDIO\\r2_h.MP3",
"AUDIO\\r5_a.MP3",
"AUDIO\\r6_a.MP3",
"AUDIO\\r6_a1.MP3",
"AUDIO\\r6_b.MP3",
"AUDIO\\lo2_a.MP3",
"AUDIO\\lo6_a.MP3",
"AUDIO\\yd2_a.MP3",
"AUDIO\\yd2_b.MP3",
"AUDIO\\yd2_c.MP3",
"AUDIO\\yd2_c1.MP3",
"AUDIO\\yd2_d.MP3",
"AUDIO\\yd2_e.MP3",
"AUDIO\\yd2_f.MP3",
"AUDIO\\yd2_g.MP3",
"AUDIO\\yd2_h.MP3",
"AUDIO\\yd2_ass.MP3",
"AUDIO\\yd2_ok.MP3",
"AUDIO\\h5_a.MP3",
"AUDIO\\h5_b.MP3",
"AUDIO\\h5_c.MP3",
"AUDIO\\ammu_a.MP3",
"AUDIO\\ammu_b.MP3",
"AUDIO\\ammu_c.MP3",
"AUDIO\\door_1.MP3",
"AUDIO\\door_2.MP3",
"AUDIO\\door_3.MP3",
"AUDIO\\door_4.MP3",
"AUDIO\\door_5.MP3",
"AUDIO\\door_6.MP3",
"AUDIO\\t3_a.MP3",
"AUDIO\\t3_b.MP3",
"AUDIO\\t3_c.MP3",
"AUDIO\\k1_b.MP3",
"AUDIO\\cat1.MP3"
};

7
src/audio/sampman.cpp
View file

@ -1,7 +0,0 @@
#pragma once
#include "common.h"
#ifndef OPENAL
#include "miles\sampman_mss.cpp"
#else
#include "openal\samp_oal.cpp"
#endif

348
src/audio/sampman.h
View file

@ -1,7 +1,345 @@
#pragma once
#include "common.h"
#ifndef OPENAL
#include "miles\sampman_mss.h"
#else
#include "openal\samp_oal.h"
#endif
#include "AudioSamples.h"
#define MAX_VOLUME 127
#define MAX_FREQ 22050
struct tSample {
int32 nOffset;
uint32 nSize;
int32 nFrequency;
int32 nLoopStart;
int32 nLoopEnd;
};
enum
{
SAMPLEBANK_MAIN,
SAMPLEBANK_PED,
MAX_SAMPLEBANKS,
SAMPLEBANK_INVALID
};
#define MAX_PEDSFX 7
#define PED_BLOCKSIZE 79000
#define MAXPROVIDERS 64
#define MAXCHANNELS 28
#define MAXCHANNELS_SURROUND 24
#define MAX2DCHANNELS 1
#define CHANNEL2D MAXCHANNELS
#define MAX_STREAMS 2
#define DIGITALRATE 32000
#define DIGITALBITS 16
#define DIGITALCHANNELS 2
#define MAX_DIGITAL_MIXER_CHANNELS 32
class cSampleManager
{
uint8 m_nEffectsVolume;
uint8 m_nMusicVolume;
uint8 m_nEffectsFadeVolume;
uint8 m_nMusicFadeVolume;
uint8 m_nMonoMode;
char unk;
char m_szCDRomRootPath[80];
bool m_bInitialised;
uint8 m_nNumberOfProviders;
char *m_aAudioProviders[MAXPROVIDERS];
tSample m_aSamples[TOTAL_AUDIO_SAMPLES];
public:
cSampleManager(void);
~cSampleManager(void);
void SetSpeakerConfig(int32 nConfig);
uint32 GetMaximumSupportedChannels(void);
uint32 GetNum3DProvidersAvailable(void);
void SetNum3DProvidersAvailable(uint32 num);
char *Get3DProviderName(uint8 id);
void Set3DProviderName(uint8 id, char *name);
int8 GetCurrent3DProviderIndex(void);
int8 SetCurrent3DProvider(uint8 which);
bool IsMP3RadioChannelAvailable(void);
void ReleaseDigitalHandle (void);
void ReacquireDigitalHandle(void);
bool Initialise(void);
void Terminate (void);
#ifdef AUDIO_OAL
void UpdateSoundBuffers(void);
#endif
bool CheckForAnAudioFileOnCD(void);
char GetCDAudioDriveLetter (void);
void UpdateEffectsVolume(void);
void SetEffectsMasterVolume(uint8 nVolume);
void SetMusicMasterVolume (uint8 nVolume);
void SetEffectsFadeVolume (uint8 nVolume);
void SetMusicFadeVolume (uint8 nVolume);
void SetMonoMode (uint8 nMode);
bool LoadSampleBank (uint8 nBank);
void UnloadSampleBank (uint8 nBank);
bool IsSampleBankLoaded(uint8 nBank);
bool IsPedCommentLoaded(uint32 nComment);
bool LoadPedComment (uint32 nComment);
int32 GetBankContainingSound(uint32 offset);
int32 _GetPedCommentSlot(uint32 nComment);
int32 GetSampleBaseFrequency (uint32 nSample);
int32 GetSampleLoopStartOffset(uint32 nSample);
int32 GetSampleLoopEndOffset (uint32 nSample);
uint32 GetSampleLength (uint32 nSample);
bool UpdateReverb(void);
void SetChannelReverbFlag (uint32 nChannel, uint8 nReverbFlag);
bool InitialiseChannel (uint32 nChannel, uint32 nSfx, uint8 nBank);
void SetChannelEmittingVolume(uint32 nChannel, uint32 nVolume);
void SetChannel3DPosition (uint32 nChannel, float fX, float fY, float fZ);
void SetChannel3DDistances (uint32 nChannel, float fMax, float fMin);
void SetChannelVolume (uint32 nChannel, uint32 nVolume);
void SetChannelPan (uint32 nChannel, uint32 nPan);
void SetChannelFrequency (uint32 nChannel, uint32 nFreq);
void SetChannelLoopPoints (uint32 nChannel, uint32 nLoopStart, int32 nLoopEnd);
void SetChannelLoopCount (uint32 nChannel, uint32 nLoopCount);
bool GetChannelUsedFlag (uint32 nChannel);
void StartChannel (uint32 nChannel);
void StopChannel (uint32 nChannel);
void PreloadStreamedFile (uint8 nFile, uint8 nStream);
void PauseStream (uint8 nPauseFlag, uint8 nStream);
void StartPreloadedStreamedFile (uint8 nStream);
bool StartStreamedFile (uint8 nFile, uint32 nPos, uint8 nStream);
void StopStreamedFile (uint8 nStream);
int32 GetStreamedFilePosition (uint8 nStream);
void SetStreamedVolumeAndPan(uint8 nVolume, uint8 nPan, uint8 nEffectFlag, uint8 nStream);
int32 GetStreamedFileLength (uint8 nStream);
bool IsStreamPlaying (uint8 nStream);
#ifdef AUDIO_OAL
void Service(void);
#endif
bool InitialiseSampleBanks(void);
};
extern cSampleManager SampleManager;
extern uint32 BankStartOffset[MAX_SAMPLEBANKS];
static char StreamedNameTable[][25]=
{
"AUDIO\\HEAD.WAV",
"AUDIO\\CLASS.WAV",
"AUDIO\\KJAH.WAV",
"AUDIO\\RISE.WAV",
"AUDIO\\LIPS.WAV",
"AUDIO\\GAME.WAV",
"AUDIO\\MSX.WAV",
"AUDIO\\FLASH.WAV",
"AUDIO\\CHAT.WAV",
"AUDIO\\HEAD.WAV",
"AUDIO\\POLICE.WAV",
"AUDIO\\CITY.WAV",
"AUDIO\\WATER.WAV",
"AUDIO\\COMOPEN.WAV",
"AUDIO\\SUBOPEN.WAV",
"AUDIO\\JB.MP3",
"AUDIO\\BET.MP3",
"AUDIO\\L1_LG.MP3",
"AUDIO\\L2_DSB.MP3",
"AUDIO\\L3_DM.MP3",
"AUDIO\\L4_PAP.MP3",
"AUDIO\\L5_TFB.MP3",
"AUDIO\\J0_DM2.MP3",
"AUDIO\\J1_LFL.MP3",
"AUDIO\\J2_KCL.MP3",
"AUDIO\\J3_VH.MP3",
"AUDIO\\J4_ETH.MP3",
"AUDIO\\J5_DST.MP3",
"AUDIO\\J6_TBJ.MP3",
"AUDIO\\T1_TOL.MP3",
"AUDIO\\T2_TPU.MP3",
"AUDIO\\T3_MAS.MP3",
"AUDIO\\T4_TAT.MP3",
"AUDIO\\T5_BF.MP3",
"AUDIO\\S0_MAS.MP3",
"AUDIO\\S1_PF.MP3",
"AUDIO\\S2_CTG.MP3",
"AUDIO\\S3_RTC.MP3",
"AUDIO\\S5_LRQ.MP3",
"AUDIO\\S4_BDBA.MP3",
"AUDIO\\S4_BDBB.MP3",
"AUDIO\\S2_CTG2.MP3",
"AUDIO\\S4_BDBD.MP3",
"AUDIO\\S5_LRQB.MP3",
"AUDIO\\S5_LRQC.MP3",
"AUDIO\\A1_SSO.WAV",
"AUDIO\\A2_PP.WAV",
"AUDIO\\A3_SS.WAV",
"AUDIO\\A4_PDR.WAV",
"AUDIO\\A5_K2FT.WAV",
"AUDIO\\K1_KBO.MP3",
"AUDIO\\K2_GIS.MP3",
"AUDIO\\K3_DS.MP3",
"AUDIO\\K4_SHI.MP3",
"AUDIO\\K5_SD.MP3",
"AUDIO\\R0_PDR2.MP3",
"AUDIO\\R1_SW.MP3",
"AUDIO\\R2_AP.MP3",
"AUDIO\\R3_ED.MP3",
"AUDIO\\R4_GF.MP3",
"AUDIO\\R5_PB.MP3",
"AUDIO\\R6_MM.MP3",
"AUDIO\\D1_STOG.MP3",
"AUDIO\\D2_KK.MP3",
"AUDIO\\D3_ADO.MP3",
"AUDIO\\D5_ES.MP3",
"AUDIO\\D7_MLD.MP3",
"AUDIO\\D4_GTA.MP3",
"AUDIO\\D4_GTA2.MP3",
"AUDIO\\D6_STS.MP3",
"AUDIO\\A6_BAIT.WAV",
"AUDIO\\A7_ETG.WAV",
"AUDIO\\A8_PS.WAV",
"AUDIO\\A9_ASD.WAV",
"AUDIO\\K4_SHI2.MP3",
"AUDIO\\C1_TEX.MP3",
"AUDIO\\EL_PH1.MP3",
"AUDIO\\EL_PH2.MP3",
"AUDIO\\EL_PH3.MP3",
"AUDIO\\EL_PH4.MP3",
"AUDIO\\YD_PH1.MP3",
"AUDIO\\YD_PH2.MP3",
"AUDIO\\YD_PH3.MP3",
"AUDIO\\YD_PH4.MP3",
"AUDIO\\HD_PH1.MP3",
"AUDIO\\HD_PH2.MP3",
"AUDIO\\HD_PH3.MP3",
"AUDIO\\HD_PH4.MP3",
"AUDIO\\HD_PH5.MP3",
"AUDIO\\MT_PH1.MP3",
"AUDIO\\MT_PH2.MP3",
"AUDIO\\MT_PH3.MP3",
"AUDIO\\MT_PH4.MP3",
"AUDIO\\MISCOM.WAV",
"AUDIO\\END.MP3",
"AUDIO\\lib_a1.WAV",
"AUDIO\\lib_a2.WAV",
"AUDIO\\lib_a.WAV",
"AUDIO\\lib_b.WAV",
"AUDIO\\lib_c.WAV",
"AUDIO\\lib_d.WAV",
"AUDIO\\l2_a.WAV",
"AUDIO\\j4t_1.WAV",
"AUDIO\\j4t_2.WAV",
"AUDIO\\j4t_3.WAV",
"AUDIO\\j4t_4.WAV",
"AUDIO\\j4_a.WAV",
"AUDIO\\j4_b.WAV",
"AUDIO\\j4_c.WAV",
"AUDIO\\j4_d.WAV",
"AUDIO\\j4_e.WAV",
"AUDIO\\j4_f.WAV",
"AUDIO\\j6_1.WAV",
"AUDIO\\j6_a.WAV",
"AUDIO\\j6_b.WAV",
"AUDIO\\j6_c.WAV",
"AUDIO\\j6_d.WAV",
"AUDIO\\t4_a.WAV",
"AUDIO\\s1_a.WAV",
"AUDIO\\s1_a1.WAV",
"AUDIO\\s1_b.WAV",
"AUDIO\\s1_c.WAV",
"AUDIO\\s1_c1.WAV",
"AUDIO\\s1_d.WAV",
"AUDIO\\s1_e.WAV",
"AUDIO\\s1_f.WAV",
"AUDIO\\s1_g.WAV",
"AUDIO\\s1_h.WAV",
"AUDIO\\s1_i.WAV",
"AUDIO\\s1_j.WAV",
"AUDIO\\s1_k.WAV",
"AUDIO\\s1_l.WAV",
"AUDIO\\s3_a.WAV",
"AUDIO\\s3_b.WAV",
"AUDIO\\el3_a.WAV",
"AUDIO\\mf1_a.WAV",
"AUDIO\\mf2_a.WAV",
"AUDIO\\mf3_a.WAV",
"AUDIO\\mf3_b.WAV",
"AUDIO\\mf3_b1.WAV",
"AUDIO\\mf3_c.WAV",
"AUDIO\\mf4_a.WAV",
"AUDIO\\mf4_b.WAV",
"AUDIO\\mf4_c.WAV",
"AUDIO\\a1_a.WAV",
"AUDIO\\a3_a.WAV",
"AUDIO\\a5_a.WAV",
"AUDIO\\a4_a.WAV",
"AUDIO\\a4_b.WAV",
"AUDIO\\a4_c.WAV",
"AUDIO\\a4_d.WAV",
"AUDIO\\k1_a.WAV",
"AUDIO\\k3_a.WAV",
"AUDIO\\r1_a.WAV",
"AUDIO\\r2_a.WAV",
"AUDIO\\r2_b.WAV",
"AUDIO\\r2_c.WAV",
"AUDIO\\r2_d.WAV",
"AUDIO\\r2_e.WAV",
"AUDIO\\r2_f.WAV",
"AUDIO\\r2_g.WAV",
"AUDIO\\r2_h.WAV",
"AUDIO\\r5_a.WAV",
"AUDIO\\r6_a.WAV",
"AUDIO\\r6_a1.WAV",
"AUDIO\\r6_b.WAV",
"AUDIO\\lo2_a.WAV",
"AUDIO\\lo6_a.WAV",
"AUDIO\\yd2_a.WAV",
"AUDIO\\yd2_b.WAV",
"AUDIO\\yd2_c.WAV",
"AUDIO\\yd2_c1.WAV",
"AUDIO\\yd2_d.WAV",
"AUDIO\\yd2_e.WAV",
"AUDIO\\yd2_f.WAV",
"AUDIO\\yd2_g.WAV",
"AUDIO\\yd2_h.WAV",
"AUDIO\\yd2_ass.WAV",
"AUDIO\\yd2_ok.WAV",
"AUDIO\\h5_a.WAV",
"AUDIO\\h5_b.WAV",
"AUDIO\\h5_c.WAV",
"AUDIO\\ammu_a.WAV",
"AUDIO\\ammu_b.WAV",
"AUDIO\\ammu_c.WAV",
"AUDIO\\door_1.WAV",
"AUDIO\\door_2.WAV",
"AUDIO\\door_3.WAV",
"AUDIO\\door_4.WAV",
"AUDIO\\door_5.WAV",
"AUDIO\\door_6.WAV",
"AUDIO\\t3_a.WAV",
"AUDIO\\t3_b.WAV",
"AUDIO\\t3_c.WAV",
"AUDIO\\k1_b.WAV",
"AUDIO\\cat1.WAV"
};

70
src/audio/miles/sampman_mss.cpp → src/audio/sampman_miles.cpp
View file

@ -1,3 +1,6 @@
#include "common.h"
#ifdef AUDIO_MSS
#include <windows.h>
#include <shobjidl.h>
#include <shlguid.h>
@ -8,7 +11,7 @@
#include "eax-util.h"
#include "mss.h"
#include "sampman_mss.h"
#include "sampman.h"
#include "AudioManager.h"
#include "MusicManager.h"
#include "Frontend.h"
@ -18,7 +21,7 @@
#pragma comment( lib, "mss32.lib" )
cSampleManager SampleManager;
int32 BankStartOffset[MAX_SAMPLEBANKS];
uint32 BankStartOffset[MAX_SAMPLEBANKS];
///////////////////////////////////////////////////////////////
char SampleBankDescFilename[] = "AUDIO\\SFX.SDT";
@ -55,9 +58,9 @@ struct tMP3Entry
uint32 nNumMP3s;
tMP3Entry *_pMP3List;
char _mp3DirectoryPath[MAX_PATH];
HSTREAM mp3Stream [MAX_MP3STREAMS];
int8 nStreamPan [MAX_MP3STREAMS];
int8 nStreamVolume[MAX_MP3STREAMS];
HSTREAM mp3Stream [MAX_STREAMS];
int8 nStreamPan [MAX_STREAMS];
int8 nStreamVolume[MAX_STREAMS];
uint32 _CurMP3Index;
int32 _CurMP3Pos;
bool _bIsMp3Active;
@ -261,6 +264,17 @@ set_new_provider(S32 index)
return false;
}
cSampleManager::cSampleManager(void) :
m_nNumberOfProviders(0)
{
;
}
cSampleManager::~cSampleManager(void)
{
}
void
cSampleManager::SetSpeakerConfig(int32 which)
{
@ -296,6 +310,26 @@ cSampleManager::GetMaximumSupportedChannels(void)
return _maxSamples;
}
uint32 cSampleManager::GetNum3DProvidersAvailable()
{
return m_nNumberOfProviders;
}
void cSampleManager::SetNum3DProvidersAvailable(uint32 num)
{
m_nNumberOfProviders = num;
}
char *cSampleManager::Get3DProviderName(uint8 id)
{
return m_aAudioProviders[id];
}
void cSampleManager::Set3DProviderName(uint8 id, char *name)
{
m_aAudioProviders[id] = name;
}
int8
cSampleManager::GetCurrent3DProviderIndex(void)
{
@ -1084,7 +1118,7 @@ cSampleManager::Initialise(void)
TRACE("stream");
{
for ( int32 i = 0; i < MAX_MP3STREAMS; i++ )
for ( int32 i = 0; i < MAX_STREAMS; i++ )
{
mp3Stream [i] = NULL;
nStreamPan [i] = 63;
@ -1199,7 +1233,7 @@ cSampleManager::Initialise(void)
void
cSampleManager::Terminate(void)
{
for ( int32 i = 0; i < MAX_MP3STREAMS; i++ )
for ( int32 i = 0; i < MAX_STREAMS; i++ )
{
if ( mp3Stream[i] )
{
@ -1366,6 +1400,12 @@ cSampleManager::SetMusicFadeVolume(uint8 nVolume)
m_nMusicFadeVolume = nVolume;
}
void
cSampleManager::SetMonoMode(uint8 nMode)
{
m_nMonoMode = nMode;
}
bool
cSampleManager::LoadSampleBank(uint8 nBank)
{
@ -1475,6 +1515,18 @@ cSampleManager::LoadPedComment(uint32 nComment)
return true;
}
int32
cSampleManager::GetBankContainingSound(uint32 offset)
{
if ( offset >= BankStartOffset[SAMPLEBANK_PED] )
return SAMPLEBANK_PED;
if ( offset >= BankStartOffset[SAMPLEBANK_MAIN] )
return SAMPLEBANK_MAIN;
return SAMPLEBANK_INVALID;
}
int32
cSampleManager::GetSampleBaseFrequency(uint32 nSample)
{
@ -1664,7 +1716,7 @@ cSampleManager::InitialiseChannel(uint32 nChannel, uint32 nSfx, uint8 nBank)
OutputDebugString(AIL_last_error());
return false;
}
return true;
}
}
@ -2255,3 +2307,5 @@ cSampleManager::InitialiseSampleBanks(void)
return true;
}
#endif

1372
src/audio/sampman_oal.cpp Normal file
View file

File diff suppressed because it is too large Load diff

19
src/core/Game.cpp
View file

@ -220,22 +220,9 @@ bool CGame::InitialiseOnceAfterRW(void)
if ( FrontEndMenuManager.m_nPrefsAudio3DProviderIndex == -99 || FrontEndMenuManager.m_nPrefsAudio3DProviderIndex == -2 )
{
CMenuManager::m_PrefsSpeakers = 0;
for ( int32 i = 0; i < DMAudio.GetNum3DProvidersAvailable(); i++ )
{
wchar buff[64];
char *name = DMAudio.Get3DProviderName(i);
AsciiToUnicode(name, buff);
char *providername = UnicodeToAscii(buff);
strupr(providername);
if ( !strcmp(providername, "MILES FAST 2D POSITIONAL AUDIO") )
{
FrontEndMenuManager.m_nPrefsAudio3DProviderIndex = i;
break;
}
}
int8 provider = DMAudio.AutoDetect3DProviders();
if ( provider != -1 )
FrontEndMenuManager.m_nPrefsAudio3DProviderIndex = provider;
}
DMAudio.SetCurrent3DProvider(FrontEndMenuManager.m_nPrefsAudio3DProviderIndex);

3
src/core/config.h
View file

@ -193,7 +193,8 @@ enum Config {
#define DEFAULT_NATIVE_RESOLUTION // Set default video mode to your native resolution (fixes Windows 10 launch)
#define USE_TXD_CDIMAGE // generate and load textures from txd.img
//#define USE_TEXTURE_POOL
//#define OPENAL
#define AUDIO_OAL
//#define AUDIO_MSS
// Particle
//#define PC_PARTICLE

3
src/skel/win/win.cpp
View file

@ -1773,13 +1773,12 @@ WinMain(HINSTANCE instance,
StaticPatcher::Apply();
SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, nil, SPIF_SENDCHANGE);
/*
// TODO: make this an option somewhere
AllocConsole();
freopen("CONIN$", "r", stdin);
freopen("CONOUT$", "w", stdout);
freopen("CONOUT$", "w", stderr);
*/
/*
* Initialize the platform independent data.