// Thread: Any. Must be locked: AudioMutex. bool CreatePlaybackDevice() { if (AudioDevice) return true; AudioDevice = alcOpenDevice(nullptr); if (!AudioDevice) { LOG(("Audio Error: Could not create default playback device, enumerating..")); EnumeratePlaybackDevices(); return false; } ALCint attributes[] = { ALC_STEREO_SOURCES, 128, ALC_FREQUENCY, Media::Player::kDefaultFrequency, 0 }; AudioContext = alcCreateContext(AudioDevice, attributes); alcMakeContextCurrent(AudioContext); if (ContextErrorHappened()) { DestroyPlaybackDevice(); return false; } ALfloat v[] = { 0.f, 0.f, -1.f, 0.f, 1.f, 0.f }; alListener3f(AL_POSITION, 0.f, 0.f, 0.f); alListener3f(AL_VELOCITY, 0.f, 0.f, 0.f); alListenerfv(AL_ORIENTATION, v); #ifndef TDESKTOP_DISABLE_OPENAL_EFFECTS // playback speed related init // generate an effect slot and an effect alGenAuxiliaryEffectSlots(1, &_playbackSpeedData.uiEffectSlot); alGenEffects(1, &_playbackSpeedData.uiEffect); // initialize the pitch shifter effect alEffecti(_playbackSpeedData.uiEffect, AL_EFFECT_TYPE, AL_EFFECT_PITCH_SHIFTER); // 12 semitones = 1 octave alEffecti(_playbackSpeedData.uiEffect, AL_PITCH_SHIFTER_COARSE_TUNE, kPlaybackSpeedTune); // connect the effect with the effect slot alAuxiliaryEffectSloti(_playbackSpeedData.uiEffectSlot, AL_EFFECTSLOT_EFFECT, _playbackSpeedData.uiEffect); // initialize a filter to disable the direct (dry) path alGenFilters(1, &_playbackSpeedData.uiFilter); alFilteri(_playbackSpeedData.uiFilter, AL_FILTER_TYPE, AL_FILTER_LOWPASS); // disable all frequencies alFilterf(_playbackSpeedData.uiFilter, AL_LOWPASS_GAIN, 0.f); // to use the modified playback speed: // connect both the effect slot and filter with the stream source and set AL_PITCH #endif // TDESKTOP_DISABLE_OPENAL_EFFECTS alDistanceModel(AL_NONE); return true; }
void CAListener::SetVel( const TVec &roVel ) const { #ifdef A_USE_OAL_DUMMY #else ALint iError; alGetError(); alListenerfv( AL_VELOCITY, roVel ); if( ( iError = alGetError() ) != AL_NO_ERROR ) { A_ERR( "alListenerfv VELOCITY (%s)\n", GetALErrorString_( iError ) ); return; } #endif // A_USE_OAL_DUMMY }
void Camera::init(float x, float y){ position->x = x; position->y = y; listenerPos[0] = 0.0; listenerPos[1] = 0.0; listenerPos[2] = 0.0; listenerVel[0] = 0.0; listenerVel[1] = 0.0; listenerVel[2] = 0.0; listenerOri[0] = 0.0; listenerOri[1] = 0.0; listenerOri[2] = -1.0; listenerOri[3] = 0.0; listenerOri[4] = 1.0; listenerOri[5] = 0.0; alListenerfv(AL_POSITION, listenerPos); alListenerfv(AL_VELOCITY, listenerVel); alListenerfv(AL_ORIENTATION, listenerOri); }
void setDirection(const Vector3f &direction) { listenerDirection = direction; float orientation[] = { listenerDirection.x, // Direction listenerDirection.y, listenerDirection.z, listenerUpVector.x, // Up vector listenerUpVector.y, listenerUpVector.z, }; alListenerfv(AL_ORIENTATION, orientation); }
void CAListener::SetPos( const TVec &roPos ) const { #ifdef A_USE_OAL_DUMMY #else ALint iError; alGetError(); alListenerfv( AL_POSITION, roPos ); if( ( iError = alGetError() ) != AL_NO_ERROR ) { A_ERR( "alListenerfv POSITION (%s)\n", GetALErrorString_( iError ) ); return; } #endif // A_USE_OAL_DUMMY }
static void setposition(ALfloat x, ALfloat y, ALfloat z) { ALfloat pos[3]; pos[0] = x; pos[1] = y; pos[2] = z; fprintf(stderr, "POSITION: [%f, %f, %f]\n", x, y, z); alListenerfv( AL_POSITION, pos ); fprintf(stderr, "--------------------------------\n"); return; }
static void init( const ALbyte *fname ) { ALfloat zeroes[] = { 0.0f, 0.0f, 0.0f }; ALfloat back[] = { 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f }; ALfloat front[] = { 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f }; ALuint boom; start = time( NULL ); alListenerfv( AL_POSITION, zeroes ); alListenerfv( AL_VELOCITY, zeroes ); alListenerfv( AL_ORIENTATION, front ); boom = CreateBufferFromFile( fname ); alGenSources( 1, &movingSource ); alSourcefv( movingSource, AL_POSITION, srcposition ); alSourcefv( movingSource, AL_VELOCITY, zeroes ); alSourcefv( movingSource, AL_DIRECTION, back ); alSourcei( movingSource, AL_BUFFER, boom ); alSourcei( movingSource, AL_LOOPING, AL_TRUE ); }
void Listener::clear(void) { union { ALfloat ort[6]; struct { ALfloat at[3]; ALfloat up[3]; }; } orient; orient.ort[0] = 0.0f; orient.ort[1] = 1.0f; orient.ort[2] = 0.0f; orient.ort[3] = 0.0f; orient.ort[4] = 0.0f; orient.ort[5] = 1.0f; ALfloat pos[3L] = { 0.0f, 0.0f, 0.0f }; alListenerfv(AL_POSITION, pos); alListenerfv(AL_ORIENTATION, orient.ort); setVelocity(osg::Vec3f(0.0f, 0.0f, 0.0f)); setGain(1.0); }
static void init( const char *fname) { ALfloat zeroes[] = { 0.0f, 0.0f, 0.0f }; ALfloat back[] = { 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f }; ALfloat front[] = { 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f }; ALuint boom; ALsizei size; ALsizei bits; ALsizei freq; ALsizei format; ALboolean err; start = time(NULL); alListenerfv(AL_POSITION, zeroes ); alListenerfv(AL_VELOCITY, zeroes ); alListenerfv(AL_ORIENTATION, front ); alGenBuffers( 1, &boom ); err = alutLoadWAV(fname, &wave, &format, &size, &bits, &freq); if(err == AL_FALSE) { fprintf(stderr, "Could not include %s\n", fname); exit(1); } alBufferData( boom, format, wave, size, freq ); free(wave); /* openal makes a local copy of wave data */ alGenSources( 1, &moving_source); alSourcef( moving_source, AL_GAIN_LINEAR_LOKI, 0.25 ); alSourcei( moving_source, AL_BUFFER, boom ); alSourcei( moving_source, AL_LOOPING, AL_TRUE); alSourcef( moving_source, AL_PITCH, 1.00); return; }
internal bool32 initialize_sound(sound_array *sounds) { ALCdevice *device = g_audioDevice = alcOpenDevice(NULL); if (device) { g_audioContext = alcCreateContext(device, NULL); if (alcMakeContextCurrent(g_audioContext)) { if (!start_new_log(AL_LOG_FILE)) { fprintf(stderr, "Failed to create new log file: %s\n", AL_LOG_FILE); } alListenerfv(AL_POSITION, g_listenerPos); alListenerfv(AL_VELOCITY, g_listenerVel); alListenerfv(AL_ORIENTATION, g_listenerOri); if (al_print_if_error("Failed to initialize listener\n")) return false; alGenSources(sounds->size, sounds->sources); if (al_print_if_error("Failed to generate audio sources\n")) return false; } else { al_log(true, "OpenAL: failed to make audio context current\n"); return false; } } else { al_log(true, "Failed to open device\n"); // TODO: fix bug where alcOpenDevice occasionally fails return false; } return true; }
void SoundListener::initListener() { mOrientation[0]= mDirection.x; // Forward.x mOrientation[1]= mDirection.y; // Forward.y mOrientation[2]= mDirection.z; // Forward.z mOrientation[3]= mUp.x; // Up.x mOrientation[4]= mUp.y; // Up.y mOrientation[5]= mUp.z; // Up.z alListener3f(AL_POSITION, mPosition.x, mPosition.y, mPosition.z); alListenerfv(AL_ORIENTATION, mOrientation); alListenerf (AL_GAIN, 1.0f); alListener3f(AL_VELOCITY, 0.0f, 0.0f, 0.0f); }
/* call-seq: setOrientation(atX, atY, at2, upX, upY, upZ) Sets the audio listener's orientation. */ VALUE Listener_setOrientation(VALUE self, VALUE atX, VALUE atY, VALUE atZ, VALUE upX, VALUE upY, VALUE upZ) { float args[6]; args[0] = NUM2DBL(atX); args[1] = NUM2DBL(atY); args[2] = NUM2DBL(atZ); args[3] = NUM2DBL(upX); args[4] = NUM2DBL(upY); args[5] = NUM2DBL(upZ); alListenerfv(AL_ORIENTATION, args); return Qnil; }
void CAListener::SetAmp( float fAmp ) const { #ifdef A_USE_OAL_DUMMY #else // Position. ALint iError; alGetError(); alListenerfv( AL_GAIN, &fAmp ); if( ( iError = alGetError() ) != AL_NO_ERROR ) { A_ERR( "alListenerfv GAIN (%s)\n", GetALErrorString_( iError ) ); return; } #endif // A_USE_OAL_DUMMY }
void Player::updateAudioListener() { alListener3f( AL_POSITION, pos_.x, pos_.y, pos_.z ); alListener3f( AL_VELOCITY, vel_.x, vel_.y, vel_.z ); ALfloat orientation[] = { camera_.position().x + camera_.direction().x, camera_.position().y + camera_.direction().y, camera_.position().z + camera_.direction().z, camera_.up().x, camera_.up().y, camera_.up().z }; alListenerfv( AL_ORIENTATION, orientation ); }
SoundPlayer::SoundPlayer() : _device(0), _context(0), _nextMatchlock(SoundSourceMatchlockFirst), _nextArrows(SoundSourceArrowsFirst), _nextCookie(1) { ALenum error; _device = alcOpenDevice(0); // select the "preferred device" if (_device) { _context = alcCreateContext(_device, 0); } alcMakeContextCurrent(_context); // Generate Buffers alGetError(); // clear error code alGenBuffers(NUMBER_OF_SOUND_BUFFERS, _buffers); if ((error = alGetError()) != AL_NO_ERROR) { //DisplayALError("alGenBuffers :", error); return; } alGenSources(NUMBER_OF_SOUND_SOURCES, _sources); if ((error = alGetError()) != AL_NO_ERROR) { return; } float orientation[6] = { 0.0f, 0.0f, -1.0f, // direction 0.0f, 1.0f, 0.0f //up }; orientation[0] = 0; //sin(rads); orientation[1] = 0.0f; // No Change to the Y vector orientation[2] = -1; //-cos(rads); alListenerfv(AL_ORIENTATION, orientation); }
void AUD_OpenALDevice::setListenerOrientation(const AUD_Quaternion& orientation) { ALfloat direction[6]; direction[0] = -2 * (orientation.w() * orientation.y() + orientation.x() * orientation.z()); direction[1] = 2 * (orientation.x() * orientation.w() - orientation.z() * orientation.y()); direction[2] = 2 * (orientation.x() * orientation.x() + orientation.y() * orientation.y()) - 1; direction[3] = 2 * (orientation.x() * orientation.y() - orientation.w() * orientation.z()); direction[4] = 1 - 2 * (orientation.x() * orientation.x() + orientation.z() * orientation.z()); direction[5] = 2 * (orientation.w() * orientation.x() + orientation.y() * orientation.z()); alListenerfv(AL_ORIENTATION, direction); m_orientation = orientation; }
void OpenALRenderableListener::updateImpl(int flags) throw(Exception) { if (flags & UPDATE_LOCATION) { const Vector3 pos(getListener()->getPosition()); // no option but to cast it down to float :( const Vector3 vel(getListener()->getVelocity()); const Vector3 at (getListener()->getAtDirection()); const Vector3 up (getListener()->getUpDirection()); ALfloat ori[] = { at.x, at.y, at.z, up.x, up.y, up.z }; alListener3f(AL_POSITION, pos.x, pos.y, pos.z); alListener3f(AL_VELOCITY, vel.x, vel.y, vel.z); alListenerfv(AL_ORIENTATION, ori); } if (flags & UPDATE_ATTRIBUTES) { alListenerf (AL_GAIN, getListener()->getGain()); } }
void Context::setListenerRotation(const quat& newRotation) { if (listenerRotation != newRotation) { listenerRotation = newRotation; const vec3 at = newRotation * vec3(0.f, 0.f, -1.f); const vec3 up = newRotation * vec3(0.f, 1.f, 0.f); const float orientation[] = { at.x, at.y, at.z, up.x, up.y, up.z }; alListenerfv(AL_ORIENTATION, orientation); #if WENDY_DEBUG checkAL("Failed to set listener rotation"); #endif } }
static void init( const ALbyte *fname ) { ALfloat weirdpos[] = { 300.0f, 0.0f, 0.0f }; ALfloat position[] = { 0.0f, 0.0f, 4.0f }; ALuint boom; alListenerfv( AL_POSITION, weirdpos ); boom = CreateBufferFromFile( fname ); alGenSources( 1, &movingSource ); alSourcei( movingSource, AL_BUFFER, boom ); alSourcei( movingSource, AL_LOOPING, AL_TRUE ); alSourcei( movingSource, AL_SOURCE_RELATIVE, AL_TRUE ); alSourcefv( movingSource, AL_POSITION, position ); alSourcef( movingSource, AL_PITCH, 1.00 ); }
AL_API void AL_APIENTRY alListeneriv(ALenum param, const ALint *values) { ALCcontext *context; if(values) { ALfloat fvals[6]; switch(param) { case AL_POSITION: case AL_VELOCITY: alListener3f(param, (ALfloat)values[0], (ALfloat)values[1], (ALfloat)values[2]); return; case AL_ORIENTATION: fvals[0] = (ALfloat)values[0]; fvals[1] = (ALfloat)values[1]; fvals[2] = (ALfloat)values[2]; fvals[3] = (ALfloat)values[3]; fvals[4] = (ALfloat)values[4]; fvals[5] = (ALfloat)values[5]; alListenerfv(param, fvals); return; } } context = GetContextRef(); if(!context) return; WriteLock(&context->PropLock); if(!(values)) SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done); switch(param) { default: SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done); } if(!ATOMIC_LOAD(&context->DeferUpdates, almemory_order_acquire)) UpdateListenerProps(context); done: WriteUnlock(&context->PropLock); ALCcontext_DecRef(context); }
AL_API void AL_APIENTRY alListeneriv( ALenum eParam, const ALint* plValues ) { ALCcontext *Context; ALfloat flValues[6]; if(plValues) { switch(eParam) { case AL_POSITION: case AL_VELOCITY: alListener3f(eParam, (ALfloat)plValues[0], (ALfloat)plValues[1], (ALfloat)plValues[2]); return; case AL_ORIENTATION: flValues[0] = (ALfloat)plValues[0]; flValues[1] = (ALfloat)plValues[1]; flValues[2] = (ALfloat)plValues[2]; flValues[3] = (ALfloat)plValues[3]; flValues[4] = (ALfloat)plValues[4]; flValues[5] = (ALfloat)plValues[5]; alListenerfv(eParam, flValues); return; } } Context = GetContextRef(); if(!Context) return; if(plValues) { switch(eParam) { default: alSetError(Context, AL_INVALID_ENUM); break; } } else alSetError(Context, AL_INVALID_VALUE); ALCcontext_DecRef(Context); }
void SoundListener::updateListener() { update(); if(mParentNode) { mPosition = mLastParentPosition; mDirection = mLastParentOrientation.zAxis(); mUp = mLastParentOrientation.yAxis(); } alListener3f(AL_POSITION, mPosition.x, mPosition.y, mPosition.z); mOrientation[0]= -mDirection.x; // Forward.x mOrientation[1]= -mDirection.y; // Forward.y mOrientation[2]= -mDirection.z; // Forward.z mOrientation[3]= mUp.x; // Up.x mOrientation[4]= mUp.y; // Up.y mOrientation[5]= mUp.z; // Up.z alListenerfv(AL_ORIENTATION, mOrientation); }
AL_API void AL_APIENTRY alListeneriv(ALenum param, const ALint *values) { ALCcontext *Context; if(values) { ALfloat fvals[6]; switch(param) { case AL_POSITION: case AL_VELOCITY: alListener3f(param, (ALfloat)values[0], (ALfloat)values[1], (ALfloat)values[2]); return; case AL_ORIENTATION: fvals[0] = (ALfloat)values[0]; fvals[1] = (ALfloat)values[1]; fvals[2] = (ALfloat)values[2]; fvals[3] = (ALfloat)values[3]; fvals[4] = (ALfloat)values[4]; fvals[5] = (ALfloat)values[5]; alListenerfv(param, fvals); return; } } Context = GetContextRef(); if(!Context) return; al_try { CHECK_VALUE(Context, values); switch(param) { default: al_throwerr(Context, AL_INVALID_ENUM); } } al_endtry; ALCcontext_DecRef(Context); }
void System::HandleEvents(const frame_tp& timepoint) { auto transformfut = TransformMap::GetAsyncUpdatedTransforms().GetFuture(timepoint); if (transformfut.valid()) { // wait for the list to be published auto transformmap = transformfut.get(); // assume this is the camera entity id if(transformmap->count(0)) { auto data = transformmap->at(0); const glm::vec3& position = data->GetTranslation(); alListener3f(AL_POSITION, position.x, position.y, position.z); const glm::vec3& up = data->GetOrientation() * UP_VECTOR; const glm::vec3& at = data->GetOrientation() * FORWARD_VECTOR; ALfloat orientation[] = {at.x, at.y, at.z, up.x, up.y, up.z}; alListenerfv(AL_ORIENTATION, orientation); } } else { std::cerr << "Sound system missed the updated transform map publication" << std::endl; } }
void SoundListener::updateListener() { Ogre::Vector3 position = this->getPosition().Meter() ; alListener3f(AL_POSITION, (float)position.x, (float)position.y, (float)position.z); Ogre::Quaternion orientation = this->getOrientation().getQuaternion(); ALfloat openal_orientation[6] ; openal_orientation[0] = orientation.zAxis().x ; openal_orientation[1] = orientation.zAxis().y ; openal_orientation[2] = orientation.zAxis().z ; openal_orientation[3] = orientation.yAxis().x ; openal_orientation[4] = orientation.yAxis().y ; openal_orientation[5] = orientation.yAxis().z ; alListenerfv(AL_ORIENTATION, openal_orientation) ; Ogre::Vector3 speed = this->getSpeed().MeterPerSecond(); alListener3f(AL_VELOCITY, (float)speed.x, (float)speed.y, (float)speed.z) ; alListenerf(AL_GAIN,getGain()) ; }
void lime_al_listenerfv (int param, value values) { if (val_is_null (values) == false) { int size = val_array_size (values); ALfloat *data = new ALfloat[size]; for (int i = 0; i < size; ++i) { data[i] = (ALfloat)val_float( val_array_i (values, i) ); } alListenerfv(param, data); delete[] data; } }
static void iterate( void ) { ALfloat orientation[] = { 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f }; static ALint angle = 0; /* * rotate at vector about up vector by angle degrees. */ _alRotatePointAboutAxis(TORAD(angle), orientation, &orientation[3]); angle += 15; /* increment fifeteen degrees degree */ fprintf(stderr, "orientation: \n\tAT(%f %f %f)\n\tUP(%f %f %f)\n", orientation[0], orientation[1], orientation[2], orientation[3], orientation[4], orientation[5]); alListenerfv(AL_ORIENTATION, orientation); micro_sleep(1500000); }
void CAListener::SetOrient( const TVec &roOrient, const TVec &roUp ) const { #ifdef A_USE_OAL_DUMMY #else ALint iError; alGetError(); // http://www.gamedev.net/community/forums/topic.asp?topic_id=389321 const ALfloat afOri[] = { roOrient[0], roOrient[1], roOrient[2], roUp[0], roUp[1], roUp[2] }; alListenerfv( AL_ORIENTATION, afOri ); if( ( iError = alGetError() ) != AL_NO_ERROR ) { A_ERR( "alListenerfv ORIENTATION (%s)\n", GetALErrorString_( iError ) ); return; } #endif // A_USE_OAL_DUMMY }
int is::Audio::init() { // Grab available devices and print them. int deviceCount; const char** deviceNames = alureGetDeviceNames( true, &deviceCount ); if ( !deviceCount ) { os->printf( "ERR OpenAL failed to find any usable devices for audio playback!\n" ); alureFreeDeviceNames( deviceNames ); audio->checkErrorSimple(); return 1; } os->printf( "INF OpenAL detected the following devices for audio:\n" ); for ( int i=0; i<deviceCount; i++ ) { os->printf( "INF %.\n", deviceNames[i] ); } // Attempt to use any device starting from the first. int i = 0; while ( alureInitDevice( deviceNames[i], NULL ) == AL_FALSE && i < deviceCount ) { audio->checkErrorSimple(); i++; } if ( i == deviceCount ) { os->printf( "ERR OpenAL failed to find any usable devices for audio playback!\n" ); alureFreeDeviceNames( deviceNames ); return 1; } os->printf( "INF OpenAL: Using %.\n", deviceNames[i] ); alureFreeDeviceNames( deviceNames ); // Initialize the listener alListener3f( AL_POSITION, 0.f, 0.f, 0.f ); alListener3f( AL_VELOCITY, 0.f, 0.f, 0.f ); float ori[6] = { 0, 0, -1, 0, 1, 0 }; alListenerfv( AL_ORIENTATION, ori ); audio->checkErrorSimple(); lua->doFolder( "data/sounds" ); return 0; }
void CSound::UpdateListenerReal() { // call from sound thread, cause OpenAL calls tend to cause L2 misses and so are slow (no reason to call them from mainthread) if (!listenerNeedsUpdate) return; // not 100% threadsafe, but worst case we would skip a single listener update (and it runs at multiple Hz!) listenerNeedsUpdate = false; const float3 myPosInMeters = myPos * ELMOS_TO_METERS; alListener3f(AL_POSITION, myPosInMeters.x, myPosInMeters.y, myPosInMeters.z); // reduce the rolloff when the camera is high above the ground (so we still hear something in tab mode or far zoom) // for altitudes up to and including 600 elmos, the rolloff is always clamped to 1 const float camHeight = std::max(1.0f, myPos.y - CGround::GetHeightAboveWater(myPos.x, myPos.z)); const float newMod = std::min(600.0f / camHeight, 1.0f); CSoundSource::SetHeightRolloffModifer(newMod); efx->SetHeightRolloffModifer(newMod); // Result were bad with listener related doppler effects. // The user experiences the camera/listener not as a world-interacting object. // So changing sounds on camera movements were irritating, esp. because zooming with the mouse wheel // often is faster than the speed of sound, causing very high frequencies. // Note: soundsource related doppler effects are not deactivated by this! Flying cannon shoots still change their frequencies. // Note2: by not updating the listener velocity soundsource related velocities are calculated wrong, // so even if the camera is moving with a cannon shoot the frequency gets changed. /* const float3 velocity = (myPos - prevPos) / (lastFrameTime); float3 velocityAvg = velocity * 0.6f + prevVelocity * 0.4f; prevVelocity = velocityAvg; velocityAvg *= ELMOS_TO_METERS; velocityAvg.y *= 0.001f; //! scale vertical axis separatly (zoom with mousewheel is faster than speed of sound!) velocityAvg *= 0.15f; alListener3f(AL_VELOCITY, velocityAvg.x, velocityAvg.y, velocityAvg.z); */ ALfloat ListenerOri[] = {camDir.x, camDir.y, camDir.z, camUp.x, camUp.y, camUp.z}; alListenerfv(AL_ORIENTATION, ListenerOri); CheckError("CSound::UpdateListener"); }