void Audio::CreateResources() { do { if (FAILED(XAudio2Create(&m_musicEngine))) { m_engineExperiencedCriticalError = true; break; } #if defined(_DEBUG) XAUDIO2_DEBUG_CONFIGURATION debugConfig = {0}; debugConfig.BreakMask = XAUDIO2_LOG_ERRORS; debugConfig.TraceMask = XAUDIO2_LOG_ERRORS; m_musicEngine->SetDebugConfiguration(&debugConfig); #endif m_musicEngineCallback.Initialize(this); m_musicEngine->RegisterForCallbacks(&m_musicEngineCallback); // This sample plays the equivalent of background music, which we tag on the mastering voice as AudioCategory_GameMedia. // In ordinary usage, if we were playing the music track with no effects, we could route it entirely through // Media Foundation. Here we are using XAudio2 to apply a reverb effect to the music, so we use Media Foundation to // decode the data then we feed it through the XAudio2 pipeline as a separate Mastering Voice, so that we can tag it // as Game Media. // We default the mastering voice to 2 channels to simplify the reverb logic. if(FAILED(m_musicEngine->CreateMasteringVoice(&m_musicMasteringVoice, XAUDIO2_DEFAULT_CHANNELS, XAUDIO2_DEFAULT_SAMPLERATE, 0, nullptr, nullptr, AudioCategory_GameMedia))) { m_engineExperiencedCriticalError = true; break; } // Create a separate engine and mastering voice for sound effects in the sample // Games will use many voices in a complex graph for audio, mixing all effects down to a // single mastering voice. // We are creating an entirely new engine instance and mastering voice in order to tag // our sound effects with the audio category AudioCategory_GameEffects. if(FAILED(XAudio2Create(&m_soundEffectEngine))) { m_engineExperiencedCriticalError = true; break; } m_soundEffectEngineCallback.Initialize(this); m_soundEffectEngine->RegisterForCallbacks(&m_soundEffectEngineCallback); // We default the mastering voice to 2 channels to simplify the reverb logic. if(FAILED(m_soundEffectEngine->CreateMasteringVoice(&m_soundEffectMasteringVoice, XAUDIO2_DEFAULT_CHANNELS, XAUDIO2_DEFAULT_SAMPLERATE, 0, nullptr, nullptr, AudioCategory_GameEffects))) { m_engineExperiencedCriticalError = true; break; } } while (false); }
Audio::Audio() { HRESULT result; result = XAudio2Create(&pXAudio2, 0, XAUDIO2_DEFAULT_PROCESSOR); result = pXAudio2->CreateMasteringVoice(&pMasterVoice); pMusicVoice = nullptr; ZeroMemory(&musicBuffer, sizeof(musicBuffer)); musicBuffer.LoopCount = XAUDIO2_LOOP_INFINITE; masterVolume = System::GetOptions()->GetMasterVolume(); musicVolume = System::GetOptions()->GetMusicVolume(); soundEffectsVolume = System::GetOptions()->GetSoundEffectVolume(); finished = false; for (int i = 0; i < MAX_SOUNDS; i++) { voices[i].active = false; time(&voices[i].lastUsed); ZeroMemory(&voices[i].Buffer, sizeof(voices[i].Buffer)); voices[i].wfx = { 0 }; voices[i].filename.clear(); } std::thread(&Audio::FindFinishedVoices, this).detach(); }
bool XAudioInterface::Init( ) { CoInitializeEx(NULL, COINIT_MULTITHREADED); //CoInitialize(NULL); HRESULT hr; UINT32 xAudioCreationFlag = 0; #ifdef _DEBUG //xAudioCreationFlag = XAUDIO2_DEBUG_ENGINE; #endif if ( FAILED(hr = XAudio2Create( &m_XAudio2, xAudioCreationFlag, XAUDIO2_DEFAULT_PROCESSOR ) )) { return false; } // If we ever have to look for multiple device, it can be done through the following code: // http://msdn.microsoft.com/en-us/library/bb669173(VS.85).aspx // for now, we are going to use the default device since Win7 games will not require // advance features. if ( FAILED(hr = m_XAudio2->CreateMasteringVoice( &m_MasterVoice, XAUDIO2_DEFAULT_CHANNELS, XAUDIO2_DEFAULT_SAMPLERATE, 0, 0, NULL ) ) ) { return false; } return true; }
int SoundDevice::CreateSoundDevice( U_INT speakers ) { #ifdef _DEBUG static const UINT32 flags = XAUDIO2_DEBUG_ENGINE; #else static const UINT32 flags = 0; #endif if( FAILED( CoInitializeEx( NULL, COINIT_MULTITHREADED ) ) ) { return -1; } if( FAILED( XAudio2Create( &xAudio, flags ) ) ) { CoUninitialize(); return -2; } if( FAILED( xAudio->CreateMasteringVoice( &masterVoice ) ) ) { CoUninitialize(); return -3; } return 0; }
// 初期化 HRESULT IXAudioDevice::Initialize(){ // エラー処理用 HRESULT hr; // COMの初期化 CoInitializeEx( NULL, COINIT_MULTITHREADED ); // IXAudio2の初期化 UINT32 flags = 0; #ifdef _DEBUG flags |= XAUDIO2_DEBUG_ENGINE; #endif hr = XAudio2Create( &m_pXAudio2, flags ); if( FAILED( hr ) ){ return E_FAIL; } // IXAudio2MasteringVoiceの初期化 hr = m_pXAudio2->CreateMasteringVoice( &m_pMasteringVoice ); if( FAILED( hr ) ){ return E_FAIL; } return S_OK; }
XAudio2SoundDevice::XAudio2SoundDevice() : SoundDevice(SOUNDDEVICE_XAUDIO2), Device_(0), MasterVoice_(0) { /* Initialize XAudio2 */ #ifndef SP_PLATFORM_XBOX CoInitializeEx(0, COINIT_MULTITHREADED); #endif /* Create XAudio2 device */ UINT32 Flags = 0; #ifdef _DEBUG Flags |= XAUDIO2_DEBUG_ENGINE; #endif if (XAudio2Create(&Device_, Flags) != S_OK) { io::Log::error("Could not create XAudio2 device"); return; } /* Create mastering voice */ if (Device_->CreateMasteringVoice(&MasterVoice_) != S_OK) { io::Log::error("Could not create mastering voice"); return; } }
XAudio2Player::XAudio2Player(void) { currentBufferNumber = 0; CoInitializeEx( NULL, COINIT_MULTITHREADED ); pXAudio2 = NULL; HRESULT hr; if( FAILED(hr = XAudio2Create( &pXAudio2, 0, XAUDIO2_DEFAULT_PROCESSOR ) ) ) return; IXAudio2MasteringVoice* pMasterVoice = NULL; if ( FAILED(hr = pXAudio2->CreateMasteringVoice( &pMasterVoice ) ) ) return; wf.wFormatTag = WAVE_FORMAT_PCM; wf.nChannels = 2; wf.nSamplesPerSec = 44100; wf.nAvgBytesPerSec = 44100 * 4; wf.nBlockAlign = 4; wf.wBitsPerSample = 16; wf.cbSize = 0; if( FAILED(hr = pXAudio2->CreateSourceVoice( &pSourceVoice, &wf, 0, 1.0f, &voiceContext ) ) ) return; if ( FAILED(hr = pSourceVoice->Start( 0, 0 ) ) ) return; doUpdate = true; t = std::thread(&XAudio2Player::Play, this); }
XAudio2Thread::XAudio2Thread() : m_xaudio2_instance(nullptr) , m_master_voice(nullptr) , m_source_voice(nullptr) { HRESULT hr = S_OK; hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED); if (FAILED(hr)) { LOG_ERROR(GENERAL, "XAudio2Thread : CoInitializeEx() failed(0x%08x)", (u32)hr); Emu.Pause(); return; } hr = XAudio2Create(&m_xaudio2_instance, 0, XAUDIO2_DEFAULT_PROCESSOR); if (FAILED(hr)) { LOG_ERROR(GENERAL, "XAudio2Thread : XAudio2Create() failed(0x%08x)", (u32)hr); Emu.Pause(); return; } hr = m_xaudio2_instance->CreateMasteringVoice(&m_master_voice); if (FAILED(hr)) { LOG_ERROR(GENERAL, "XAudio2Thread : CreateMasteringVoice() failed(0x%08x)", (u32)hr); m_xaudio2_instance->Release(); Emu.Pause(); } }
bool XAudio2_7::Start() { HRESULT hr; // callback doesn't seem to run on a specific cpu anyways IXAudio2* xaudptr; if (FAILED(hr = XAudio2Create(&xaudptr, 0, XAUDIO2_DEFAULT_PROCESSOR))) { PanicAlertT("XAudio2_7 init failed: %#X", hr); Stop(); return false; } m_xaudio2 = std::unique_ptr<IXAudio2, Releaser>(xaudptr); // XAudio2 master voice // XAUDIO2_DEFAULT_CHANNELS instead of 2 for expansion? if (FAILED(hr = m_xaudio2->CreateMasteringVoice(&m_mastering_voice, 2, m_mixer->GetSampleRate()))) { PanicAlertT("XAudio2_7 master voice creation failed: %#X", hr); Stop(); return false; } // Volume m_mastering_voice->SetVolume(m_volume); m_voice_context = std::unique_ptr<StreamingVoiceContext2_7> (new StreamingVoiceContext2_7(m_xaudio2.get(), m_mixer, m_sound_sync_event)); return true; }
bool CAudioManager::Init() { HRESULT hr; hr = XAudio2Create(&m_pXAudio2, 0, XAUDIO2_DEFAULT_PROCESSOR); if(FAILED(hr)) { LogErrorHr("Failed to create XAudio2", hr); return false; } hr = m_pXAudio2->CreateMasteringVoice(&m_pDevice); if(FAILED(hr)) { LogErrorHr("Failed to create mastering voice", hr); return false; } for(int iTrackIndex = 0; iTrackIndex < g_iAudioTrackCount; iTrackIndex++) { if(!m_tracks[iTrackIndex].Init(m_pXAudio2, m_pDevice)) { return false; } } m_bInited = true; return true; }
XAudio2Player::XAudio2Player(IXAudio2* pxa, int &status) { currentBufferNumber = 0; pXAudio2 = pxa; HRESULT hr; if( FAILED(hr = XAudio2Create( &pXAudio2, 0, XAUDIO2_DEFAULT_PROCESSOR ) ) ) status = SA_XAUDIO2_ERROR; IXAudio2MasteringVoice* pMasterVoice = NULL; if ( FAILED(hr = pXAudio2->CreateMasteringVoice( &pMasterVoice ) ) ) status = SA_XAUDIO2_ERROR; wf.wFormatTag = WAVE_FORMAT_PCM; wf.nChannels = 2; wf.nSamplesPerSec = 44100; wf.nAvgBytesPerSec = 44100 * 4; wf.nBlockAlign = 4; wf.wBitsPerSample = 16; wf.cbSize = 0; if( FAILED(hr = pXAudio2->CreateSourceVoice( &pSourceVoice, &wf, 0, 1.0f, &voiceContext ) ) ) status = SA_XAUDIO2_ERROR; if ( FAILED(hr = pSourceVoice->Start( 0, 0 ) ) ) status = SA_XAUDIO2_ERROR; doUpdate = true; t = std::thread(&XAudio2Player::Play, this); }
void EngineService::AcceptVisitor( JobFiber& /*fiber*/, const ConfigurationBroadcastVisitor ) { enum : UINT32 { XAudio2CreateFlags = (ETIsDebugModeEnabled() ? XAUDIO2_DEBUG_ENGINE : 0) }; ComPointer<IXAudio2> audio; _log( MessageSeverity::Message, "Creating XAudio2 instance." ET_UTF8_NEWLINE_LITERAL ); if( FAILED( XAudio2Create( audio.GetInterfacePointer(), XAudio2CreateFlags, XAUDIO2_DEFAULT_PROCESSOR ) ) ) { _log( MessageSeverity::Error, "Unable to create XAudio2 instance!" ET_UTF8_NEWLINE_LITERAL ); return; } if( FAILED( audio->RegisterForCallbacks( this ) ) ) { _log( MessageSeverity::Error, "Unable to register XAudio2 device callbacks!" ET_UTF8_NEWLINE_LITERAL ); return; } if( FAILED( audio->StartEngine() ) ) { _log( MessageSeverity::Error, "Unable to start XAudio2 engine!" ET_UTF8_NEWLINE_LITERAL ); return; } _log( MessageSeverity::Message, "Created XAudio2 instance." ET_UTF8_NEWLINE_LITERAL ); // Commit changes to the service. _audio = eastl::move( audio ); }
static int XAUDIO2_Init(SDL_AudioDriverImpl * impl) { /* XAudio2Create() is a macro that uses COM; we don't load the .dll */ IXAudio2 *ixa2 = NULL; if (FAILED(WIN_CoInitialize())) { SDL_SetError("XAudio2: CoInitialize() failed"); return 0; } if (XAudio2Create(&ixa2, 0, XAUDIO2_DEFAULT_PROCESSOR) != S_OK) { WIN_CoUninitialize(); SDL_SetError("XAudio2: XAudio2Create() failed"); return 0; /* not available. */ } IXAudio2_Release(ixa2); /* Set the function pointers */ impl->DetectDevices = XAUDIO2_DetectDevices; impl->OpenDevice = XAUDIO2_OpenDevice; impl->PlayDevice = XAUDIO2_PlayDevice; impl->WaitDevice = XAUDIO2_WaitDevice; impl->WaitDone = XAUDIO2_WaitDone; impl->GetDeviceBuf = XAUDIO2_GetDeviceBuf; impl->CloseDevice = XAUDIO2_CloseDevice; impl->Deinitialize = XAUDIO2_Deinitialize; return 1; /* this audio target is available. */ }
static void XAUDIO2_DetectDevices(void) { IXAudio2 *ixa2 = NULL; UINT32 devcount = 0; UINT32 i = 0; if (XAudio2Create(&ixa2, 0, XAUDIO2_DEFAULT_PROCESSOR) != S_OK) { SDL_SetError("XAudio2: XAudio2Create() failed at detection."); return; } else if (IXAudio2_GetDeviceCount(ixa2, &devcount) != S_OK) { SDL_SetError("XAudio2: IXAudio2::GetDeviceCount() failed."); IXAudio2_Release(ixa2); return; } for (i = 0; i < devcount; i++) { XAUDIO2_DEVICE_DETAILS details; if (IXAudio2_GetDeviceDetails(ixa2, i, &details) == S_OK) { char *str = WIN_StringToUTF8(details.DisplayName); if (str != NULL) { SDL_AddAudioDevice(SDL_FALSE, str, (void *) ((size_t) i+1)); SDL_free(str); /* SDL_AddAudioDevice made a copy of the string. */ } } } IXAudio2_Release(ixa2); }
/* Constructor */ XAudioSoundSystem::XAudioSoundSystem(void) { HRESULT hr; mXAudio2 = NULL; mMasteringVoice = NULL; UINT32 flags = 0; // // Initialize XAudio2 // CoInitializeEx( NULL, COINIT_MULTITHREADED ); if( FAILED( hr = XAudio2Create( &mXAudio2, flags ) ) ) { wprintf( L"Failed to init XAudio2 engine: %#X\n", hr ); return; } // // Create a mastering voice // if( FAILED( hr = mXAudio2->CreateMasteringVoice( &mMasteringVoice ) ) ) { wprintf( L"Failed creating mastering voice: %#X\n", hr ); SAFE_RELEASE( mXAudio2 ); return; } }
static void XAUDIO2_DetectDevices(int iscapture, SDL_AddAudioDevice addfn) { IXAudio2 *ixa2 = NULL; UINT32 devcount = 0; UINT32 i = 0; void *ptr = NULL; if (iscapture) { SDL_SetError("XAudio2: capture devices unsupported."); return; } else if (XAudio2Create(&ixa2, 0, XAUDIO2_DEFAULT_PROCESSOR) != S_OK) { SDL_SetError("XAudio2: XAudio2Create() failed."); return; } else if (IXAudio2_GetDeviceCount(ixa2, &devcount) != S_OK) { SDL_SetError("XAudio2: IXAudio2::GetDeviceCount() failed."); IXAudio2_Release(ixa2); return; } for (i = 0; i < devcount; i++) { XAUDIO2_DEVICE_DETAILS details; if (IXAudio2_GetDeviceDetails(ixa2, i, &details) == S_OK) { char *str = utf16_to_utf8(details.DisplayName); if (str != NULL) { addfn(str); SDL_free(str); /* addfn() made a copy of the string. */ } } } IXAudio2_Release(ixa2); }
//---------------------------------------------------------------------------------------------------- bool EEMusic::InitializeMusic() { if (!s_isMusicInitialized) { av_register_all(); // CoInitializeEx(NULL, COINIT_MULTITHREADED); if (FAILED(XAudio2Create(&s_XAudio2, 0))) { MessageBoxW(NULL, L"Create XAudio2 failed!", L"ERROR", MB_OK); // CoUninitialize(); return false; } if (FAILED(s_XAudio2->CreateMasteringVoice(&s_masteringVoice))) { MessageBoxW(NULL, L"Create mastering voice failed!", L"ERROR", MB_OK); s_XAudio2->Release(); s_XAudio2 = NULL; // CoUninitialize(); return false; } s_isMusicInitialized = true; } return true; }
static int XAUDIO2_Init(SDL_AudioDriverImpl * impl) { #ifndef SDL_XAUDIO2_HAS_SDK SDL_SetError("XAudio2: SDL was built without XAudio2 support (old DirectX SDK)."); return 0; /* no XAudio2 support, ever. Update your SDK! */ #else /* XAudio2Create() is a macro that uses COM; we don't load the .dll */ IXAudio2 *ixa2 = NULL; if (FAILED(WIN_CoInitialize())) { SDL_SetError("XAudio2: CoInitialize() failed"); return 0; } if (XAudio2Create(&ixa2, 0, XAUDIO2_DEFAULT_PROCESSOR) != S_OK) { WIN_CoUninitialize(); SDL_SetError("XAudio2: XAudio2Create() failed"); return 0; /* not available. */ } IXAudio2_Release(ixa2); /* Set the function pointers */ impl->DetectDevices = XAUDIO2_DetectDevices; impl->OpenDevice = XAUDIO2_OpenDevice; impl->PlayDevice = XAUDIO2_PlayDevice; impl->WaitDevice = XAUDIO2_WaitDevice; impl->WaitDone = XAUDIO2_WaitDone; impl->GetDeviceBuf = XAUDIO2_GetDeviceBuf; impl->CloseDevice = XAUDIO2_CloseDevice; impl->Deinitialize = XAUDIO2_Deinitialize; return 1; /* this audio target is available. */ #endif }
static xaudio2_t *xaudio2_new(unsigned samplerate, unsigned channels, size_t size, unsigned device) { xaudio2_t *handle = NULL; WAVEFORMATEX wfx = {0}; #if defined(__cplusplus) && !defined(CINTERFACE) handle = new xaudio2; #else handle = (xaudio2_t*)calloc(1, sizeof(*handle)); #endif if (!handle) goto error; #if !defined(__cplusplus) || defined(CINTERFACE) handle->lpVtbl = &voice_vtable; #endif if (FAILED(XAudio2Create(&handle->pXAudio2, 0, XAUDIO2_DEFAULT_PROCESSOR))) goto error; #if (_WIN32_WINNT >= 0x0602 /*_WIN32_WINNT_WIN8*/) if (FAILED(IXAudio2_CreateMasteringVoice(handle->pXAudio2, &handle->pMasterVoice, channels, samplerate, 0, (LPCWSTR)(uintptr_t)device, NULL, AudioCategory_GameEffects))) goto error; #else if (FAILED(IXAudio2_CreateMasteringVoice(handle->pXAudio2, &handle->pMasterVoice, channels, samplerate, 0, device, NULL))) goto error; #endif xaudio2_set_wavefmt(&wfx, channels, samplerate); if (FAILED(IXAudio2_CreateSourceVoice(handle->pXAudio2, &handle->pSourceVoice, &wfx, XAUDIO2_VOICE_NOSRC, XAUDIO2_DEFAULT_FREQ_RATIO, (IXAudio2VoiceCallback*)handle, 0, 0))) goto error; handle->hEvent = CreateEvent(0, FALSE, FALSE, 0); if (!handle->hEvent) goto error; handle->bufsize = size / MAX_BUFFERS; handle->buf = (uint8_t*)calloc(1, handle->bufsize * MAX_BUFFERS); if (!handle->buf) goto error; if (FAILED(IXAudio2SourceVoice_Start(handle->pSourceVoice, 0, XAUDIO2_COMMIT_NOW))) goto error; return handle; error: xaudio2_free(handle); return NULL; }
BOOL XAudio2SoundDriverLegacy::Setup() { if (dllInitialized == true) return true; dllInitialized = true; bufferLength[0] = bufferLength[1] = bufferLength[2] = bufferLength[3] = bufferLength[4] = bufferLength[5] = 0; bufferLength[6] = bufferLength[7] = bufferLength[8] = bufferLength[9] = 0; audioIsPlaying = false; writeBuffer = 0; readBuffer = 0; filledBuffers = 0; bufferBytes = 0; lastLength = 1; cacheSize = 0; interrupts = 0; hMutex = CreateMutex(NULL, FALSE, NULL); if (FAILED(XAudio2Create(&g_engine))) { CoUninitialize(); return -1; } if (FAILED(g_engine->CreateMasteringVoice(&g_master))) { g_engine->Release(); CoUninitialize(); return -2; } canPlay = true; // Load Wave File WAVEFORMATEX wfm; memset(&wfm, 0, sizeof(WAVEFORMATEX)); wfm.wFormatTag = WAVE_FORMAT_PCM; wfm.nChannels = 2; wfm.nSamplesPerSec = 44100; wfm.wBitsPerSample = 16; // TODO: Allow 8bit audio... wfm.nBlockAlign = wfm.wBitsPerSample / 8 * wfm.nChannels; wfm.nAvgBytesPerSec = wfm.nSamplesPerSec * wfm.nBlockAlign; if (FAILED(g_engine->CreateSourceVoice(&g_source, &wfm, 0, XAUDIO2_DEFAULT_FREQ_RATIO, &voiceCallback, NULL, NULL))) { g_engine->Release(); CoUninitialize(); return -3; } g_source->Start(); SetVolume(Configuration::getVolume()); return FALSE; }
bool Player::Create() { if (FAILED(XAudio2Create(&AudioDriver, 0, XAUDIO2_DEFAULT_PROCESSOR))) return false; if (FAILED(AudioDriver->CreateMasteringVoice(&AudioMVoice))) return false; return true; }
void Audio::Initialize(bool music, bool fx) { m = music; f = fx; HRESULT hr = XAudio2Create(&s_pXAudio2, 0, XAUDIO2_DEFAULT_PROCESSOR); assert(SUCCEEDED(hr)); hr = s_pXAudio2->CreateMasteringVoice(&s_pMasterVoice); assert(SUCCEEDED(hr)); }
virtual const char* open( void * hwnd, unsigned sample_rate, unsigned nch, unsigned max_samples_per_frame, unsigned num_frames ) { this->hwnd = hwnd; this->sample_rate = sample_rate; this->nch = nch; this->max_samples_per_frame = max_samples_per_frame; this->num_frames = num_frames; #ifdef HAVE_KS_HEADERS WAVEFORMATEXTENSIBLE wfx; wfx.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE; wfx.Format.nChannels = nch; //1; wfx.Format.nSamplesPerSec = sample_rate; wfx.Format.nBlockAlign = 2 * nch; //2; wfx.Format.nAvgBytesPerSec = wfx.Format.nSamplesPerSec * wfx.Format.nBlockAlign; wfx.Format.wBitsPerSample = 16; wfx.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX); wfx.Samples.wValidBitsPerSample = 16; wfx.SubFormat = KSDATAFORMAT_SUBTYPE_PCM; wfx.dwChannelMask = nch == 2 ? KSAUDIO_SPEAKER_STEREO : KSAUDIO_SPEAKER_MONO; #else WAVEFORMATEX wfx; wfx.wFormatTag = WAVE_FORMAT_PCM; wfx.nChannels = nch; //1; wfx.nSamplesPerSec = sample_rate; wfx.nBlockAlign = 2 * nch; //2; wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign; wfx.wBitsPerSample = 16; wfx.cbSize = 0; #endif HRESULT hr = XAudio2Create( &xaud, 0 ); if (FAILED(hr)) return "Creating XAudio2 interface"; hr = xaud->CreateMasteringVoice( &mVoice, nch, sample_rate, 0, NULL, NULL ); if (FAILED(hr)) return "Creating XAudio2 mastering voice"; hr = xaud->CreateSourceVoice( &sVoice, &wfx, 0, 4.0f, ¬ify ); if (FAILED(hr)) return "Creating XAudio2 source voice"; hr = sVoice->Start( 0 ); if (FAILED(hr)) return "Starting XAudio2 voice"; hr = sVoice->SetFrequencyRatio((float)1.0f); if (FAILED(hr)) return "Setting XAudio2 voice frequency ratio"; buffered_count = 0; buffer_read_cursor = 0; buffer_write_cursor = 0; samples_played = 0; sample_buffer = new int16_t[ max_samples_per_frame * num_frames ]; samples_in_buffer = new UINT64[ num_frames ]; memset( samples_in_buffer, 0, sizeof( UINT64 ) * num_frames ); return NULL; }
Error AudioDriverXAudio2::init() { active = false; thread_exited = false; exit_thread = false; pcm_open = false; samples_in = NULL; mix_rate = 48000; // FIXME: speaker_mode seems unused in the Xaudio2 driver so far speaker_mode = SPEAKER_MODE_STEREO; channels = 2; int latency = GLOBAL_DEF("audio/output_latency", 25); buffer_size = closest_power_of_2(latency * mix_rate / 1000); samples_in = memnew_arr(int32_t, buffer_size * channels); for (int i = 0; i < AUDIO_BUFFERS; i++) { samples_out[i] = memnew_arr(int16_t, buffer_size * channels); xaudio_buffer[i].AudioBytes = buffer_size * channels * sizeof(int16_t); xaudio_buffer[i].pAudioData = (const BYTE *)(samples_out[i]); xaudio_buffer[i].Flags = 0; } HRESULT hr; hr = XAudio2Create(&xaudio, 0, XAUDIO2_DEFAULT_PROCESSOR); if (hr != S_OK) { ERR_EXPLAIN("Error creating XAudio2 engine."); ERR_FAIL_V(ERR_UNAVAILABLE); } hr = xaudio->CreateMasteringVoice(&mastering_voice); if (hr != S_OK) { ERR_EXPLAIN("Error creating XAudio2 mastering voice."); ERR_FAIL_V(ERR_UNAVAILABLE); } wave_format.nChannels = channels; wave_format.cbSize = 0; wave_format.nSamplesPerSec = mix_rate; wave_format.wFormatTag = WAVE_FORMAT_PCM; wave_format.wBitsPerSample = 16; wave_format.nBlockAlign = channels * wave_format.wBitsPerSample >> 3; wave_format.nAvgBytesPerSec = mix_rate * wave_format.nBlockAlign; hr = xaudio->CreateSourceVoice(&source_voice, &wave_format, 0, XAUDIO2_MAX_FREQ_RATIO, &voice_callback); if (hr != S_OK) { ERR_EXPLAIN("Error creating XAudio2 source voice. " + itos(hr)); ERR_FAIL_V(ERR_UNAVAILABLE); } mutex = Mutex::create(); thread = Thread::create(AudioDriverXAudio2::thread_func, this); return OK; };
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 InitXAudio(Game* thegame) { CoInitializeEx(NULL, COINIT_MULTITHREADED); HRESULT hr = XAudio2Create(&XAudio2, 0, XAUDIO2_DEFAULT_PROCESSOR); if(FAILED(hr)) exit(EXIT_FAILURE); hr = XAudio2->CreateMasteringVoice(&MasterVoice); if(FAILED(hr)) exit(EXIT_FAILURE); }
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(); } }
//---------------------------------------------------------------------------------- // //---------------------------------------------------------------------------------- void InitSound() { HRESULT hr; hr = CoInitializeEx(NULL, COINIT_MULTITHREADED); hr = XAudio2Create(&g_xaudio2, 0); hr = g_xaudio2->CreateMasteringVoice(&g_masteringVoice, 2, 44100); g_sound = EffekseerSound::Sound::Create(g_xaudio2, 16, 16); g_manager->SetSoundPlayer( g_sound->CreateSoundPlayer() ); g_manager->SetSoundLoader( g_sound->CreateSoundLoader() ); }
void GameAudio::initialize() { currentMusicPlaying = ENUM_MUSIC_NONE; //// initially, current music is none bool ciFailed = FAILED(CoInitializeEx(0, COINIT_MULTITHREADED)); UINT32 flags = 0; bool xa2cSuccess = SUCCEEDED(XAudio2Create(&xAudio2Engine)); bool cmvSuccess = SUCCEEDED(xAudio2Engine->CreateMasteringVoice(&masterVoice, XAUDIO2_DEFAULT_CHANNELS, XAUDIO2_DEFAULT_SAMPLERATE, 0, 0, 0)); //// -- still not sure if I need only one master voice or multiple(one master per one source voice) }
xaudio2_t *xaudio2_new(unsigned samplerate, unsigned channels, size_t size, unsigned device) { xaudio2_t *handle = (xaudio2_t*)calloc(1, sizeof(*handle)); if (!handle) return NULL; handle->lpVtbl = &voice_vtable; CoInitializeEx(0, COINIT_MULTITHREADED); WAVEFORMATEX wfx = {0}; if (FAILED(XAudio2Create(&handle->pXAudio2))) goto error; if (FAILED(IXAudio2_CreateMasteringVoice(handle->pXAudio2, &handle->pMasterVoice, channels, samplerate, 0, device, NULL))) goto error; wfx.wFormatTag = WAVE_FORMAT_IEEE_FLOAT; wfx.nChannels = channels; wfx.nSamplesPerSec = samplerate; wfx.nBlockAlign = channels * sizeof(float); wfx.wBitsPerSample = sizeof(float) * 8; wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign; wfx.cbSize = 0; if (FAILED(IXAudio2_CreateSourceVoice(handle->pXAudio2, &handle->pSourceVoice, &wfx, XAUDIO2_VOICE_NOSRC, XAUDIO2_DEFAULT_FREQ_RATIO, (IXAudio2VoiceCallback*)handle, 0, 0))) goto error; handle->hEvent = CreateEvent(0, FALSE, FALSE, 0); if (!handle->hEvent) goto error; handle->bufsize = size / MAX_BUFFERS; handle->buf = (uint8_t*)calloc(1, handle->bufsize * MAX_BUFFERS); if (!handle->buf) goto error; if (FAILED(IXAudio2SourceVoice_Start(handle->pSourceVoice, 0, XAUDIO2_COMMIT_NOW))) goto error; return handle; error: xaudio2_free(handle); return NULL; }