void Sound_Engine::Internal::Init(){
pXAudio2=0;
pMasteringVoice=0;
pSubmixVoice=0;
pReverbEffect=0;
nFrameToApply3DAudio=0;
dwChannelMask=0;
nChannels=0;
CoInitializeEx(NULL, COINIT_MULTITHREADED);
HR(XAudio2Create( &pXAudio2, 0 )) ;
HR(pXAudio2->CreateMasteringVoice( &pMasteringVoice ) );
// Check device details to make sure it's within our sample supported parameters
XAUDIO2_DEVICE_DETAILS details;
HR(pXAudio2->GetDeviceDetails( 0, &details ) );
if( details.OutputFormat.Format.nChannels > OUTPUTCHANNELS ){
RELEASECOM( pXAudio2 );
assert(true);
}
dwChannelMask = details.OutputFormat.dwChannelMask;
nChannels = details.OutputFormat.Format.nChannels;
HR(XAudio2CreateReverb( &pReverbEffect, 0 ) ); // Create reverb effect
// Create a submix voice
// Performance tip: you need not run global FX with the sample number
// of channels as the final mix. For example, this sample runs
// the reverb in mono mode, thus reducing CPU overhead.
XAUDIO2_EFFECT_DESCRIPTOR effects[] = { { pReverbEffect, TRUE, 1 } };
XAUDIO2_EFFECT_CHAIN effectChain = { 1, effects };
HR(pXAudio2->CreateSubmixVoice( &pSubmixVoice, 1,details.OutputFormat.Format.nSamplesPerSec, 0, 0, NULL, &effectChain ) );
// Set default FX params
XAUDIO2FX_REVERB_PARAMETERS native;
ReverbConvertI3DL2ToNative( &g_PRESET_PARAMS[0], &native );
pSubmixVoice->SetEffectParameters( 0, &native, sizeof( native ) );
//
// Initialize X3DAudio
// Speaker geometry configuration on the final mix, specifies assignment of channels
// to speaker positions, defined as per WAVEFORMATEXTENSIBLE.dwChannelMask
X3DAudioInitialize( details.OutputFormat.dwChannelMask, X3DAUDIO_SPEED_OF_SOUND, x3DInstance );
CurrentListenerPos = D3DXVECTOR3( 0, 0, 0 );
listener.Position = CurrentListenerPos;
listener.OrientFront = D3DXVECTOR3( 0, 0, 1 );
listener.OrientTop = D3DXVECTOR3( 0, 1, 0 );
listener.pCone = (X3DAUDIO_CONE*)&Listener_DirectionalCone;
dspSettings.SrcChannelCount = INPUTCHANNELS;
dspSettings.DstChannelCount = nChannels;
dspSettings.pMatrixCoefficients = matrixCoefficients;
}
void DeviceAudioDX11::restartAudio (void)
{
#if DT2_MULTITHREADED_AUDIO
AutoSpinLockRecursive lock(&_lock);
#endif
if (!_x_audio_2) {
// Initialize Audio system
HRESULT hr = XAudio2Create( &_x_audio_2, 0, XAUDIO2_DEFAULT_PROCESSOR );
Assert(SUCCEEDED(hr));
// Initialize Mastering Voice
hr = _x_audio_2->CreateMasteringVoice( &_x_master_voice );
Assert(SUCCEEDED(hr));
// Initialize 3D audio
XAUDIO2_VOICE_DETAILS voice_details;
_x_master_voice->GetVoiceDetails(&voice_details);
// Initialize 3D audio subsystem
X3DAudioInitialize( voice_details.InputChannels, X3DAUDIO_SPEED_OF_SOUND, _x3_instance );
// Initialize listener
::memset(&_x3_listener,0,sizeof(X3DAUDIO_LISTENER));
// Initialize DSP parameters
::memset(&_x3_dsp,0,sizeof(X3DAUDIO_DSP_SETTINGS));
_x3_dsp_matrix.resize(voice_details.InputChannels * NUM_CHANNELS);
_x3_dsp_delays.resize(voice_details.InputChannels);
_x3_dsp.pMatrixCoefficients = &_x3_dsp_matrix[0];
_x3_dsp.pDelayTimes = &_x3_dsp_delays[0];
_x3_dsp.DstChannelCount = voice_details.InputChannels;
_x3_dsp.SrcChannelCount = 0; // Changed on the fly when calculating
// Initialize rest of this class
setNumberOfChannels(32);
// Get all channels playing again
for (DTuint c = 0; c < min2(_channels.size(),_save_channels.size()); ++c) {
playOnChannel (_channels[c], _save_channels[c]._source, _save_channels[c]._sound_loader);
RELEASE(_save_channels[c]._source);
RELEASE(_save_channels[c]._sound_loader);
}
_save_channels.clear();
}
}
AudioWorld::AudioWorld(const AudioDeviceDetails& deviceDetails)
: x3DAudio_()
, deviceDetails_(deviceDetails)
, levelMatrix_(deviceDetails.numSrcCannels * deviceDetails.numDestCannels, 0)
, listeners_()
, emitters_()
, mainListener_()
{
/// TODO: Initializing X3DAudio handle every create the world may be heavy cost
enforce<XAudioException>(
SUCCEEDED(X3DAudioInitialize(deviceDetails.channelMask, X3DAUDIO_SPEED_OF_SOUND, x3DAudio_)),
"Failed to initialize the X3DAudio.");
}
XAudio& XAudio::GetInstance()
{
if( !_pXAudioSingleton_ ){
_pXAudioSingleton_ = new XAudio();
CoInitializeEx( NULL, COINIT_MULTITHREADED );
UINT32 flags = 0;
#ifdef _DEBUG
flags |= XAUDIO2_DEBUG_ENGINE;
#endif
if( FAILED( XAudio2Create( &pXAudio2, flags ) ) ){
CoUninitialize();
MessageBoxA( NULL, "Failed: XAudio::XAudio2Create DirectXのバージョンが古い可能性があります。November 2008以降のバージョンのDirectXをインストールして下さい。", "Error", MB_OK );
}
if( FAILED( pXAudio2->CreateMasteringVoice( &pMasteringVoice ) ) ){
XAD_SAFE_RELEASE( pXAudio2 );
CoUninitialize();
MessageBoxA( NULL, "Failed: XAudio::CreateMasteringVoice", "Error", MB_OK );
}
HRESULT hr;
// Check device details to make sure it's within our sample supported parameters
XAUDIO2_DEVICE_DETAILS details;
if( FAILED( hr = pXAudio2->GetDeviceDetails( 0, &details ) ) )
{
XAD_SAFE_RELEASE( pXAudio2 );
CoUninitialize();
MessageBoxA( NULL, "Failed: XAudio::GetDeviceDetails", "Error", MB_OK );
}
if( details.OutputFormat.Format.nChannels > XAUDIO2_MAX_AUDIO_CHANNELS )
{
XAD_SAFE_RELEASE( pXAudio2 );
CoUninitialize();
MessageBoxA( NULL, "Failed: details channels", "Error", MB_OK );
}
XAudio::m_dwChannelMask = details.OutputFormat.dwChannelMask;
XAudio::m_OutputChannels = details.OutputFormat.Format.nChannels;
X3DAudioInitialize( XAudio::m_dwChannelMask, X3DAUDIO_SPEED_OF_SOUND, XAudio::x3DInstance );
}
return *_pXAudioSingleton_;
}
// setup creates the performance object, the default audio path, the
// audio path for non-local sounds, the audio path for the listener, the
// loader for creating segments from sound files and extracts the buffer
// from the non-local audio path and the listener from the listener audio
// path
//
bool SoundCard::setup(void* hwnd) {
bool rc = false;
HRESULT hr;
UINT32 flags = 0;
// Enable XAudio2 debugging if we're running in debug mode
#ifdef _DEBUG
flags |= XAUDIO2_DEBUG_ENGINE;
#endif
if ( FAILED( hr = XAudio2Create( &pXAudio2, flags ) ) )
{
error(L"SoundCard::01 Failed to initialize XAudio2 engine");
release();
}
else if ( FAILED( hr = pXAudio2->CreateMasteringVoice( &pMasteringVoice ) ) )
{
error(L"SoundCard::02 Failed to create Mastering Voice");
release();
}
else
{
// Initialize the X3DAudio engine
XAUDIO2_DEVICE_DETAILS deviceDetails;
pXAudio2->GetDeviceDetails(0,&deviceDetails);
DWORD channelMask = deviceDetails.OutputFormat.dwChannelMask;
X3DAudioInitialize( channelMask, X3DAUDIO_SPEED_OF_SOUND, X3DInstance );
update(); // update the X3DAUDIO_LISTENER with the current camera position/heading
// set the frequency and volume range of the context
// http://msdn.microsoft.com/en-us/library/ee415828(v=VS.85).aspx
context->set(GF_AU_FREQ, DEFAULT_FREQUENCY);
context->set(GF_AU_MXVL, MAX_VOLUME);
context->set(GF_AU_MNVL, MIN_VOLUME);
context->set(GF_AU_CVOL, DEFAULT_VOLUME);
rc = true;
}
return rc;
}
//--- private constructor to hide it from explicit instantiation;
//--- initializes XAudio2, X3DAudio and the listener.
//--- sets the status flag.
XACore::XACore()
: mXAEngine(NULL), mMasteringVoice(NULL), mChannelCount(0)
{
HRESULT hr; // use to catch XAudio2 function call results.
CoInitializeEx(NULL, COINIT_MULTITHREADED);
hr = XAudio2Create(&mXAEngine, 0, XAUDIO2_DEFAULT_PROCESSOR);
if (FAILED(hr))
{
MessageBox(NULL, TEXT(" XAudio2Create() failed to create the XAudio2 engine."), TEXT("XACore constructor() - Failed"), MB_OK | MB_ICONERROR);
CoUninitialize();
mXAEngine = NULL;
mStatus = EngineError;
return;
}
mXAEngine->StartEngine();
// Retrieve information about the audio device.
// Note the Windows 8 SdK distribution of XAudio2 requires an alternative approach to retrieving this information.
mXAEngine->GetDeviceDetails(0, &mDetails);
mChannelCount = mDetails.OutputFormat.Format.nChannels;
hr = mXAEngine->CreateMasteringVoice(&mMasteringVoice);
if (FAILED(hr))
{
MessageBox(NULL, TEXT(" CreateMasteringVoice() failed to create the voice."), TEXT("XACore constructor() - Failed"), MB_OK | MB_ICONERROR);
CoUninitialize();
mXAEngine->Release();
mXAEngine = NULL;
mMasteringVoice = NULL;
mStatus = MasterError;
return;
}
// Set up X3DAudio.
DWORD channelMask;
channelMask = mDetails.OutputFormat.dwChannelMask;
X3DAudioInitialize(channelMask, X3DAUDIO_SPEED_OF_SOUND, m3DHandle);
mStatus = OK;
} // end XACore constructor method.
HRESULT SoundManager::init()
{
HRESULT hr = S_OK;
UINT32 flags = 0;
#ifdef _DEBUG
flags |= XAUDIO2_DEBUG_ENGINE;
#endif
// Send in the wanted flags when the sound device is created.
if( FAILED( hr = XAudio2Create(&m_soundDevice, flags)) )
{
return hr;
}
if( FAILED( hr = m_soundDevice->CreateMasteringVoice(&m_masterVoice)))
{
return hr;
}
XAUDIO2_DEVICE_DETAILS details;
if( FAILED( hr = m_soundDevice->GetDeviceDetails(0, &details)))
{
return hr;
}
m_destChannels = details.OutputFormat.Format.nChannels;
X3DAudioInitialize( details.OutputFormat.dwChannelMask, X3DAUDIO_SPEED_OF_SOUND,
m_X3DAudioInstance);
m_matrixCoefficients = new FLOAT32[1*details.OutputFormat.Format.nChannels];
m_emitterAzimuths = new FLOAT32[1];
initPositionalSound();
return hr;
}
//ACRE_RESULT CFilterPosition::process(short* samples, int sampleCount, int channels, CPlayer *player, const unsigned int* channelSpeakerArray, unsigned int *channelMask, ACRE_VOLUME volume) {
ACRE_RESULT CFilterPosition::process(short* samples, int sampleCount, int channels, const unsigned int speakerMask, CSoundMixdownEffect *params) {
X3DAUDIO_LISTENER Listener = {};
X3DAUDIO_EMITTER Emitter = {0};
X3DAUDIO_DSP_SETTINGS DSPSettings = {0};
X3DAUDIO_CONE emitterCone = {0};
X3DAUDIO_VECTOR listener_position;
X3DAUDIO_VECTOR speaker_position;
X3DAUDIO_VECTOR vector_listenerDirection;
X3DAUDIO_VECTOR vector_speakerDirection;
//LOCK(player);
//LOCK(CEngine::getInstance()->getSelf());
float killCoef;
float *Matrix = new float[1 * channels];
//LOG("channels: %d", channels);
if (!this->p_IsInitialized) {
// we need to figure out what channel mask we want to use.
/*
unsigned int initSpeakers = channelSpeakerArray[0];
LOG("Speaker 1: %d", channelSpeakerArray[0]);
for (int i = 1; i < channels; i++) {
LOG("Speaker %d: %d", i+1, channelSpeakerArray[i]);
initSpeakers = initSpeakers | channelSpeakerArray[i];
}
*/
X3DAudioInitialize(speakerMask, X3DAUDIO_SPEED_OF_SOUND, this->p_X3DInstance);
this->p_IsInitialized = TRUE;
}
if (CAcreSettings::getInstance()->getDisablePosition())
return ACRE_OK;
DSPSettings.SrcChannelCount = 1;
DSPSettings.DstChannelCount = channels;
DSPSettings.pMatrixCoefficients = Matrix;
speaker_position.x = params->getParam("speakerPosX");
speaker_position.y = params->getParam("speakerPosY");
speaker_position.z = params->getParam("speakerPosZ");
Emitter.Position = speaker_position;
vector_speakerDirection.x = params->getParam("headVectorX");
vector_speakerDirection.y = params->getParam("headVectorY");
vector_speakerDirection.z = params->getParam("headVectorZ");
Emitter.OrientFront = vector_speakerDirection;
Emitter.OrientTop = this->getUpVector(vector_speakerDirection);
Emitter.Velocity = X3DAUDIO_VECTOR( 0, 0, 0 );
Emitter.ChannelCount = 1;
if (params->getParam("isWorld") == POSITIONAL_EFFECT_ISWORLD) {
listener_position.x = CEngine::getInstance()->getSelf()->getWorldPosition().x;
listener_position.y = CEngine::getInstance()->getSelf()->getWorldPosition().y;
listener_position.z = CEngine::getInstance()->getSelf()->getWorldPosition().z;
vector_listenerDirection.x = CEngine::getInstance()->getSelf()->getHeadVector().x;
vector_listenerDirection.y = CEngine::getInstance()->getSelf()->getHeadVector().y;
vector_listenerDirection.z = CEngine::getInstance()->getSelf()->getHeadVector().z;
if (params->getParam("speakingType") == ACRE_SPEAKING_DIRECT) {
/*if(CEngine::getInstance()->getSoundEngine()->getCurveModel() == ACRE_CURVE_MODEL_AMPLITUDE) {
Emitter.CurveDistanceScaler = (player->getAmplitudeCoef())*(CEngine::getInstance()->getSoundEngine()->getCurveScale());
Emitter.pVolumeCurve = NULL;
} else */
if (CEngine::getInstance()->getSoundEngine()->getCurveModel() == ACRE_CURVE_MODEL_SELECTABLE_A) {
Emitter.CurveDistanceScaler = 1.0f*(params->getParam("curveScale"));
Emitter.pVolumeCurve = NULL;
} else if (CEngine::getInstance()->getSoundEngine()->getCurveModel() == ACRE_CURVE_MODEL_SELECTABLE_B) {
Emitter.CurveDistanceScaler = 1.0f*(params->getParam("curveScale"));
Emitter.pVolumeCurve = (X3DAUDIO_DISTANCE_CURVE *)&distanceCurve;
} else {
Emitter.CurveDistanceScaler = 1.0f;
Emitter.pVolumeCurve = NULL;
//Emitter.pVolumeCurve = (X3DAUDIO_DISTANCE_CURVE *)&distanceCurve;
}
} else {
Emitter.CurveDistanceScaler = 1.0f;
Emitter.pVolumeCurve = (X3DAUDIO_DISTANCE_CURVE *)&distanceCurve;
}
} else {
listener_position.x = 0.0f;
listener_position.y = 0.0f;
listener_position.z = 0.0f;
vector_listenerDirection.x = 0.0f;
vector_listenerDirection.y = 1.0f;
vector_listenerDirection.z = 0.0f;
Emitter.CurveDistanceScaler = 1.0f;
Emitter.pVolumeCurve = (X3DAUDIO_DISTANCE_CURVE *)&distanceCurve;
}
Emitter.DopplerScaler = 1.0f;
Emitter.ChannelRadius = 1.0f;
emitterCone.InnerAngle = X3DAUDIO_PI/4;
emitterCone.OuterAngle = X3DAUDIO_PI/2;
emitterCone.InnerVolume = 1.2f;
emitterCone.OuterVolume = 1.0f;
Emitter.pCone = &emitterCone;
//Listener.pCone = &emitterCone;
Emitter.InnerRadius = 2.0f;
Emitter.InnerRadiusAngle = X3DAUDIO_PI/4.0f;
X3DAUDIO_VECTOR listener_topVec = this->getUpVector(vector_listenerDirection);
//float listenerDot = vector_listenerDirection.x*listener_topVec.x + vector_listenerDirection.y*listener_topVec.y + vector_listenerDirection.z*listener_topVec.z;
//TRACE("Listener Dot Product: %f", listenerDot);
Listener.OrientFront = vector_listenerDirection;
Listener.OrientTop = listener_topVec;
Listener.Position = listener_position;
//UNLOCK(CEngine::getInstance()->getSelf());
//UNLOCK(player);
X3DAudioCalculate(this->p_X3DInstance, &Listener, &Emitter,
X3DAUDIO_CALCULATE_MATRIX | X3DAUDIO_CALCULATE_EMITTER_ANGLE,
&DSPSettings );
/*
std::string matrixVals = std::string("");
for (int i = 0; i < channels; i++) {
char *mAppend;
sprintf(mAppend, "%f, ", Matrix[i]);
matrixVals.append(std::string(mAppend));
}
TRACE("MATRIX: %s", matrixVals.c_str());
*/
TRACE("matrix: c:[%d], %f, %f, %f", channels, Matrix[0], Matrix[1], (Matrix[0] + Matrix[1]));// +Matrix[2] + Matrix[3] + Matrix[4] + Matrix[5]));
/*
LOG("Positions: d:[%f], l:[%f,%f,%f] s:[%f,%f,%f]",
DSPSettings.EmitterToListenerDistance,
Listener.Position.x,
Listener.Position.y,
Listener.Position.z,
Emitter.Position.x,
Emitter.Position.y,
Emitter.Position.z
);
*/
if (CEngine::getInstance()->getSoundEngine()->getCurveModel() == ACRE_CURVE_MODEL_AMPLITUDE || CEngine::getInstance()->getSoundEngine()->getCurveModel() == ACRE_CURVE_MODEL_SELECTABLE_A) {
killCoef = std::max(0.0f,(1-((DSPSettings.EmitterToListenerDistance-(MAX_FALLOFF_DISTANCE))/MAX_FALLOFF_RANGE)));
if (DSPSettings.EmitterToListenerDistance < (MAX_FALLOFF_DISTANCE)) {
killCoef = 1;
}
killCoef = std::min(1.0f, killCoef);
} else {
killCoef = 1;
};
//LOG("dis: %f kc: %f ac: %f", DSPSettings.EmitterToListenerDistance, killCoef, this->getPlayer()->getAmplitudeCoef());
for (int x = 0; x < sampleCount * channels; x+=channels) {
for (int i = 0; i < channels; i++) {
samples[x+i] = (short)(samples[x+i] * Matrix[i] * killCoef);
}
}
if (Matrix)
delete Matrix;
return ACRE_OK;
}
bool AudioManager::LoadContent( int sfxChannelCount, int musicChannelCount )
{
//ZeroMemory(&m_3dSounds, sizeof(Audio3dInfo));
m_sfxChannelCount = sfxChannelCount;
m_musicChannelCount = musicChannelCount;
if( !LoadSubmixes() )
{
return false;
}
//details of the current audio device, hardware
XAUDIO2_DEVICE_DETAILS details;
m_audioEngine->GetDeviceDetails(0, &details);
m_sound3D.nChannels = details.OutputFormat.Format.nChannels;
m_sound3D.dwChannelMask = details.OutputFormat.dwChannelMask;
//initialize 3dsound Handler
float SPEEDOFSOUND = 343.5f;
X3DAudioInitialize(details.OutputFormat.dwChannelMask, SPEEDOFSOUND, m_audio3dHandle);
//SETUP LISTENER ///initial values
m_sound3D.Emitter.push_back(Audio3dEmitter());
m_sound3D.Listener.Position = floatToa3dfloat(XMFLOAT3(0, 0, 0));
m_sound3D.Listener.OrientFront = floatToa3dfloat(XMFLOAT3(0, 0, 1));
m_sound3D.Listener.OrientTop = floatToa3dfloat(XMFLOAT3(0, 1, 0));
//Cone values
m_sound3D.Listener.pCone = (X3DAUDIO_CONE*)&Listener_DirectionalCone;
//EMITTER
m_sound3D.Emitter[0].m_emitter.pCone = &m_sound3D.emitterCone;
m_sound3D.Emitter[0].m_emitter.pCone->InnerAngle = 0.0f;
// Setting the inner cone angles to X3DAUDIO_2PI and
// outer cone other than 0 causes
// the emitter to act like a point emitter using the
// INNER cone settings only.
m_sound3D.Emitter[0].m_emitter.pCone->OuterAngle = 0.0f;
// Setting the outer cone angles to zero causes
// the emitter to act like a point emitter using the
// OUTER cone settings only.
m_sound3D.Emitter[0].m_emitter.pCone->InnerVolume = 0.0f;
m_sound3D.Emitter[0].m_emitter.pCone->OuterVolume = 1.0f;
m_sound3D.Emitter[0].m_emitter.pCone->InnerLPF = 0.0f;
m_sound3D.Emitter[0].m_emitter.pCone->OuterLPF = 1.0f;
m_sound3D.Emitter[0].m_emitter.pCone->InnerReverb = 0.0f;
m_sound3D.Emitter[0].m_emitter.pCone->OuterReverb = 1.0f;
m_sound3D.Emitter[0].m_emitter.Position = floatToa3dfloat(XMFLOAT3(0, 0, 5));
m_sound3D.Emitter[0].m_emitter.OrientFront = floatToa3dfloat(XMFLOAT3(0, 0, 1));
m_sound3D.Emitter[0].m_emitter.OrientTop = floatToa3dfloat(XMFLOAT3(0, 1, 0));
m_sound3D.Emitter[0].m_emitter.ChannelCount = INPUTCHANNELS;
m_sound3D.Emitter[0].m_emitter.ChannelRadius = 1.0f;
m_sound3D.Emitter[0].m_emitter.pChannelAzimuths = m_sound3D.emitterAzimuths;
// Use of Inner radius allows for smoother transitions as
// a sound travels directly through, above, or below the listener.
// It also may be used to give elevation cues.
m_sound3D.Emitter[0].m_emitter.InnerRadius = 2.0f;
m_sound3D.Emitter[0].m_emitter.InnerRadiusAngle = X3DAUDIO_PI / 4.0f;;
m_sound3D.Emitter[0].m_emitter.pVolumeCurve = (X3DAUDIO_DISTANCE_CURVE*)&X3DAudioDefault_LinearCurve;
m_sound3D.Emitter[0].m_emitter.pLFECurve = (X3DAUDIO_DISTANCE_CURVE*)&Emitter_LFE_Curve;
m_sound3D.Emitter[0].m_emitter.pLPFDirectCurve = NULL; // use default curve
m_sound3D.Emitter[0].m_emitter.pLPFReverbCurve = NULL; // use default curve
m_sound3D.Emitter[0].m_emitter.pReverbCurve = (X3DAUDIO_DISTANCE_CURVE*)&Emitter_Reverb_Curve;
m_sound3D.Emitter[0].m_emitter.CurveDistanceScaler = 14.0f;
m_sound3D.Emitter[0].m_emitter.DopplerScaler = 1.0f;
//DPS
m_sound3D.Emitter[0].dspSettings.SrcChannelCount = INPUTCHANNELS;
m_sound3D.Emitter[0].dspSettings.DstChannelCount = m_sound3D.nChannels;
m_sound3D.Emitter[0].dspSettings.pMatrixCoefficients = m_sound3D.matrixCoefficients;
if (!LoadAudio())
{
return false;
}
////LOOP SOUND
//XAUDIO2_BUFFER playerBuffer = { 0 };
//shared_ptr<ImplData> soundData = m_3dTrackList[sound3dIndexMap["3ds_Pboost.wav"]];
//playerBuffer.AudioBytes = soundData->g_audioData.xaBuffer()->AudioBytes;
//playerBuffer.pAudioData = soundData->g_audioData.xaBuffer()->pAudioData;
//playerBuffer.Flags = XAUDIO2_END_OF_STREAM;
//playerBuffer.LoopCount = XAUDIO2_LOOP_INFINITE;
////Get rid of what ever was queued to play
////soundData->g_sourceVoice->FlushSourceBuffers();
//soundData->g_sourceVoice->SubmitSourceBuffer(&playerBuffer);
//soundData->g_sourceVoice->Start(0);
//AllocConsole();
//freopen("CONOUT$", "w", stdout);
return true;
}
bool Audio3D::initialiseAudio()
{
if (m_masteringVoice != NULL)
m_masteringVoice->DestroyVoice();
SAFE_RELEASE(m_XAudio2);
HRESULT hr;
if (FAILED(hr = XAudio2Create( &m_XAudio2, 0)))
{
LOG->logMsg(LT_ERROR, "Error while creating XAudio2: %#X", hr);
SAFE_RELEASE(m_XAudio2);
return false;
}
if (FAILED(hr = m_XAudio2->CreateMasteringVoice(&m_masteringVoice)))
{
LOG->logMsg(LT_ERROR, "Audio3D: Error while creating master voice: %#X", hr);
return false;
}
XAUDIO2_DEVICE_DETAILS details;
if( FAILED( hr = m_XAudio2->GetDeviceDetails( 0, &details ) ) )
{
SAFE_RELEASE( m_XAudio2 );
LOG->logMsg(LT_ERROR, "Failed to retrieve DeviceDetails: %#X", hr);
return false;
}
if( details.OutputFormat.Format.nChannels > OUTPUTCHANNELS )
{
SAFE_RELEASE( m_XAudio2 );
LOG->logMsg(LT_ERROR, "nChannels too large.");
return false;
}
m_channelMask = details.OutputFormat.dwChannelMask;
m_channels = details.OutputFormat.Format.nChannels;
//Create reverb effect:
if( FAILED( hr = XAudio2CreateReverb( &m_reverbEffect, 0 ) ) )
{
SAFE_RELEASE( m_XAudio2 );
LOG->logMsg(LT_ERROR, "Failed to create reverb: %#X", hr);
return false;
}
//Create submix voice for mixing effects
XAUDIO2_EFFECT_DESCRIPTOR effects[] = { { m_reverbEffect, TRUE, 1 } };
XAUDIO2_EFFECT_CHAIN effectChain = { 1, effects };
if( FAILED( hr = m_XAudio2->CreateSubmixVoice( &m_submixVoice, 1,
details.OutputFormat.Format.nSamplesPerSec, 0, 0,
NULL, &effectChain ) ) )
{
SAFE_RELEASE( m_XAudio2 );
SAFE_RELEASE( m_reverbEffect );
LOG->logMsg(LT_ERROR, "Failed to create submix voice: %#X", hr);
return false;
}
// Set default FX params
XAUDIO2FX_REVERB_PARAMETERS native;
ReverbConvertI3DL2ToNative( &PRESET_PARAMS[0], &native );
m_submixVoice->SetEffectParameters( 0, &native, sizeof( native ) );
const float SPEEDOFSOUND = X3DAUDIO_SPEED_OF_SOUND;
X3DAudioInitialize( details.OutputFormat.dwChannelMask, SPEEDOFSOUND, m_x3DInstance );
m_useInnerRadius = true;
m_listenerPos = D3DXVECTOR3( 0, 0, 0 );
m_useRedirectToLFE = ((details.OutputFormat.dwChannelMask & SPEAKER_LOW_FREQUENCY) != 0);
//
// Setup 3D audio structs
//
m_listener.Position = m_listenerPos;
m_listener.OrientFront = D3DXVECTOR3( 0, 1, 0 );
m_listener.OrientTop = D3DXVECTOR3( 0, 1, 0 );
m_listener.pCone = (X3DAUDIO_CONE*)&m_listener_DirectionalCone;
//LOG->logMsg(LT_STATUS, "Audio3D: initialized.");
this->m_curveDistanceScaler = 60.0f;
m_initialized = true;
return true;
}
void Sound::initialize()
{
HRESULT res;
if (FAILED(res = XAudio2Create(&audio)))
{
// Failed to create XAudio2 engine instance
initialized = false;
return;
}
audio->GetDeviceDetails(0, &details);
if (FAILED(res = audio->CreateMasteringVoice(&mVoice, details.OutputFormat.Format.nChannels)))
{
// Failed to create mastering voice
initialized = false;
return;
}
mVoice->SetVolume(1.0f);
// Create Sound Effects submix voice (ALL sound effects pass through here)
// A Sound Effect must have exactly ONE channel, sample rate of 44100 Hz
audio->CreateSubmixVoice(&smSFX, details.OutputFormat.Format.nChannels, 44100);
// Create Music submix voice (ALL music passes through here)
// Music must have exactly TWO channels, sample rate of 48000 Hz
audio->CreateSubmixVoice(&smMusic, 2, 48000);
SFXSend.Flags = XAUDIO2_SEND_USEFILTER;
SFXSend.pOutputVoice = smSFX;
SFXSendList.SendCount = 1;
SFXSendList.pSends = &SFXSend;
musicSend.Flags = 0;
musicSend.pOutputVoice = smMusic;
musicSendList.SendCount = 1;
musicSendList.pSends = &musicSend;
// Set music volume HERE
smMusic->SetVolume(0.4f);
// Set sound effect volume HERE
smSFX->SetVolume(1.0f);
wfm = new WAVEFORMATEXTENSIBLE();
ZeroMemory(wfm, sizeof(WAVEFORMATEXTENSIBLE));
loadMusic(ingamemusic, "sounds/ingamemusic.xwm", ingamemusicBuffer, ingameMusicXMABuffer);
loadMusic(menumusic, "sounds/menumusic.xwm", menumusicBuffer, menuMusicXMABuffer);
loadSound(SFX_ROCKET, "sounds/rocket.xwm");
loadSound(SFX_CRASH, "sounds/crash.xwm");
loadSound(SFX_ENGINE, "sounds/engine.xwm");
loadSound(SFX_BOOST, "sounds/boost.xwm");
loadSound(SFX_LASER, "sounds/laser.xwm");
loadSound(SFX_DROPMINE, "sounds/dropmine.xwm");
loadSound(SFX_SCREAM1, "sounds/scream1.xwm");
loadSound(SFX_SCREAM2, "sounds/scream2.xwm");
loadSound(SFX_SCREAM3, "sounds/scream3.xwm");
loadSound(SFX_CAREXPLODE, "sounds/carexplode.xwm");
loadSound(SFX_EXPLOSION, "sounds/explosion.xwm");
loadSound(SFX_BEEP, "sounds/beep.xwm");
loadSound(SFX_ROCKETLAUNCH, "sounds/rocketlaunch.xwm");
loadSound(SFX_PICKUP, "sounds/pickup.xwm");
loadSound(SFX_SELECT, "sounds/select.xwm");
loadSound(SFX_SHOTGUN, "sounds/shotgun.xwm");
loadSound(SFX_TAKENLEAD, "sounds/takenlead.xwm");
loadSound(SFX_LOSTLEAD, "sounds/lostlead.xwm");
loadSound(SFX_NOAMMO, "sounds/noammo.xwm");
loadSound(SFX_ONE, "sounds/one.xwm");
loadSound(SFX_TWO, "sounds/two.xwm");
loadSound(SFX_THREE, "sounds/three.xwm");
// Now set up 3D audio
X3DAudioInitialize(details.OutputFormat.dwChannelMask, X3DAUDIO_SPEED_OF_SOUND, audio3DHandle);
listener.pCone = NULL;
X3DAUDIO_VECTOR vec;
vec.x = 0.0f;
vec.y = 0.0f;
vec.z = 1.0f;
listener.OrientFront = X3DAUDIO_VECTOR(vec);
vec.y = 1.0f;
vec.z = 0.0f;
listener.OrientTop = X3DAUDIO_VECTOR(vec);
listener.Position.x = 0.0f;
listener.Position.y = 0.0f;
listener.Position.z = 0.0f;
listener.Velocity.x = 0.0f;
listener.Velocity.y = 0.0f;
listener.Velocity.z = 0.0f;
// Now set up emitters
emitters = new X3DAUDIO_EMITTER[NUM_EMITTERS];
for (int i = 0; i < NUM_EMITTERS; i++)
{
ZeroMemory(&(emitters[i]), sizeof(emitters[i]));
emitters[i].ChannelCount = 1;
emitters[i].InnerRadius = 6.0f;
emitters[i].InnerRadiusAngle = X3DAUDIO_PI * 2.0f;
emitters[i].CurveDistanceScaler = 8.0f;
emitters[i].DopplerScaler = 1.0f;
}
ZeroMemory(&dspSettings, sizeof(X3DAUDIO_DSP_SETTINGS));
float* mat = new float[details.OutputFormat.Format.nChannels];
dspSettings.SrcChannelCount = 1;
dspSettings.DstChannelCount = details.OutputFormat.Format.nChannels;
dspSettings.pMatrixCoefficients = mat;
voiceBuffer = new IXAudio2SourceVoice*[maxVoices];
for (int i = 0; i < maxVoices; i++)
{
voiceBuffer[i] = NULL;
audio->CreateSourceVoice(&(voiceBuffer[i]), (WAVEFORMATEX*) wfm, XAUDIO2_VOICE_USEFILTER, XAUDIO2_MAX_FREQ_RATIO, 0, &SFXSendList, 0);
}
voiceBufferReserved = new IXAudio2SourceVoice*[maxReservedVoices];
for (int i = 0; i < maxReservedVoices; i++)
{
voiceBufferReserved[i] = NULL;
audio->CreateSourceVoice(&(voiceBufferReserved[i]), (WAVEFORMATEX*) wfm, XAUDIO2_VOICE_USEFILTER, XAUDIO2_MAX_FREQ_RATIO, 0, &SFXSendList, 0);
}
initialized = true;
return;
}
void CDECL X3DA16_X3DAudioInitialize(UINT32 chanmask, float speedofsound,
X3DAUDIO_HANDLE handle)
{
/* forward to 1.7 */
X3DAudioInitialize(chanmask, speedofsound, handle);
}
M3D_RESULT __stdcall M3D_activate(int enable)
{
if(enable)
{
if(pXAudio2)
return M3D_ALREADY_STARTED;
char ReverbVolumeText[256];
if(!GothicReadIniString("PARAMETERS", "ReverbVolume", "3.0", ReverbVolumeText, 256, "SystemPack.ini"))
GothicWriteIniString("PARAMETERS", "ReverbVolume", "3.0", "SystemPack.ini");
ReverbVolume = (float)atof(ReverbVolumeText);
HRESULT hResult = S_OK;
if(FAILED(hResult = XAudio2Create(&pXAudio2, 0, XAUDIO2_DEFAULT_PROCESSOR)))
{
#ifdef LOG
fprintf(Log, "M3D_activate XAudio2Create failed %d\n", hResult);
#endif
return M3D_NOT_INIT;
}
memset(&deviceDetails, 0, sizeof(XAUDIO2_DEVICE_DETAILS));
if(FAILED(hResult = pXAudio2->GetDeviceDetails(0, &deviceDetails)))
{
pXAudio2->Release();
pXAudio2 = NULL;
#ifdef LOG
fprintf(Log, "M3D_activate GetDeviceDetails failed %d\n", hResult);
#endif
return M3D_NOT_INIT;
}
UINT32 SampleRate = MIN(MAX(deviceDetails.OutputFormat.Format.nSamplesPerSec, XAUDIO2FX_REVERB_MIN_FRAMERATE), XAUDIO2FX_REVERB_MAX_FRAMERATE);
if(FAILED(hResult = pXAudio2->CreateMasteringVoice(&pMasterVoice, XAUDIO2_DEFAULT_CHANNELS, SampleRate)))
{
pXAudio2->Release();
pXAudio2 = NULL;
#ifdef LOG
fprintf(Log, "M3D_activate CreateMasteringVoice failed %d\n", hResult);
#endif
return M3D_NOT_INIT;
}
X3DAudioInitialize(deviceDetails.OutputFormat.dwChannelMask, X3DAUDIO_SPEED_OF_SOUND, X3DAudioInstance);
memset(&Listener, 0, sizeof(M3D_Listener));
Listener.pMasterVoice = pMasterVoice;
Listener.Z_face = 1.0f;
Listener.Y_up = 1.0f;
UpdateAllSamples();
X3DDSPSettings.SrcChannelCount = 1;
X3DDSPSettings.DstChannelCount = deviceDetails.OutputFormat.Format.nChannels;
X3DDSPSettings.pMatrixCoefficients = new FLOAT32[deviceDetails.OutputFormat.Format.nChannels];
memset(X3DDSPSettings.pMatrixCoefficients, 0, sizeof(FLOAT32) * deviceDetails.OutputFormat.Format.nChannels);
Samples = new M3D_Source[MAX_SAMPLES_COUNT];
memset(Samples, 0, sizeof(M3D_Source) * MAX_SAMPLES_COUNT);
for(int i = 0; i < MAX_SAMPLES_COUNT; i++)
{
SetSampleDefaults(&Samples[i]);
if(FAILED(hResult = XAudio2CreateReverb(&Samples[i].pReverbEffect)))
{
pMasterVoice->DestroyVoice();
pMasterVoice = NULL;
pXAudio2->Release();
pXAudio2 = NULL;
#ifdef LOG
fprintf(Log, "M3D_activate XAudio2CreateReverb failed %d\n", hResult);
#endif
return M3D_NOT_INIT;
}
XAUDIO2_EFFECT_DESCRIPTOR effects[] = { { Samples[i].pReverbEffect, TRUE, 1 } };
XAUDIO2_EFFECT_CHAIN effectChain = { 1, effects };
if(FAILED(hResult = pXAudio2->CreateSubmixVoice(&Samples[i].pSubmixVoice, 1, SampleRate, 0, 0, NULL, Samples[i].pReverbEffect ? &effectChain : NULL)))
{
Samples[i].pReverbEffect->Release();
Samples[i].pReverbEffect = NULL;
pMasterVoice->DestroyVoice();
pMasterVoice = NULL;
pXAudio2->Release();
pXAudio2 = NULL;
#ifdef LOG
fprintf(Log, "M3D_activate CreateSubmixVoice(%d) failed %d\n", deviceDetails.OutputFormat.Format.nSamplesPerSec, hResult);
#endif
return M3D_NOT_INIT;
}
XAUDIO2FX_REVERB_PARAMETERS native;
ReverbConvertI3DL2ToNative( &ROOM_PRESET_PARAMS[Current_EAX_room_type], &native );
Samples[i].pSubmixVoice->SetEffectParameters(0, &native, sizeof(native));
}
}
else
{
if(!pXAudio2)
return M3D_NOT_INIT;
if(Samples)
{
for(int i = 0; i < MAX_SAMPLES_COUNT; i++)
{
M3D_end_3D_sample((M3D_SAMPLE)&Samples[i]);
if(Samples[i].pSubmixVoice)
{
Samples[i].pSubmixVoice->DestroyVoice();
Samples[i].pSubmixVoice = NULL;
}
if(Samples[i].pReverbEffect)
{
Samples[i].pReverbEffect->Release();
Samples[i].pReverbEffect = NULL;
}
}
delete[] Samples;
Samples = NULL;
}
if(pMasterVoice)
{
pMasterVoice->DestroyVoice();
pMasterVoice = NULL;
}
if(X3DDSPSettings.pMatrixCoefficients)
{
delete[] X3DDSPSettings.pMatrixCoefficients;
X3DDSPSettings.pMatrixCoefficients = NULL;
}
if(pXAudio2)
{
pXAudio2->Release();
pXAudio2 = NULL;
}
}
#ifdef LOG
fprintf(Log, "M3D_activate(%d) ok\n", enable);
#endif
return M3D_NOERR;
}
