/*************************************************************************** * Copyright (C) 2005-2019 by the FIFE team * * http://www.fifengine.net * * This file is part of FIFE. * * * * FIFE is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This library is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the * * Free Software Foundation, Inc., * * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * ***************************************************************************/ // Standard C++ library includes #include // Platform specific includes // 3rd party library includes // FIFE includes // These includes are split up in two parts, separated by one empty line // First block: files included from the FIFE root src directory // Second block: files included from the same folder #include "util/log/logger.h" #include "util/base/exception.h" #include "util/time/timemanager.h" #include "soundemitter.h" #include "soundmanager.h" #include "soundclipmanager.h" namespace FIFE { static Logger _log(LM_AUDIO); SoundEmitter::SoundEmitter(SoundManager* manager, uint32_t uid) : m_manager(manager), m_source(0), m_directFilter(NULL), m_soundClip(), m_soundClipId(0), m_streamId(0), m_emitterId(uid), m_group(""), m_samplesOffset(0), m_active(false), m_fadeIn(false), m_fadeOut(false), m_origGain(0.0f), m_fadeInStartTimestamp(0), m_fadeInEndTimestamp(0), m_fadeOutStartTimestamp(0), m_fadeOutEndTimestamp(0), m_playCheckDifference(0) { if (!m_manager->isActive()) { return; } resetInternData(); } SoundEmitter::~SoundEmitter() { if (!m_manager->isActive()) { return; } reset(); } void SoundEmitter::setSource(ALuint source) { if (!source && m_source) { alSourceStop(m_source); // Release all buffers alSourcei(m_source, AL_BUFFER, AL_NONE); alGetError(); deactivateEffects(); } m_source = source; if (m_source > 0) { m_active = true; activateEffects(); syncData(); } else { m_active = false; } } ALuint SoundEmitter::getSource() const { return m_source; } bool SoundEmitter::isActive() const { return m_active; } void SoundEmitter::update() { if (!m_soundClip || m_internData.soundState == SD_STOPPED_STATE) { return; } if (m_fadeIn || m_fadeOut) { checkFade(); } // non streaming if (!m_soundClip->isStream()) { if (getState() == SD_STOPPED_STATE) { stop(); } return; } ALint procs; ALint bufs; ALuint buffer; alGetSourcei(m_source, AL_BUFFERS_PROCESSED, &procs); while (procs--) { // needed for correct cursor position float samplesOffset, newOffset; alGetSourcef(m_source, AL_SAMPLE_OFFSET, &samplesOffset); alSourceUnqueueBuffers(m_source, 1, &buffer); alGetSourcef(m_source, AL_SAMPLE_OFFSET, &newOffset); m_samplesOffset += (samplesOffset - newOffset); if (m_soundClip->getStream(m_streamId, buffer)) { // EOF! if (m_internData.loop) { // play again from the beginning m_soundClip->setStreamPos(m_streamId, SD_BYTE_POS, 0); m_soundClip->getStream(m_streamId, buffer); } else { // check if the playback has been finished alGetSourcei(m_source, AL_BUFFERS_QUEUED, &bufs); if (bufs == 0) { stop(); } continue; } } alSourceQueueBuffers(m_source, 1, &buffer); } CHECK_OPENAL_LOG(_log, LogManager::LEVEL_ERROR, "error while streaming") } uint32_t SoundEmitter::getId() const { return m_emitterId; } void SoundEmitter::setRelativePositioning(bool relative) { if (isActive()) { alSourcei(m_source, AL_SOURCE_RELATIVE, relative ? AL_TRUE : AL_FALSE); } m_internData.relative = relative; } bool SoundEmitter::isRelativePositioning() const { return m_internData.relative; } void SoundEmitter::setDirection(const AudioSpaceCoordinate& direction) { if (isActive()) { ALfloat vec[3] = { static_cast(direction.x), static_cast(direction.y), static_cast(direction.z) }; alSourcefv(m_source, AL_DIRECTION, vec); } m_internData.direction = direction; } AudioSpaceCoordinate SoundEmitter::getDirection() const { return m_internData.direction; } void SoundEmitter::setPitch(float pitch) { if (pitch > 0.0) { if (isActive()) { alSourcef(m_source, AL_PITCH, pitch); } m_internData.pitch = pitch; } } float SoundEmitter::getPitch() const { return m_internData.pitch; } void SoundEmitter::setRolloff(float rolloff) { if (isActive()) { alSourcef(m_source, AL_ROLLOFF_FACTOR, rolloff); } m_internData.rolloff = rolloff; } float SoundEmitter::getRolloff() const { return m_internData.rolloff; } void SoundEmitter::reset(bool defaultall) { // remove effects and filter if (m_directFilter) { m_manager->deactivateFilter(m_directFilter, this); } std::vectoreffects = m_effects; for (std::vector::iterator it = effects.begin(); it != effects.end(); ++it) { if (*it) { m_manager->removeEmitterFromSoundEffect(*it, this); } } // release buffer and source handle if (isActive()) { alSourceStop(m_source); alSourcei(m_source, AL_BUFFER, AL_NONE); alGetError(); m_manager->releaseSource(this); } // reset clip if (m_soundClip) { if (m_soundClip->isStream()) { m_soundClip->quitStreaming(m_streamId); m_streamId = 0; } m_soundClipId = 0; // release the soundClip //SoundClipManager::instance()->free(m_soundClipId); m_soundClip.reset(); } // default source properties if (defaultall) { resetInternData(); if (isActive()) { syncData(); } } if (m_group != "") { m_manager->removeFromGroup(this); m_group = ""; } m_samplesOffset = 0; m_fadeIn = false; m_fadeOut = false; m_origGain = 0; } void SoundEmitter::release() { m_manager->releaseEmitter(m_emitterId); } void SoundEmitter::setSoundClip(SoundClipPtr soundClip) { // equal clip if (m_soundClipId == soundClip->getHandle()) { return; } detachSoundClip(); m_soundClipId = soundClip->getHandle(); m_soundClip = soundClip; attachSoundClip(); } SoundClipPtr SoundEmitter::getSoundClip() { return m_soundClip; } void SoundEmitter::setSoundClip(const std::string& name) { SoundClipPtr clip = SoundClipManager::instance()->get(name); setSoundClip(clip); } void SoundEmitter::attachSoundClip() { if (!m_soundClip->isStream()) { if (!isActive()) { return; } // non-streaming alSourceQueueBuffers(m_source, m_soundClip->countBuffers(), m_soundClip->getBuffers()); alSourcei(m_source, AL_LOOPING, m_internData.loop ? AL_TRUE : AL_FALSE); } else { // streaming m_streamId = m_soundClip->beginStreaming(); m_soundClip->acquireStream(m_streamId); if (!isActive()) { return; } // queue initial buffers alSourceQueueBuffers(m_source, BUFFER_NUM, m_soundClip->getBuffers(m_streamId)); alSourcei(m_source, AL_LOOPING, AL_FALSE); } CHECK_OPENAL_LOG(_log, LogManager::LEVEL_ERROR, "error attaching sound clip") } void SoundEmitter::detachSoundClip() { if (!m_soundClip) { return; } SoundStateType state = getState(); if (state == SD_PLAYING_STATE || state == SD_PAUSED_STATE) { stop(); } if (isActive()) { // detach all buffers alSourcei(m_source, AL_BUFFER, AL_NONE); CHECK_OPENAL_LOG(_log, LogManager::LEVEL_ERROR, "error detaching sound clip"); } if (m_soundClip->isStream()) { m_soundClip->quitStreaming(m_streamId); m_streamId = 0; } m_soundClipId = 0; m_soundClip.reset(); } void SoundEmitter::setLooping(bool loop) { if (m_soundClip && isActive()) { if (!m_soundClip->isStream()) { alSourcei(m_source, AL_LOOPING, loop ? AL_TRUE : AL_FALSE); } else { alSourcei(m_source, AL_LOOPING, AL_FALSE); } } m_internData.loop = loop; } bool SoundEmitter::isLooping() const { return m_internData.loop; } void SoundEmitter::play() { if (m_soundClip && isActive()) { alSourcePlay(m_source); } m_internData.playTimestamp = TimeManager::instance()->getTime(); m_playCheckDifference = 0; // resume if (m_internData.soundState == SD_PAUSED_STATE) { m_internData.playTimestamp -= static_cast(getCursor(SD_TIME_POS) * 1000); } m_internData.soundState = SD_PLAYING_STATE; } void SoundEmitter::play(float inTime, float outTime) { float zero = 0; m_origGain = m_internData.volume; if (!Mathf::Equal(zero, inTime)) { m_fadeIn = true; setGain(0.0f); play(); m_fadeInStartTimestamp = m_internData.playTimestamp; m_fadeInEndTimestamp = m_fadeInStartTimestamp + static_cast(inTime * 1000.0f); } if (getState() != SD_PLAYING_STATE) { play(); } if (!Mathf::Equal(zero, outTime)) { m_fadeOut = true; setGain(0.0f); m_fadeOutEndTimestamp = m_internData.playTimestamp + getDuration(); m_fadeOutStartTimestamp = m_fadeOutEndTimestamp - static_cast(outTime * 1000.0f); } } void SoundEmitter::stop() { if (m_soundClip && isActive()) { alSourceStop(m_source); rewind(); } m_internData.soundState = SD_STOPPED_STATE; m_internData.playTimestamp = 0; callOnSoundFinished(); } void SoundEmitter::stop(float time) { m_fadeOut = true; m_origGain = m_internData.volume; m_fadeOutStartTimestamp = TimeManager::instance()->getTime(); m_fadeOutEndTimestamp = m_fadeOutStartTimestamp + static_cast(time * 1000.0f); } void SoundEmitter::pause() { if (m_soundClip && isActive()) { alSourcePause(m_source); } m_internData.soundState = SD_PAUSED_STATE; } void SoundEmitter::rewind() { m_internData.playTimestamp = 0; m_samplesOffset = 0; if (!isActive() || !m_soundClip) { return; } if (m_soundClip->isStream()) { setCursor(SD_BYTE_POS, 0); } else { alSourceRewind(m_source); } } void SoundEmitter::setGain(float gain) { if (isActive()) { alSourcef(m_source, AL_GAIN, gain); } m_internData.volume = gain; } float SoundEmitter::getGain() const { return m_internData.volume; } void SoundEmitter::setMaxGain(float gain) { if (isActive()) { alSourcef(m_source, AL_MAX_GAIN, gain); } m_internData.maxVolume = gain; } float SoundEmitter::getMaxGain() const { return m_internData.maxVolume; } void SoundEmitter::setMinGain(float gain) { if (isActive()) { alSourcef(m_source, AL_MIN_GAIN, gain); } m_internData.minVolume = gain; } float SoundEmitter::getMinGain() const { return m_internData.minVolume; } bool SoundEmitter::isStereo() { if (m_soundClip) { return m_soundClip->getDecoder()->isStereo(); } return false; } int16_t SoundEmitter::getBitResolution() { if (m_soundClip) { return m_soundClip->getDecoder()->getBitResolution(); } return 0; } uint64_t SoundEmitter::getSampleRate() { if (m_soundClip) { return m_soundClip->getDecoder()->getSampleRate(); } return 0; } uint64_t SoundEmitter::getDecodedLength() { if (m_soundClip) { return m_soundClip->getDecoder()->getDecodedLength(); } return 0; } uint64_t SoundEmitter::getDuration() { if (m_soundClip) { //convert to milliseconds double samplerate = static_cast(getSampleRate()) / 1000.0; double bitres = static_cast(getBitResolution()); // convert to bits double size = static_cast(getDecodedLength()) * 8.0; double stereo = (isStereo() ? 2.0 : 1.0); double time = ( size / (samplerate * bitres) ) / stereo; return static_cast(time); } return 0; } uint32_t SoundEmitter::getPlayTimestamp() { return m_internData.playTimestamp; } bool SoundEmitter::isFinished() { if (isLooping()) { return false; } if (isActive()) { return getState() == SD_STOPPED_STATE; } if (getState() == SD_STOPPED_STATE) { return true; } // roughly check, in the case the clip do not plays (is not active) return (m_internData.playTimestamp + m_playCheckDifference + static_cast(getDuration())) <= TimeManager::instance()->getTime(); } void SoundEmitter::setCursor(SoundPositionType type, float value) { if (!m_soundClip || !isActive()) { return; } ALint state = 0; if (!m_soundClip->isStream()) { switch(type) { case SD_BYTE_POS: alSourcef(m_source, AL_BYTE_OFFSET, value); break; case SD_SAMPLE_POS: alSourcef(m_source, AL_SAMPLE_OFFSET, value); break; case SD_TIME_POS: alSourcef(m_source, AL_SEC_OFFSET, value); break; } CHECK_OPENAL_LOG(_log, LogManager::LEVEL_ERROR, "error setting cursor position") } else { switch (type) { case SD_BYTE_POS: m_samplesOffset = value / (getBitResolution() / 8 * (isStereo() ? 2 : 1)); break; case SD_SAMPLE_POS: m_samplesOffset = value; break; case SD_TIME_POS: m_samplesOffset = value * getSampleRate(); break; } alGetSourcei(m_source, AL_SOURCE_STATE, &state); if (state == AL_PLAYING || state == AL_PAUSED) { alSourceStop(m_source); } m_soundClip->setStreamPos(m_streamId, type, value); // detach all buffers alSourcei(m_source, AL_BUFFER, 0); // queue the buffers with new data m_soundClip->acquireStream(m_streamId); alSourceQueueBuffers(m_source, BUFFER_NUM, m_soundClip->getBuffers(m_streamId)); if (state == AL_PLAYING) { alSourcePlay(m_source); } CHECK_OPENAL_LOG(_log, LogManager::LEVEL_ERROR, "error setting stream cursor position") } } float SoundEmitter::getCursor(SoundPositionType type) { if (!m_soundClip || !isActive()) { return 0.0f; } ALfloat pos = 0.0f; switch(type) { case SD_BYTE_POS: alGetSourcef(m_source, AL_BYTE_OFFSET, &pos); break; case SD_SAMPLE_POS: alGetSourcef(m_source, AL_SAMPLE_OFFSET, &pos); break; case SD_TIME_POS: alGetSourcef(m_source, AL_SEC_OFFSET, &pos); break; } if (m_soundClip->isStream()) { switch (type) { case SD_BYTE_POS: pos += m_samplesOffset * (getBitResolution() / 8 * (isStereo() ? 2 : 1)); break; case SD_SAMPLE_POS: pos += m_samplesOffset; break; case SD_TIME_POS: pos += m_samplesOffset / getSampleRate(); break; } } CHECK_OPENAL_LOG(_log, LogManager::LEVEL_ERROR, "error getting cursor") return pos; } void SoundEmitter::setPosition(const AudioSpaceCoordinate& position) { if (isActive()) { alSource3f(m_source, AL_POSITION, static_cast(position.x), static_cast(position.y), static_cast(position.z)); } m_internData.position = position; } AudioSpaceCoordinate SoundEmitter::getPosition() const { return m_internData.position; } bool SoundEmitter::isPosition() const { double zero = 0; return !(Mathd::Equal(zero, m_internData.position.x) && Mathd::Equal(zero, m_internData.position.y) && Mathd::Equal(zero, m_internData.position.z)); } void SoundEmitter::setReferenceDistance(float distance) { if (isActive()) { alSourcef(m_source, AL_REFERENCE_DISTANCE, distance); } m_internData.refDistance = distance; } float SoundEmitter::getReferenceDistance() const { return m_internData.refDistance; } void SoundEmitter::setMaxDistance(float distance) { if (isActive()) { alSourcef(m_source, AL_MAX_DISTANCE, distance); } m_internData.maxDistance = distance; } float SoundEmitter::getMaxDistance() const { return m_internData.maxDistance; } void SoundEmitter::setVelocity(const AudioSpaceCoordinate& velocity) { if (isActive()) { alSource3f(m_source, AL_VELOCITY, static_cast(velocity.x), static_cast(velocity.y), static_cast(velocity.z)); } m_internData.velocity = velocity; } AudioSpaceCoordinate SoundEmitter::getVelocity() const { return m_internData.velocity; } void SoundEmitter::setConeInnerAngle(float inner) { if (isActive()) { alSourcef(m_source, AL_CONE_INNER_ANGLE, inner); } m_internData.coneInnerAngle = inner; } float SoundEmitter::getConeInnerAngle() const { return m_internData.coneInnerAngle; } void SoundEmitter::setConeOuterAngle(float outer) { if (isActive()) { alSourcef(m_source, AL_CONE_OUTER_ANGLE, outer); } m_internData.coneOuterAngle = outer; } float SoundEmitter::getConeOuterAngle() const { return m_internData.coneOuterAngle; } void SoundEmitter::setConeOuterGain(float gain) { if (isActive()) { alSourcef(m_source, AL_CONE_OUTER_GAIN, gain); } m_internData.coneOuterGain = gain; } float SoundEmitter::getConeOuterGain() const { return m_internData.coneOuterGain; } SoundStateType SoundEmitter::getState() { if (!isActive()) { return m_internData.soundState; } ALint state; alGetSourcei(m_source, AL_SOURCE_STATE, &state); switch(state) { case AL_INITIAL: return SD_INITIAL_STATE; break; case AL_PLAYING: return SD_PLAYING_STATE; break; case AL_PAUSED: return SD_PAUSED_STATE; break; case AL_STOPPED: return SD_STOPPED_STATE; break; default: return SD_UNKNOWN_STATE; break; } } void SoundEmitter::setGroup(const std::string& group) { if (group != m_group) { if (m_group != "") { m_manager->removeFromGroup(this); } m_group = group; if (m_group != "") { m_manager->addToGroup(this); } } } const std::string& SoundEmitter::getGroup() { return m_group; } void SoundEmitter::syncData() { setGain(m_internData.volume); setMaxGain(m_internData.maxVolume); setMinGain(m_internData.minVolume); setReferenceDistance(m_internData.refDistance); setMaxDistance(m_internData.maxDistance); setRolloff(m_internData.rolloff); setPitch(m_internData.pitch); setConeInnerAngle(m_internData.coneInnerAngle); setConeOuterAngle(m_internData.coneOuterAngle); setConeOuterGain(m_internData.coneOuterGain); setPosition(m_internData.position); setDirection(m_internData.direction); setVelocity(m_internData.velocity); setLooping(m_internData.loop); setRelativePositioning(m_internData.relative); if (m_internData.soundState == SD_PLAYING_STATE) { uint32_t timediff = TimeManager::instance()->getTime() - m_internData.playTimestamp - m_playCheckDifference; if (m_internData.loop) { timediff = timediff % getDuration(); } float time = static_cast(timediff) / 1000.0f; attachSoundClip(); setCursor(SD_TIME_POS, time); if (m_soundClip && isActive()) { m_internData.playTimestamp = TimeManager::instance()->getTime() - timediff; alSourcePlay(m_source); } } } void SoundEmitter::resetInternData() { m_internData.volume = 1.0; m_internData.maxVolume = 1.0; m_internData.minVolume = 0.0; m_internData.refDistance = 1.0; m_internData.maxDistance = 1000000.0; m_internData.rolloff = 1.0; m_internData.pitch = 1.0; m_internData.coneInnerAngle = 360.0; m_internData.coneOuterAngle = 360.0; m_internData.coneOuterGain = 0.0; m_internData.position = AudioSpaceCoordinate(0.0, 0.0, 0.0); m_internData.direction = AudioSpaceCoordinate(0.0, 0.0, 0.0); m_internData.velocity = AudioSpaceCoordinate(0.0, 0.0, 0.0); m_internData.playTimestamp = 0; m_internData.soundState = SD_UNKNOWN_STATE; m_internData.loop = false; m_internData.relative = false; } void SoundEmitter::checkFade() { uint32_t timestamp = TimeManager::instance()->getTime(); if (m_fadeIn) { float delta = m_origGain / static_cast(m_fadeInEndTimestamp - m_fadeInStartTimestamp); if (timestamp >= m_fadeInEndTimestamp) { m_fadeIn = false; setGain(m_origGain); } else { float gain = delta * static_cast(timestamp - m_fadeInStartTimestamp); gain = std::min(gain, m_origGain); setGain(gain); } } else if (m_fadeOut) { float delta = m_origGain / static_cast(m_fadeOutEndTimestamp - m_fadeOutStartTimestamp); if (timestamp >= m_fadeOutEndTimestamp) { m_fadeOut = false; stop(); setGain(m_origGain); } else { float gain = delta * static_cast(m_fadeOutEndTimestamp - timestamp); gain = std::max(gain, 0.0f); setGain(gain); } } } void SoundEmitter::addEffect(SoundEffect* effect) { bool added = false; for (std::vector::iterator it = m_effects.begin(); it != m_effects.end(); ++it) { if (!(*it)) { (*it) = effect; added = true; break; } } if (!added) { m_effects.push_back(effect); } } void SoundEmitter::removeEffect(SoundEffect* effect) { for (std::vector::iterator it = m_effects.begin(); it != m_effects.end(); ++it) { if (effect == *it) { (*it) = NULL; break; } } } uint8_t SoundEmitter::getEffectCount() { uint8_t counter = 0; for (std::vector::iterator it = m_effects.begin(); it != m_effects.end(); ++it) { if (*it) { ++counter; } } return counter; } uint8_t SoundEmitter::getEffectNumber(SoundEffect* effect) { uint8_t number = 0; for (std::vector::iterator it = m_effects.begin(); it != m_effects.end(); ++it) { if (effect == *it) { break; } ++number; } return number; } void SoundEmitter::setDirectFilter(SoundFilter* filter) { m_directFilter = filter; } SoundFilter* SoundEmitter::getDirectFilter() { return m_directFilter; } void SoundEmitter::activateEffects() { for (std::vector::iterator it = m_effects.begin(); it != m_effects.end(); ++it) { if (*it) { m_manager->activateEffect(*it, this); } } if (m_directFilter) { m_manager->activateFilter(m_directFilter, this); } } void SoundEmitter::deactivateEffects() { for (std::vector::iterator it = m_effects.begin(); it != m_effects.end(); ++it) { if (*it) { m_manager->deactivateEffect(*it, this); } } if (m_directFilter) { m_manager->deactivateFilter(m_directFilter, this); } } void SoundEmitter::setCheckDifference() { if (m_playCheckDifference == 0 && getState() == SD_PLAYING_STATE) { m_playCheckDifference = TimeManager::instance()->getTime() - m_internData.playTimestamp; } } void SoundEmitter::addListener(SoundEmitterListener* listener) { m_listeners.push_back(listener); } void SoundEmitter::removeListener(SoundEmitterListener* listener) { std::vector::iterator i = m_listeners.begin(); while (i != m_listeners.end()) { if ((*i) == listener) { *i = NULL; return; } ++i; } FL_WARN(_log, "Cannot remove unknown listener"); } void SoundEmitter::callOnSoundFinished() { std::vector::iterator i = m_listeners.begin(); for (; i != m_listeners.end(); ++i) { if (*i) { (*i)->onSoundFinished(m_emitterId, m_soundClipId); } } m_listeners.erase(std::remove(m_listeners.begin(), m_listeners.end(), (SoundEmitterListener*)NULL), m_listeners.end()); } }