mirror/openmw-tes3mp
1
0
Fork 1
mirror of https://github.com/TES3MP/openmw-tes3mp.git synced 2025-03-03 13:19:40 +00:00
Code Issues Releases Wiki Activity

Avoid inheriting from Sound for sound types

Browse source
This commit is contained in:
Chris Robinson 2015-11-30 05:42:51 -08:00
parent 77965501d4
commit 816015d6e6
10 changed files with 390 additions and 429 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
apps/openmw/mwbase/soundmanager.hpp
View file

@ -107,6 +107,14 @@ namespace MWBase
virtual SoundPtr playTrack(const MWSound::DecoderPtr& decoder, PlayType type) = 0; virtual SoundPtr playTrack(const MWSound::DecoderPtr& decoder, PlayType type) = 0;
///< Play a 2D audio track, using a custom decoder ///< Play a 2D audio track, using a custom decoder
virtual void stopTrack(SoundPtr sound) = 0;
///< Stop the given audio track from playing
virtual double getTrackTimeDelay(SoundPtr sound) = 0;
///< Retives the time delay, in seconds, of the audio track (must be a sound
/// returned by \ref playTrack). Only intended to be called by the track
/// decoder's read method.
virtual SoundPtr playSound(const std::string& soundId, float volume, float pitch, virtual SoundPtr playSound(const std::string& soundId, float volume, float pitch,
PlayType type=Play_TypeSfx, PlayMode mode=Play_Normal, PlayType type=Play_TypeSfx, PlayMode mode=Play_Normal,
float offset=0) = 0; float offset=0) = 0;
@ -123,6 +131,9 @@ namespace MWBase
float volume, float pitch, PlayType type=Play_TypeSfx, PlayMode mode=Play_Normal, float offset=0) = 0; float volume, float pitch, PlayType type=Play_TypeSfx, PlayMode mode=Play_Normal, float offset=0) = 0;
///< Play a 3D sound at \a initialPos. If the sound should be moving, it must be updated using Sound::setPosition. ///< Play a 3D sound at \a initialPos. If the sound should be moving, it must be updated using Sound::setPosition.
virtual void stopSound(SoundPtr sound) = 0;
///< Stop the given sound from playing
virtual void stopSound3D(const MWWorld::Ptr &reference, const std::string& soundId) = 0; virtual void stopSound3D(const MWWorld::Ptr &reference, const std::string& soundId) = 0;
///< Stop the given object from playing the given sound, ///< Stop the given object from playing the given sound,

4
apps/openmw/mwsound/movieaudiofactory.cpp
View file

@ -61,7 +61,7 @@ namespace MWSound
virtual double getAudioClock() virtual double getAudioClock()
{ {
return (double)getSampleOffset()/(double)mAVStream->codec->sample_rate - return (double)getSampleOffset()/(double)mAVStream->codec->sample_rate -
mAudioTrack->getStreamDelay(); MWBase::Environment::get().getSoundManager()->getTrackTimeDelay(mAudioTrack);
} }
virtual void adjustAudioSettings(AVSampleFormat& sampleFormat, uint64_t& channelLayout, int& sampleRate) virtual void adjustAudioSettings(AVSampleFormat& sampleFormat, uint64_t& channelLayout, int& sampleRate)
@ -86,6 +86,8 @@ namespace MWSound
public: public:
~MovieAudioDecoder() ~MovieAudioDecoder()
{ {
if(mAudioTrack.get())
MWBase::Environment::get().getSoundManager()->stopTrack(mAudioTrack);
mAudioTrack.reset(); mAudioTrack.reset();
mDecoderBridge.reset(); mDecoderBridge.reset();
} }

609
apps/openmw/mwsound/openal_output.cpp
View file

@ -157,17 +157,14 @@ static ALenum getALFormat(ChannelConfig chans, SampleType type)
// //
// A streaming OpenAL sound. // A streaming OpenAL sound.
// //
class OpenAL_SoundStream : public Sound class OpenAL_SoundStream
{ {
static const ALuint sNumBuffers = 6; static const ALuint sNumBuffers = 6;
static const ALfloat sBufferLength; static const ALfloat sBufferLength;
protected: private:
OpenAL_Output &mOutput;
ALuint mSource; ALuint mSource;
private:
ALuint mBuffers[sNumBuffers]; ALuint mBuffers[sNumBuffers];
ALint mCurrentBufIdx; ALint mCurrentBufIdx;
@ -189,34 +186,18 @@ private:
friend class OpenAL_Output; friend class OpenAL_Output;
public: public:
OpenAL_SoundStream(OpenAL_Output &output, ALuint src, DecoderPtr decoder, const osg::Vec3f& pos, float vol, float basevol, float pitch, float mindist, float maxdist, int flags); OpenAL_SoundStream(ALuint src, DecoderPtr decoder);
virtual ~OpenAL_SoundStream(); ~OpenAL_SoundStream();
virtual void stop(); bool isPlaying();
virtual bool isPlaying(); double getStreamDelay() const;
virtual double getTimeOffset(); double getStreamOffset() const;
virtual double getStreamDelay() const;
virtual void applyUpdates();
void play();
bool process(); bool process();
ALint refillQueue(); ALint refillQueue();
}; };
const ALfloat OpenAL_SoundStream::sBufferLength = 0.125f; const ALfloat OpenAL_SoundStream::sBufferLength = 0.125f;
class OpenAL_SoundStream3D : public OpenAL_SoundStream
{
OpenAL_SoundStream3D(const OpenAL_SoundStream3D &rhs);
OpenAL_SoundStream3D& operator=(const OpenAL_SoundStream3D &rhs);
public:
OpenAL_SoundStream3D(OpenAL_Output &output, ALuint src, DecoderPtr decoder, const osg::Vec3f& pos, float vol, float basevol, float pitch, float mindist, float maxdist, int flags)
: OpenAL_SoundStream(output, src, decoder, pos, vol, basevol, pitch, mindist, maxdist, flags)
{ }
virtual void applyUpdates();
};
// //
// A background streaming thread (keeps active streams processed) // A background streaming thread (keeps active streams processed)
@ -329,13 +310,9 @@ private:
}; };
OpenAL_SoundStream::OpenAL_SoundStream(OpenAL_Output &output, ALuint src, DecoderPtr decoder, const osg::Vec3f& pos, float vol, float basevol, float pitch, float mindist, float maxdist, int flags) OpenAL_SoundStream::OpenAL_SoundStream(ALuint src, DecoderPtr decoder)
: Sound(pos, vol, basevol, pitch, mindist, maxdist, flags) : mSource(src), mCurrentBufIdx(0), mFrameSize(0), mSilence(0), mDecoder(decoder), mIsFinished(false)
, mOutput(output), mSource(src), mCurrentBufIdx(0), mFrameSize(0), mSilence(0)
, mDecoder(decoder), mIsFinished(true)
{ {
throwALerror();
alGenBuffers(sNumBuffers, mBuffers); alGenBuffers(sNumBuffers, mBuffers);
throwALerror(); throwALerror();
try try
@ -358,8 +335,6 @@ OpenAL_SoundStream::OpenAL_SoundStream(OpenAL_Output &output, ALuint src, Decode
mFrameSize = framesToBytes(1, chans, type); mFrameSize = framesToBytes(1, chans, type);
mBufferSize = static_cast<ALuint>(sBufferLength*srate); mBufferSize = static_cast<ALuint>(sBufferLength*srate);
mBufferSize *= mFrameSize; mBufferSize *= mFrameSize;
mOutput.mActiveStreams.push_back(this);
} }
catch(std::exception&) catch(std::exception&)
{ {
@ -367,51 +342,20 @@ OpenAL_SoundStream::OpenAL_SoundStream(OpenAL_Output &output, ALuint src, Decode
alGetError(); alGetError();
throw; throw;
} }
mIsFinished = false;
} }
OpenAL_SoundStream::~OpenAL_SoundStream() OpenAL_SoundStream::~OpenAL_SoundStream()
{ {
mOutput.mStreamThread->remove(this);
alSourceStop(mSource);
alSourcei(mSource, AL_BUFFER, 0);
mOutput.mFreeSources.push_back(mSource);
alDeleteBuffers(sNumBuffers, mBuffers); alDeleteBuffers(sNumBuffers, mBuffers);
alGetError(); alGetError();
mDecoder->close(); mDecoder->close();
mOutput.mActiveStreams.erase(std::find(mOutput.mActiveStreams.begin(),
mOutput.mActiveStreams.end(), this));
}
void OpenAL_SoundStream::play()
{
alSourceStop(mSource);
alSourcei(mSource, AL_BUFFER, 0);
throwALerror();
mIsFinished = false;
mOutput.mStreamThread->add(this);
}
void OpenAL_SoundStream::stop()
{
mOutput.mStreamThread->remove(this);
mIsFinished = true;
alSourceStop(mSource);
alSourcei(mSource, AL_BUFFER, 0);
throwALerror();
mDecoder->rewind();
} }
bool OpenAL_SoundStream::isPlaying() bool OpenAL_SoundStream::isPlaying()
{ {
ALint state; ALint state;
boost::lock_guard<boost::mutex> lock(mOutput.mStreamThread->mMutex);
alGetSourcei(mSource, AL_SOURCE_STATE, &state); alGetSourcei(mSource, AL_SOURCE_STATE, &state);
throwALerror(); throwALerror();
@ -420,33 +364,6 @@ bool OpenAL_SoundStream::isPlaying()
return !mIsFinished; return !mIsFinished;
} }
double OpenAL_SoundStream::getTimeOffset()
{
ALint state = AL_STOPPED;
ALint offset;
double t;
boost::lock_guard<boost::mutex> lock(mOutput.mStreamThread->mMutex);
alGetSourcei(mSource, AL_SAMPLE_OFFSET, &offset);
alGetSourcei(mSource, AL_SOURCE_STATE, &state);
if(state == AL_PLAYING || state == AL_PAUSED)
{
ALint queued;
alGetSourcei(mSource, AL_BUFFERS_QUEUED, &queued);
ALint inqueue = mBufferSize/mFrameSize*queued - offset;
t = (double)(mDecoder->getSampleOffset() - inqueue) / (double)mSampleRate;
}
else
{
/* Underrun, or not started yet. The decoder offset is where we'll play
* next. */
t = (double)mDecoder->getSampleOffset() / (double)mSampleRate;
}
throwALerror();
return t;
}
double OpenAL_SoundStream::getStreamDelay() const double OpenAL_SoundStream::getStreamDelay() const
{ {
ALint state = AL_STOPPED; ALint state = AL_STOPPED;
@ -467,41 +384,30 @@ double OpenAL_SoundStream::getStreamDelay() const
return d; return d;
} }
void OpenAL_SoundStream::updateAll(bool local) double OpenAL_SoundStream::getStreamOffset() const
{ {
alSourcef(mSource, AL_REFERENCE_DISTANCE, mMinDistance); ALint state = AL_STOPPED;
alSourcef(mSource, AL_MAX_DISTANCE, mMaxDistance); ALint offset;
if(local) double t;
alGetSourcei(mSource, AL_SAMPLE_OFFSET, &offset);
alGetSourcei(mSource, AL_SOURCE_STATE, &state);
if(state == AL_PLAYING || state == AL_PAUSED)
{ {
alSourcef(mSource, AL_ROLLOFF_FACTOR, 0.0f); ALint queued;
alSourcei(mSource, AL_SOURCE_RELATIVE, AL_TRUE); alGetSourcei(mSource, AL_BUFFERS_QUEUED, &queued);
ALint inqueue = mBufferSize/mFrameSize*queued - offset;
t = (double)(mDecoder->getSampleOffset() - inqueue) / (double)mSampleRate;
} }
else else
{ {
alSourcef(mSource, AL_ROLLOFF_FACTOR, 1.0f); /* Underrun, or not started yet. The decoder offset is where we'll play
alSourcei(mSource, AL_SOURCE_RELATIVE, AL_FALSE); * next. */
} t = (double)mDecoder->getSampleOffset() / (double)mSampleRate;
alSourcei(mSource, AL_LOOPING, AL_FALSE);
applyUpdates();
}
void OpenAL_SoundStream::applyUpdates()
{
ALfloat gain = mVolume*mBaseVolume;
ALfloat pitch = mPitch;
if(!(mFlags&MWBase::SoundManager::Play_NoEnv) && mOutput.mLastEnvironment == Env_Underwater)
{
gain *= 0.9f;
pitch *= 0.7f;
} }
alSourcef(mSource, AL_GAIN, gain);
alSourcef(mSource, AL_PITCH, pitch);
alSource3f(mSource, AL_POSITION, mPos[0], mPos[1], mPos[2]);
alSource3f(mSource, AL_DIRECTION, 0.0f, 0.0f, 0.0f);
alSource3f(mSource, AL_VELOCITY, 0.0f, 0.0f, 0.0f);
throwALerror(); throwALerror();
return t;
} }
bool OpenAL_SoundStream::process() bool OpenAL_SoundStream::process()
@ -562,172 +468,6 @@ ALint OpenAL_SoundStream::refillQueue()
return queued; return queued;
} }
void OpenAL_SoundStream3D::applyUpdates()
{
ALfloat gain = mVolume*mBaseVolume;
ALfloat pitch = mPitch;
if((mPos - mOutput.mPos).length2() > mMaxDistance*mMaxDistance)
gain = 0.0f;
else if(!(mFlags&MWBase::SoundManager::Play_NoEnv) && mOutput.mLastEnvironment == Env_Underwater)
{
gain *= 0.9f;
pitch *= 0.7f;
}
alSourcef(mSource, AL_GAIN, gain);
alSourcef(mSource, AL_PITCH, pitch);
alSource3f(mSource, AL_POSITION, mPos[0], mPos[1], mPos[2]);
alSource3f(mSource, AL_DIRECTION, 0.0f, 0.0f, 0.0f);
alSource3f(mSource, AL_VELOCITY, 0.0f, 0.0f, 0.0f);
throwALerror();
}
//
// A regular 2D OpenAL sound
//
class OpenAL_Sound : public Sound
{
protected:
OpenAL_Output &mOutput;
ALuint mSource;
friend class OpenAL_Output;
void updateAll(bool local);
private:
OpenAL_Sound(const OpenAL_Sound &rhs);
OpenAL_Sound& operator=(const OpenAL_Sound &rhs);
public:
OpenAL_Sound(OpenAL_Output &output, ALuint src, const osg::Vec3f& pos, float vol, float basevol, float pitch, float mindist, float maxdist, int flags);
virtual ~OpenAL_Sound();
virtual void stop();
virtual bool isPlaying();
virtual double getTimeOffset();
virtual void applyUpdates();
};
//
// A regular 3D OpenAL sound
//
class OpenAL_Sound3D : public OpenAL_Sound
{
OpenAL_Sound3D(const OpenAL_Sound &rhs);
OpenAL_Sound3D& operator=(const OpenAL_Sound &rhs);
public:
OpenAL_Sound3D(OpenAL_Output &output, ALuint src, const osg::Vec3f& pos, float vol, float basevol, float pitch, float mindist, float maxdist, int flags)
: OpenAL_Sound(output, src, pos, vol, basevol, pitch, mindist, maxdist, flags)
{ }
virtual void applyUpdates();
};
OpenAL_Sound::OpenAL_Sound(OpenAL_Output &output, ALuint src, const osg::Vec3f& pos, float vol, float basevol, float pitch, float mindist, float maxdist, int flags)
: Sound(pos, vol, basevol, pitch, mindist, maxdist, flags)
, mOutput(output), mSource(src)
{
mOutput.mActiveSounds.push_back(this);
}
OpenAL_Sound::~OpenAL_Sound()
{
alSourceStop(mSource);
alSourcei(mSource, AL_BUFFER, 0);
mOutput.mFreeSources.push_back(mSource);
mOutput.mActiveSounds.erase(std::find(mOutput.mActiveSounds.begin(),
mOutput.mActiveSounds.end(), this));
}
void OpenAL_Sound::stop()
{
alSourceStop(mSource);
throwALerror();
}
bool OpenAL_Sound::isPlaying()
{
ALint state;
alGetSourcei(mSource, AL_SOURCE_STATE, &state);
throwALerror();
return state==AL_PLAYING || state==AL_PAUSED;
}
double OpenAL_Sound::getTimeOffset()
{
ALfloat t;
alGetSourcef(mSource, AL_SEC_OFFSET, &t);
throwALerror();
return t;
}
void OpenAL_Sound::updateAll(bool local)
{
alSourcef(mSource, AL_REFERENCE_DISTANCE, mMinDistance);
alSourcef(mSource, AL_MAX_DISTANCE, mMaxDistance);
if(local)
{
alSourcef(mSource, AL_ROLLOFF_FACTOR, 0.0f);
alSourcei(mSource, AL_SOURCE_RELATIVE, AL_TRUE);
}
else
{
alSourcef(mSource, AL_ROLLOFF_FACTOR, 1.0f);
alSourcei(mSource, AL_SOURCE_RELATIVE, AL_FALSE);
}
alSourcei(mSource, AL_LOOPING, (mFlags&MWBase::SoundManager::Play_Loop) ? AL_TRUE : AL_FALSE);
applyUpdates();
}
void OpenAL_Sound::applyUpdates()
{
ALfloat gain = mVolume*mBaseVolume;
ALfloat pitch = mPitch;
if(!(mFlags&MWBase::SoundManager::Play_NoEnv) && mOutput.mLastEnvironment == Env_Underwater)
{
gain *= 0.9f;
pitch *= 0.7f;
}
alSourcef(mSource, AL_GAIN, gain);
alSourcef(mSource, AL_PITCH, pitch);
alSource3f(mSource, AL_POSITION, mPos[0], mPos[1], mPos[2]);
alSource3f(mSource, AL_DIRECTION, 0.0f, 0.0f, 0.0f);
alSource3f(mSource, AL_VELOCITY, 0.0f, 0.0f, 0.0f);
throwALerror();
}
void OpenAL_Sound3D::applyUpdates()
{
ALfloat gain = mVolume*mBaseVolume;
ALfloat pitch = mPitch;
if((mPos - mOutput.mPos).length2() > mMaxDistance*mMaxDistance)
gain = 0.0f;
else if(!(mFlags&MWBase::SoundManager::Play_NoEnv) && mOutput.mLastEnvironment == Env_Underwater)
{
gain *= 0.9f;
pitch *= 0.7f;
}
alSourcef(mSource, AL_GAIN, gain);
alSourcef(mSource, AL_PITCH, pitch);
alSource3f(mSource, AL_POSITION, mPos[0], mPos[1], mPos[2]);
alSource3f(mSource, AL_DIRECTION, 0.0f, 0.0f, 0.0f);
alSource3f(mSource, AL_VELOCITY, 0.0f, 0.0f, 0.0f);
throwALerror();
}
// //
// An OpenAL output device // An OpenAL output device
@ -881,15 +621,16 @@ void OpenAL_Output::unloadSound(Sound_Handle data)
SoundVec::const_iterator iter = mActiveSounds.begin(); SoundVec::const_iterator iter = mActiveSounds.begin();
for(;iter != mActiveSounds.end();++iter) for(;iter != mActiveSounds.end();++iter)
{ {
if(!(*iter)->mSource) if(!(*iter)->mHandle)
continue; continue;
ALuint source = GET_PTRID((*iter)->mHandle);
ALint srcbuf; ALint srcbuf;
alGetSourcei((*iter)->mSource, AL_BUFFER, &srcbuf); alGetSourcei(source, AL_BUFFER, &srcbuf);
if((ALuint)srcbuf == buffer) if((ALuint)srcbuf == buffer)
{ {
alSourceStop((*iter)->mSource); alSourceStop(source);
alSourcei((*iter)->mSource, AL_BUFFER, 0); alSourcei(source, AL_BUFFER, 0);
} }
} }
alDeleteBuffers(1, &buffer); alDeleteBuffers(1, &buffer);
@ -907,123 +648,281 @@ size_t OpenAL_Output::getSoundDataSize(Sound_Handle data) const
} }
MWBase::SoundPtr OpenAL_Output::playSound(Sound_Handle data, float vol, float basevol, float pitch, int flags,float offset) MWBase::SoundPtr OpenAL_Output::playSound(Sound_Handle data, float vol, float basevol, float pitch, int flags, float offset)
{ {
boost::shared_ptr<OpenAL_Sound> sound; boost::shared_ptr<Sound> sound;
ALuint src; ALuint source;
if(mFreeSources.empty()) if(mFreeSources.empty())
fail("No free sources"); fail("No free sources");
src = mFreeSources.front(); source = mFreeSources.front();
mFreeSources.pop_front(); mFreeSources.pop_front();
try { try {
sound.reset(new OpenAL_Sound(*this, src, osg::Vec3f(0.f, 0.f, 0.f), vol, basevol, pitch, 1.0f, 1000.0f, flags)); alSourcef(source, AL_REFERENCE_DISTANCE, 1.0f);
alSourcef(source, AL_MAX_DISTANCE, 1000.0f);
alSourcef(source, AL_ROLLOFF_FACTOR, 0.0f);
alSourcei(source, AL_SOURCE_RELATIVE, AL_TRUE);
alSourcei(source, AL_LOOPING, (flags&MWBase::SoundManager::Play_Loop) ? AL_TRUE : AL_FALSE);
ALfloat gain = vol*basevol;
if(!(flags&MWBase::SoundManager::Play_NoEnv) && mLastEnvironment == Env_Underwater)
{
gain *= 0.9f;
pitch *= 0.7f;
}
alSourcef(source, AL_GAIN, gain);
alSourcef(source, AL_PITCH, pitch);
alSource3f(source, AL_POSITION, 0.0f, 0.0f, 0.0f);
alSource3f(source, AL_DIRECTION, 0.0f, 0.0f, 0.0f);
alSource3f(source, AL_VELOCITY, 0.0f, 0.0f, 0.0f);
alSourcef(source, AL_SEC_OFFSET, offset/pitch);
alSourcei(source, AL_BUFFER, GET_PTRID(data));
alSourcePlay(source);
throwALerror();
sound.reset(new Sound(osg::Vec3f(0.f, 0.f, 0.f), vol, basevol, pitch, 1.0f, 1000.0f, flags));
sound->mHandle = MAKE_PTRID(source);
mActiveSounds.push_back(sound);
} }
catch(std::exception&) catch(std::exception&) {
{ mFreeSources.push_back(source);
mFreeSources.push_back(src);
throw; throw;
} }
sound->updateAll(true);
alSourcei(src, AL_BUFFER, GET_PTRID(data));
alSourcef(src, AL_SEC_OFFSET, offset/pitch);
alSourcePlay(src);
throwALerror();
return sound; return sound;
} }
MWBase::SoundPtr OpenAL_Output::playSound3D(Sound_Handle data, const osg::Vec3f &pos, float vol, float basevol, float pitch, MWBase::SoundPtr OpenAL_Output::playSound3D(Sound_Handle data, const osg::Vec3f &pos, float vol, float basevol, float pitch,
float min, float max, int flags, float offset) float mindist, float maxdist, int flags, float offset)
{ {
boost::shared_ptr<OpenAL_Sound> sound; boost::shared_ptr<Sound> sound;
ALuint src; ALuint source;
if(mFreeSources.empty()) if(mFreeSources.empty())
fail("No free sources"); fail("No free sources");
src = mFreeSources.front(); source = mFreeSources.front();
mFreeSources.pop_front(); mFreeSources.pop_front();
try { try {
sound.reset(new OpenAL_Sound3D(*this, src, pos, vol, basevol, pitch, min, max, flags)); alSourcef(source, AL_REFERENCE_DISTANCE, mindist);
alSourcef(source, AL_MAX_DISTANCE, maxdist);
alSourcef(source, AL_ROLLOFF_FACTOR, 1.0f);
alSourcei(source, AL_SOURCE_RELATIVE, AL_FALSE);
alSourcei(source, AL_LOOPING, (flags&MWBase::SoundManager::Play_Loop) ? AL_TRUE : AL_FALSE);
ALfloat gain = vol*basevol;
if((pos - mPos).length2() > maxdist*maxdist)
gain = 0.0f;
if(!(flags&MWBase::SoundManager::Play_NoEnv) && mLastEnvironment == Env_Underwater)
{
gain *= 0.9f;
pitch *= 0.7f;
}
alSourcef(source, AL_GAIN, gain);
alSourcef(source, AL_PITCH, pitch);
alSourcefv(source, AL_POSITION, pos.ptr());
alSource3f(source, AL_DIRECTION, 0.0f, 0.0f, 0.0f);
alSource3f(source, AL_VELOCITY, 0.0f, 0.0f, 0.0f);
alSourcef(source, AL_SEC_OFFSET, offset/pitch);
alSourcei(source, AL_BUFFER, GET_PTRID(data));
alSourcePlay(source);
throwALerror();
sound.reset(new Sound(pos, vol, basevol, pitch, mindist, maxdist, flags));
sound->mHandle = MAKE_PTRID(source);
mActiveSounds.push_back(sound);
} }
catch(std::exception&) catch(std::exception&) {
{ mFreeSources.push_back(source);
mFreeSources.push_back(src);
throw; throw;
} }
sound->updateAll(false); return sound;
alSourcei(src, AL_BUFFER, GET_PTRID(data)); }
alSourcef(src, AL_SEC_OFFSET, offset/pitch);
alSourcePlay(src); void OpenAL_Output::stopSound(MWBase::SoundPtr sound)
{
if(!sound->mHandle)
return;
ALuint source = GET_PTRID(sound->mHandle);
sound->mHandle = 0;
alSourceStop(source);
alSourcei(source, AL_BUFFER, 0);
mFreeSources.push_back(source);
mActiveSounds.erase(std::find(mActiveSounds.begin(), mActiveSounds.end(), sound));
}
bool OpenAL_Output::isSoundPlaying(MWBase::SoundPtr sound)
{
if(!sound->mHandle)
return false;
ALuint source = GET_PTRID(sound->mHandle);
ALint state;
alGetSourcei(source, AL_SOURCE_STATE, &state);
throwALerror(); throwALerror();
return sound; return state == AL_PLAYING || state == AL_PAUSED;
} }
MWBase::SoundPtr OpenAL_Output::streamSound(DecoderPtr decoder, float basevol, float pitch, int flags) MWBase::SoundPtr OpenAL_Output::streamSound(DecoderPtr decoder, float basevol, float pitch, int flags)
{ {
boost::shared_ptr<OpenAL_SoundStream> sound; boost::shared_ptr<Sound> sound;
ALuint src; OpenAL_SoundStream *stream = 0;
ALuint source;
if(mFreeSources.empty()) if(mFreeSources.empty())
fail("No free sources"); fail("No free sources");
src = mFreeSources.front(); source = mFreeSources.front();
mFreeSources.pop_front(); mFreeSources.pop_front();
if((flags&MWBase::SoundManager::Play_Loop)) if((flags&MWBase::SoundManager::Play_Loop))
std::cout <<"Warning: cannot loop stream \""<<decoder->getName()<<"\""<< std::endl; std::cout <<"Warning: cannot loop stream \""<<decoder->getName()<<"\""<< std::endl;
try try {
{ alSourcef(source, AL_REFERENCE_DISTANCE, 1.0f);
sound.reset(new OpenAL_SoundStream(*this, src, decoder, osg::Vec3f(0.0f, 0.0f, 0.0f), 1.0f, basevol, pitch, 1.0f, 1000.0f, flags)); alSourcef(source, AL_MAX_DISTANCE, 1000.0f);
alSourcef(source, AL_ROLLOFF_FACTOR, 0.0f);
alSourcei(source, AL_SOURCE_RELATIVE, AL_TRUE);
alSourcei(source, AL_LOOPING, AL_FALSE);
ALfloat gain = basevol;
if(!(flags&MWBase::SoundManager::Play_NoEnv) && mLastEnvironment == Env_Underwater)
{
gain *= 0.9f;
pitch *= 0.7f;
}
alSourcef(source, AL_GAIN, gain);
alSourcef(source, AL_PITCH, pitch);
alSource3f(source, AL_POSITION, 0.0f, 0.0f, 0.0f);
alSource3f(source, AL_DIRECTION, 0.0f, 0.0f, 0.0f);
alSource3f(source, AL_VELOCITY, 0.0f, 0.0f, 0.0f);
throwALerror();
sound.reset(new Sound(osg::Vec3f(0.0f, 0.0f, 0.0f), 1.0f, basevol, pitch, 1.0f, 1000.0f, flags));
stream = new OpenAL_SoundStream(source, decoder);
mStreamThread->add(stream);
sound->mHandle = stream;
mActiveStreams.push_back(sound);
} }
catch(std::exception&) catch(std::exception&) {
{ mStreamThread->remove(stream);
mFreeSources.push_back(src); delete stream;
mFreeSources.push_back(source);
throw; throw;
} }
sound->updateAll(true);
sound->play();
return sound; return sound;
} }
MWBase::SoundPtr OpenAL_Output::streamSound3D(DecoderPtr decoder, const osg::Vec3f &pos, float volume, float basevol, float pitch, float mindist, float maxdist, int flags)
MWBase::SoundPtr OpenAL_Output::streamSound3D(DecoderPtr decoder, const osg::Vec3f &pos, float volume, float basevol, float pitch, float min, float max, int flags)
{ {
boost::shared_ptr<OpenAL_SoundStream> sound; boost::shared_ptr<Sound> sound;
ALuint src; OpenAL_SoundStream *stream = 0;
ALuint source;
if(mFreeSources.empty()) if(mFreeSources.empty())
fail("No free sources"); fail("No free sources");
src = mFreeSources.front(); source = mFreeSources.front();
mFreeSources.pop_front(); mFreeSources.pop_front();
if((flags&MWBase::SoundManager::Play_Loop)) if((flags&MWBase::SoundManager::Play_Loop))
std::cout <<"Warning: cannot loop stream \""<<decoder->getName()<<"\""<< std::endl; std::cout <<"Warning: cannot loop stream \""<<decoder->getName()<<"\""<< std::endl;
try try {
{ alSourcef(source, AL_REFERENCE_DISTANCE, mindist);
sound.reset(new OpenAL_SoundStream3D(*this, src, decoder, pos, volume, basevol, pitch, min, max, flags)); alSourcef(source, AL_MAX_DISTANCE, maxdist);
alSourcef(source, AL_ROLLOFF_FACTOR, 1.0f);
alSourcei(source, AL_SOURCE_RELATIVE, AL_FALSE);
alSourcei(source, AL_LOOPING, AL_FALSE);
ALfloat gain = volume*basevol;
if((pos - mPos).length2() > maxdist*maxdist)
gain = 0.0f;
if(!(flags&MWBase::SoundManager::Play_NoEnv) && mLastEnvironment == Env_Underwater)
{
gain *= 0.9f;
pitch *= 0.7f;
}
alSourcef(source, AL_GAIN, gain);
alSourcef(source, AL_PITCH, pitch);
alSourcefv(source, AL_POSITION, pos.ptr());
alSource3f(source, AL_DIRECTION, 0.0f, 0.0f, 0.0f);
alSource3f(source, AL_VELOCITY, 0.0f, 0.0f, 0.0f);
throwALerror();
sound.reset(new Sound(pos, volume, basevol, pitch, mindist, maxdist, flags));
stream = new OpenAL_SoundStream(source, decoder);
mStreamThread->add(stream);
sound->mHandle = stream;
mActiveStreams.push_back(sound);
} }
catch(std::exception&) catch(std::exception&) {
{ mStreamThread->remove(stream);
mFreeSources.push_back(src); delete stream;
mFreeSources.push_back(source);
throw; throw;
} }
sound->updateAll(false);
sound->play();
return sound; return sound;
} }
void OpenAL_Output::stopStream(MWBase::SoundPtr sound)
{
if(!sound->mHandle)
return;
OpenAL_SoundStream *stream = reinterpret_cast<OpenAL_SoundStream*>(sound->mHandle);
ALuint source = stream->mSource;
sound->mHandle = 0;
mStreamThread->remove(stream);
alSourceStop(source);
alSourcei(source, AL_BUFFER, 0);
mFreeSources.push_back(source);
mActiveStreams.erase(std::find(mActiveStreams.begin(), mActiveStreams.end(), sound));
delete stream;
}
double OpenAL_Output::getStreamDelay(MWBase::SoundPtr sound)
{
if(!sound->mHandle)
return 0.0;
OpenAL_SoundStream *stream = reinterpret_cast<OpenAL_SoundStream*>(sound->mHandle);
return stream->getStreamDelay();
}
double OpenAL_Output::getStreamOffset(MWBase::SoundPtr sound)
{
if(!sound->mHandle)
return 0.0;
OpenAL_SoundStream *stream = reinterpret_cast<OpenAL_SoundStream*>(sound->mHandle);
boost::lock_guard<boost::mutex> lock(mStreamThread->mMutex);
return stream->getStreamOffset();
}
bool OpenAL_Output::isStreamPlaying(MWBase::SoundPtr sound)
{
if(!sound->mHandle)
return false;
OpenAL_SoundStream *stream = reinterpret_cast<OpenAL_SoundStream*>(sound->mHandle);
boost::lock_guard<boost::mutex> lock(mStreamThread->mMutex);
return stream->isPlaying();
}
void OpenAL_Output::startUpdate() void OpenAL_Output::startUpdate()
{ {
@ -1060,14 +959,17 @@ void OpenAL_Output::pauseSounds(int types)
SoundVec::const_iterator sound = mActiveSounds.begin(); SoundVec::const_iterator sound = mActiveSounds.begin();
for(;sound != mActiveSounds.end();++sound) for(;sound != mActiveSounds.end();++sound)
{ {
if(*sound && (*sound)->mSource && ((*sound)->getPlayType()&types)) if(*sound && (*sound)->mHandle && ((*sound)->getPlayType()&types))
sources.push_back((*sound)->mSource); sources.push_back(GET_PTRID((*sound)->mHandle));
} }
StreamVec::const_iterator stream = mActiveStreams.begin(); StreamVec::const_iterator stream = mActiveStreams.begin();
for(;stream != mActiveStreams.end();++stream) for(;stream != mActiveStreams.end();++stream)
{ {
if(*stream && (*stream)->mSource && ((*stream)->getPlayType()&types)) if(*stream && (*stream)->mHandle && ((*stream)->getPlayType()&types))
sources.push_back((*stream)->mSource); {
OpenAL_SoundStream *strm = reinterpret_cast<OpenAL_SoundStream*>((*stream)->mHandle);
sources.push_back(strm->mSource);
}
} }
if(!sources.empty()) if(!sources.empty())
{ {
@ -1082,14 +984,17 @@ void OpenAL_Output::resumeSounds(int types)
SoundVec::const_iterator sound = mActiveSounds.begin(); SoundVec::const_iterator sound = mActiveSounds.begin();
for(;sound != mActiveSounds.end();++sound) for(;sound != mActiveSounds.end();++sound)
{ {
if(*sound && (*sound)->mSource && ((*sound)->getPlayType()&types)) if(*sound && (*sound)->mHandle && ((*sound)->getPlayType()&types))
sources.push_back((*sound)->mSource); sources.push_back(GET_PTRID((*sound)->mHandle));
} }
StreamVec::const_iterator stream = mActiveStreams.begin(); StreamVec::const_iterator stream = mActiveStreams.begin();
for(;stream != mActiveStreams.end();++stream) for(;stream != mActiveStreams.end();++stream)
{ {
if(*stream && (*stream)->mSource && ((*stream)->getPlayType()&types)) if(*stream && (*stream)->mHandle && ((*stream)->getPlayType()&types))
sources.push_back((*stream)->mSource); {
OpenAL_SoundStream *strm = reinterpret_cast<OpenAL_SoundStream*>((*stream)->mHandle);
sources.push_back(strm->mSource);
}
} }
if(!sources.empty()) if(!sources.empty())
{ {

14
apps/openmw/mwsound/openal_output.hpp
View file

@ -16,9 +16,6 @@ namespace MWSound
class SoundManager; class SoundManager;
class Sound; class Sound;
class OpenAL_Sound;
class OpenAL_SoundStream;
class OpenAL_Output : public Sound_Output class OpenAL_Output : public Sound_Output
{ {
ALCdevice *mDevice; ALCdevice *mDevice;
@ -27,9 +24,9 @@ namespace MWSound
typedef std::deque<ALuint> IDDq; typedef std::deque<ALuint> IDDq;
IDDq mFreeSources; IDDq mFreeSources;
typedef std::vector<OpenAL_Sound*> SoundVec; typedef std::vector<MWBase::SoundPtr> SoundVec;
SoundVec mActiveSounds; SoundVec mActiveSounds;
typedef std::vector<OpenAL_SoundStream*> StreamVec; typedef std::vector<MWBase::SoundPtr> StreamVec;
StreamVec mActiveStreams; StreamVec mActiveStreams;
Environment mLastEnvironment; Environment mLastEnvironment;
@ -45,9 +42,16 @@ namespace MWSound
virtual MWBase::SoundPtr playSound(Sound_Handle data, float vol, float basevol, float pitch, int flags, float offset); virtual MWBase::SoundPtr playSound(Sound_Handle data, float vol, float basevol, float pitch, int flags, float offset);
virtual MWBase::SoundPtr playSound3D(Sound_Handle data, const osg::Vec3f &pos, virtual MWBase::SoundPtr playSound3D(Sound_Handle data, const osg::Vec3f &pos,
float vol, float basevol, float pitch, float min, float max, int flags, float offset); float vol, float basevol, float pitch, float min, float max, int flags, float offset);
virtual void stopSound(MWBase::SoundPtr sound);
virtual bool isSoundPlaying(MWBase::SoundPtr sound);
virtual MWBase::SoundPtr streamSound(DecoderPtr decoder, float basevol, float pitch, int flags); virtual MWBase::SoundPtr streamSound(DecoderPtr decoder, float basevol, float pitch, int flags);
virtual MWBase::SoundPtr streamSound3D(DecoderPtr decoder, const osg::Vec3f &pos, virtual MWBase::SoundPtr streamSound3D(DecoderPtr decoder, const osg::Vec3f &pos,
float vol, float basevol, float pitch, float min, float max, int flags); float vol, float basevol, float pitch, float min, float max, int flags);
virtual void stopStream(MWBase::SoundPtr sound);
virtual double getStreamDelay(MWBase::SoundPtr sound);
virtual double getStreamOffset(MWBase::SoundPtr sound);
virtual bool isStreamPlaying(MWBase::SoundPtr sound);
virtual void startUpdate(); virtual void startUpdate();
virtual void finishUpdate(); virtual void finishUpdate();

25
apps/openmw/mwsound/sound.hpp
View file

@ -10,7 +10,6 @@ namespace MWSound
Sound& operator=(const Sound &rhs); Sound& operator=(const Sound &rhs);
Sound(const Sound &rhs); Sound(const Sound &rhs);
protected:
osg::Vec3f mPos; osg::Vec3f mPos;
float mVolume; /* NOTE: Real volume = mVolume*mBaseVolume */ float mVolume; /* NOTE: Real volume = mVolume*mBaseVolume */
float mBaseVolume; float mBaseVolume;
@ -21,12 +20,13 @@ namespace MWSound
float mFadeOutTime; float mFadeOutTime;
protected:
void *mHandle;
friend class Sound_Output;
friend class OpenAL_Output;
public: public:
virtual void stop() = 0;
virtual bool isPlaying() = 0;
virtual double getTimeOffset() = 0;
virtual double getStreamDelay() const { return 0.0; }
virtual void applyUpdates() = 0;
void setPosition(const osg::Vec3f &pos) { mPos = pos; } void setPosition(const osg::Vec3f &pos) { mPos = pos; }
void setVolume(float volume) { mVolume = volume; } void setVolume(float volume) { mVolume = volume; }
void setBaseVolume(float volume) { mBaseVolume = volume; } void setBaseVolume(float volume) { mBaseVolume = volume; }
@ -47,16 +47,11 @@ namespace MWSound
bool getIs3D() const { return mFlags&Play_3D; } bool getIs3D() const { return mFlags&Play_3D; }
Sound(const osg::Vec3f& pos, float vol, float basevol, float pitch, float mindist, float maxdist, int flags) Sound(const osg::Vec3f& pos, float vol, float basevol, float pitch, float mindist, float maxdist, int flags)
: mPos(pos) : mPos(pos), mVolume(vol), mBaseVolume(basevol), mPitch(pitch)
, mVolume(vol) , mMinDistance(mindist), mMaxDistance(maxdist), mFlags(flags)
, mBaseVolume(basevol) , mFadeOutTime(0.0f), mHandle(0)
, mPitch(pitch)
, mMinDistance(mindist)
, mMaxDistance(maxdist)
, mFlags(flags)
, mFadeOutTime(0.0f)
{ } { }
virtual ~Sound() { } ~Sound() { }
}; };
} }

7
apps/openmw/mwsound/sound_output.hpp
View file

@ -35,9 +35,16 @@ namespace MWSound
/// @param offset Number of seconds into the sound to start playback. /// @param offset Number of seconds into the sound to start playback.
virtual MWBase::SoundPtr playSound3D(Sound_Handle data, const osg::Vec3f &pos, virtual MWBase::SoundPtr playSound3D(Sound_Handle data, const osg::Vec3f &pos,
float vol, float basevol, float pitch, float min, float max, int flags, float offset) = 0; float vol, float basevol, float pitch, float min, float max, int flags, float offset) = 0;
virtual void stopSound(MWBase::SoundPtr sound) = 0;
virtual bool isSoundPlaying(MWBase::SoundPtr sound) = 0;
virtual MWBase::SoundPtr streamSound(DecoderPtr decoder, float basevol, float pitch, int flags) = 0; virtual MWBase::SoundPtr streamSound(DecoderPtr decoder, float basevol, float pitch, int flags) = 0;
virtual MWBase::SoundPtr streamSound3D(DecoderPtr decoder, const osg::Vec3f &pos, virtual MWBase::SoundPtr streamSound3D(DecoderPtr decoder, const osg::Vec3f &pos,
float vol, float basevol, float pitch, float min, float max, int flags) = 0; float vol, float basevol, float pitch, float min, float max, int flags) = 0;
virtual void stopStream(MWBase::SoundPtr sound) = 0;
virtual double getStreamDelay(MWBase::SoundPtr sound) = 0;
virtual double getStreamOffset(MWBase::SoundPtr sound) = 0;
virtual bool isStreamPlaying(MWBase::SoundPtr sound) = 0;
virtual void startUpdate() = 0; virtual void startUpdate() = 0;
virtual void finishUpdate() = 0; virtual void finishUpdate() = 0;

131
apps/openmw/mwsound/soundmanagerimp.cpp
View file

@ -293,7 +293,7 @@ namespace MWSound
void SoundManager::stopMusic() void SoundManager::stopMusic()
{ {
if(mMusic) if(mMusic)
mMusic->stop(); mOutput->stopStream(mMusic);
mMusic.reset(); mMusic.reset();
} }
@ -303,8 +303,7 @@ namespace MWSound
return; return;
std::cout <<"Playing "<<filename<< std::endl; std::cout <<"Playing "<<filename<< std::endl;
mLastPlayedMusic = filename; mLastPlayedMusic = filename;
try try {
{
stopMusic(); stopMusic();
DecoderPtr decoder = getDecoder(); DecoderPtr decoder = getDecoder();
@ -313,8 +312,7 @@ namespace MWSound
mMusic = mOutput->streamSound(decoder, volumeFromType(Play_TypeMusic), mMusic = mOutput->streamSound(decoder, volumeFromType(Play_TypeMusic),
1.0f, Play_NoEnv|Play_TypeMusic|Play_2D); 1.0f, Play_NoEnv|Play_TypeMusic|Play_2D);
} }
catch(std::exception &e) catch(std::exception &e) {
{
std::cout << "Music Error: " << e.what() << "\n"; std::cout << "Music Error: " << e.what() << "\n";
} }
} }
@ -366,7 +364,7 @@ namespace MWSound
bool SoundManager::isMusicPlaying() bool SoundManager::isMusicPlaying()
{ {
return mMusic && mMusic->isPlaying(); return mMusic && mOutput->isStreamPlaying(mMusic);
} }
void SoundManager::playPlaylist(const std::string &playlist) void SoundManager::playPlaylist(const std::string &playlist)
@ -411,9 +409,8 @@ namespace MWSound
{ {
MWBase::SoundPtr sound = snditer->second.first; MWBase::SoundPtr sound = snditer->second.first;
Sound_Loudness *loudness = snditer->second.second; Sound_Loudness *loudness = snditer->second.second;
float sec = sound->getTimeOffset(); float sec = mOutput->getStreamOffset(sound);
if(sound->isPlaying()) return loudness->getLoudnessAtTime(sec);
return loudness->getLoudnessAtTime(sec);
} }
return 0.0f; return 0.0f;
@ -450,7 +447,7 @@ namespace MWSound
SaySoundMap::const_iterator snditer = mActiveSaySounds.find(ptr); SaySoundMap::const_iterator snditer = mActiveSaySounds.find(ptr);
if(snditer != mActiveSaySounds.end()) if(snditer != mActiveSaySounds.end())
{ {
if(snditer->second.first->isPlaying()) if(mOutput->isStreamPlaying(snditer->second.first))
return false; return false;
return true; return true;
} }
@ -462,7 +459,7 @@ namespace MWSound
SaySoundMap::iterator snditer = mActiveSaySounds.find(ptr); SaySoundMap::iterator snditer = mActiveSaySounds.find(ptr);
if(snditer != mActiveSaySounds.end()) if(snditer != mActiveSaySounds.end())
{ {
snditer->second.first->stop(); mOutput->stopStream(snditer->second.first);
mActiveSaySounds.erase(snditer); mActiveSaySounds.erase(snditer);
} }
mPendingSaySounds.erase(ptr); mPendingSaySounds.erase(ptr);
@ -485,6 +482,16 @@ namespace MWSound
return track; return track;
} }
void SoundManager::stopTrack(MWBase::SoundPtr sound)
{
mOutput->stopStream(sound);
}
double SoundManager::getTrackTimeDelay(MWBase::SoundPtr sound)
{
return mOutput->getStreamDelay(sound);
}
MWBase::SoundPtr SoundManager::playSound(const std::string& soundId, float volume, float pitch, PlayType type, PlayMode mode, float offset) MWBase::SoundPtr SoundManager::playSound(const std::string& soundId, float volume, float pitch, PlayType type, PlayMode mode, float offset)
{ {
@ -586,6 +593,11 @@ namespace MWSound
return sound; return sound;
} }
void SoundManager::stopSound(MWBase::SoundPtr sound)
{
mOutput->stopSound(sound);
}
void SoundManager::stopSound3D(const MWWorld::Ptr &ptr, const std::string& soundId) void SoundManager::stopSound3D(const MWWorld::Ptr &ptr, const std::string& soundId)
{ {
SoundMap::iterator snditer = mActiveSounds.find(ptr); SoundMap::iterator snditer = mActiveSounds.find(ptr);
@ -596,7 +608,7 @@ namespace MWSound
for(;sndidx != snditer->second.end();++sndidx) for(;sndidx != snditer->second.end();++sndidx)
{ {
if(sndidx->second == sfx) if(sndidx->second == sfx)
sndidx->first->stop(); mOutput->stopSound(sndidx->first);
} }
} }
} }
@ -608,7 +620,7 @@ namespace MWSound
{ {
SoundBufferRefPairList::iterator sndidx = snditer->second.begin(); SoundBufferRefPairList::iterator sndidx = snditer->second.begin();
for(;sndidx != snditer->second.end();++sndidx) for(;sndidx != snditer->second.end();++sndidx)
sndidx->first->stop(); mOutput->stopSound(sndidx->first);
} }
} }
@ -623,7 +635,7 @@ namespace MWSound
{ {
SoundBufferRefPairList::iterator sndidx = snditer->second.begin(); SoundBufferRefPairList::iterator sndidx = snditer->second.begin();
for(;sndidx != snditer->second.end();++sndidx) for(;sndidx != snditer->second.end();++sndidx)
sndidx->first->stop(); mOutput->stopSound(sndidx->first);
} }
++snditer; ++snditer;
} }
@ -634,7 +646,7 @@ namespace MWSound
sayiter->first != MWMechanics::getPlayer() && sayiter->first != MWMechanics::getPlayer() &&
sayiter->first.getCell() == cell) sayiter->first.getCell() == cell)
{ {
sayiter->second.first->stop(); mOutput->stopStream(sayiter->second.first);
} }
++sayiter; ++sayiter;
} }
@ -650,7 +662,7 @@ namespace MWSound
for(;sndidx != snditer->second.end();++sndidx) for(;sndidx != snditer->second.end();++sndidx)
{ {
if(sndidx->second == sfx) if(sndidx->second == sfx)
sndidx->first->stop(); mOutput->stopSound(sndidx->first);
} }
} }
} }
@ -680,7 +692,7 @@ namespace MWSound
SoundBufferRefPairList::const_iterator sndidx = snditer->second.begin(); SoundBufferRefPairList::const_iterator sndidx = snditer->second.begin();
for(;sndidx != snditer->second.end();++sndidx) for(;sndidx != snditer->second.end();++sndidx)
{ {
if(sndidx->second == sfx && sndidx->first->isPlaying()) if(sndidx->second == sfx && mOutput->isSoundPlaying(sndidx->first))
return true; return true;
} }
} }
@ -788,7 +800,7 @@ namespace MWSound
env = Env_Underwater; env = Env_Underwater;
else if(mUnderwaterSound) else if(mUnderwaterSound)
{ {
mUnderwaterSound->stop(); mOutput->stopSound(mUnderwaterSound);
mUnderwaterSound.reset(); mUnderwaterSound.reset();
} }
@ -803,7 +815,7 @@ namespace MWSound
if(mListenerUnderwater) if(mListenerUnderwater)
{ {
// Play underwater sound (after updating listener) // Play underwater sound (after updating listener)
if(!(mUnderwaterSound && mUnderwaterSound->isPlaying())) if(!(mUnderwaterSound && mOutput->isSoundPlaying(mUnderwaterSound)))
mUnderwaterSound = playSound("Underwater", 1.0f, 1.0f, Play_TypeSfx, Play_LoopNoEnv); mUnderwaterSound = playSound("Underwater", 1.0f, 1.0f, Play_TypeSfx, Play_LoopNoEnv);
} }
@ -814,15 +826,35 @@ namespace MWSound
SoundBufferRefPairList::iterator sndidx = snditer->second.begin(); SoundBufferRefPairList::iterator sndidx = snditer->second.begin();
while(sndidx != snditer->second.end()) while(sndidx != snditer->second.end())
{ {
if(!updateSound(sndidx->first, snditer->first, duration)) MWWorld::Ptr ptr = snditer->first;
MWBase::SoundPtr sound = sndidx->first;
if(!ptr.isEmpty() && sound->getIs3D())
{ {
const ESM::Position &pos = ptr.getRefData().getPosition();
const osg::Vec3f objpos(pos.asVec3());
sound->setPosition(objpos);
if(sound->getDistanceCull())
{
if((mListenerPos - objpos).length2() > 2000*2000)
mOutput->stopSound(sound);
}
}
if(!mOutput->isSoundPlaying(sound))
{
mOutput->stopSound(sound);
Sound_Buffer *sfx = sndidx->second; Sound_Buffer *sfx = sndidx->second;
if(sfx->mUses-- == 1) if(sfx->mUses-- == 1)
mUnusedBuffers.push_front(sfx); mUnusedBuffers.push_front(sfx);
sndidx = snditer->second.erase(sndidx); sndidx = snditer->second.erase(sndidx);
} }
else else
{
sound->updateFade(duration);
++sndidx; ++sndidx;
}
} }
if(snditer->second.empty()) if(snditer->second.empty())
mActiveSounds.erase(snditer++); mActiveSounds.erase(snditer++);
@ -862,36 +894,34 @@ namespace MWSound
SaySoundMap::iterator sayiter = mActiveSaySounds.begin(); SaySoundMap::iterator sayiter = mActiveSaySounds.begin();
while(sayiter != mActiveSaySounds.end()) while(sayiter != mActiveSaySounds.end())
{ {
if(!updateSound(sayiter->second.first, sayiter->first, duration)) MWWorld::Ptr ptr = sayiter->first;
mActiveSaySounds.erase(sayiter++); MWBase::SoundPtr sound = sayiter->second.first;
else if(!ptr.isEmpty() && sound->getIs3D())
++sayiter;
}
mOutput->finishUpdate();
}
bool SoundManager::updateSound(MWBase::SoundPtr sound, const MWWorld::Ptr& ptr, float duration)
{
if(!ptr.isEmpty() && sound->getIs3D())
{
const ESM::Position &pos = ptr.getRefData().getPosition();
const osg::Vec3f objpos(pos.asVec3());
sound->setPosition(objpos);
if(sound->getDistanceCull())
{ {
if((mListenerPos - objpos).length2() > 2000*2000) const ESM::Position &pos = ptr.getRefData().getPosition();
sound->stop(); const osg::Vec3f objpos(pos.asVec3());
sound->setPosition(objpos);
if(sound->getDistanceCull())
{
if((mListenerPos - objpos).length2() > 2000*2000)
mOutput->stopStream(sound);
}
}
if(!mOutput->isStreamPlaying(sound))
{
mOutput->stopStream(sound);
mActiveSaySounds.erase(sayiter++);
}
else
{
sound->updateFade(duration);
++sayiter;
} }
} }
mOutput->finishUpdate();
if(!sound->isPlaying())
return false;
sound->updateFade(duration);
sound->applyUpdates();
return true;
} }
@ -928,7 +958,6 @@ namespace MWSound
{ {
MWBase::SoundPtr sound = sndidx->first; MWBase::SoundPtr sound = sndidx->first;
sound->setBaseVolume(volumeFromType(sound->getPlayType())); sound->setBaseVolume(volumeFromType(sound->getPlayType()));
sound->applyUpdates();
} }
} }
SaySoundMap::iterator sayiter = mActiveSaySounds.begin(); SaySoundMap::iterator sayiter = mActiveSaySounds.begin();
@ -936,12 +965,10 @@ namespace MWSound
{ {
MWBase::SoundPtr sound = sayiter->second.first; MWBase::SoundPtr sound = sayiter->second.first;
sound->setBaseVolume(volumeFromType(sound->getPlayType())); sound->setBaseVolume(volumeFromType(sound->getPlayType()));
sound->applyUpdates();
} }
if(mMusic) if(mMusic)
{ {
mMusic->setBaseVolume(volumeFromType(mMusic->getPlayType())); mMusic->setBaseVolume(volumeFromType(mMusic->getPlayType()));
mMusic->applyUpdates();
} }
mOutput->finishUpdate(); mOutput->finishUpdate();
} }
@ -1056,7 +1083,7 @@ namespace MWSound
SoundBufferRefPairList::iterator sndidx = snditer->second.begin(); SoundBufferRefPairList::iterator sndidx = snditer->second.begin();
for(;sndidx != snditer->second.end();++sndidx) for(;sndidx != snditer->second.end();++sndidx)
{ {
sndidx->first->stop(); mOutput->stopSound(sndidx->first);
Sound_Buffer *sfx = sndidx->second; Sound_Buffer *sfx = sndidx->second;
if(sfx->mUses-- == 1) if(sfx->mUses-- == 1)
mUnusedBuffers.push_front(sfx); mUnusedBuffers.push_front(sfx);
@ -1065,7 +1092,7 @@ namespace MWSound
mActiveSounds.clear(); mActiveSounds.clear();
SaySoundMap::iterator sayiter = mActiveSaySounds.begin(); SaySoundMap::iterator sayiter = mActiveSaySounds.begin();
for(;sayiter != mActiveSaySounds.end();++sayiter) for(;sayiter != mActiveSaySounds.end();++sayiter)
sayiter->second.first->stop(); mOutput->stopStream(sayiter->second.first);
mActiveSaySounds.clear(); mActiveSaySounds.clear();
mPendingSaySounds.clear(); mPendingSaySounds.clear();
mUnderwaterSound.reset(); mUnderwaterSound.reset();

12
apps/openmw/mwsound/soundmanagerimp.hpp
View file

@ -116,7 +116,6 @@ namespace MWSound
MWBase::SoundPtr playVoice(DecoderPtr decoder, const osg::Vec3f &pos, bool playlocal); MWBase::SoundPtr playVoice(DecoderPtr decoder, const osg::Vec3f &pos, bool playlocal);
void streamMusicFull(const std::string& filename); void streamMusicFull(const std::string& filename);
bool updateSound(MWBase::SoundPtr sound, const MWWorld::Ptr &ptr, float duration);
void updateSounds(float duration); void updateSounds(float duration);
void updateRegionSound(float duration); void updateRegionSound(float duration);
@ -174,6 +173,14 @@ namespace MWSound
virtual MWBase::SoundPtr playTrack(const DecoderPtr& decoder, PlayType type); virtual MWBase::SoundPtr playTrack(const DecoderPtr& decoder, PlayType type);
///< Play a 2D audio track, using a custom decoder ///< Play a 2D audio track, using a custom decoder
virtual void stopTrack(MWBase::SoundPtr sound);
///< Stop the given audio track from playing
virtual double getTrackTimeDelay(MWBase::SoundPtr sound);
///< Retives the time delay, in seconds, of the audio track (must be a sound
/// returned by \ref playTrack). Only intended to be called by the track
/// decoder's read method.
virtual MWBase::SoundPtr playSound(const std::string& soundId, float volume, float pitch, PlayType type=Play_TypeSfx, PlayMode mode=Play_Normal, float offset=0); virtual MWBase::SoundPtr playSound(const std::string& soundId, float volume, float pitch, PlayType type=Play_TypeSfx, PlayMode mode=Play_Normal, float offset=0);
///< Play a sound, independently of 3D-position ///< Play a sound, independently of 3D-position
///< @param offset Number of seconds into the sound to start playback. ///< @param offset Number of seconds into the sound to start playback.
@ -189,6 +196,9 @@ namespace MWSound
///< Play a 3D sound at \a initialPos. If the sound should be moving, it must be updated using Sound::setPosition. ///< Play a 3D sound at \a initialPos. If the sound should be moving, it must be updated using Sound::setPosition.
///< @param offset Number of seconds into the sound to start playback. ///< @param offset Number of seconds into the sound to start playback.
virtual void stopSound(MWBase::SoundPtr sound);
///< Stop the given sound from playing
virtual void stopSound3D(const MWWorld::Ptr &reference, const std::string& soundId); virtual void stopSound3D(const MWWorld::Ptr &reference, const std::string& soundId);
///< Stop the given object from playing the given sound, ///< Stop the given object from playing the given sound,

4
apps/openmw/mwworld/projectilemanager.cpp
View file

@ -190,7 +190,7 @@ namespace MWWorld
{ {
MWBase::Environment::get().getWorld()->explodeSpell(pos, it->mEffects, caster, ESM::RT_Target, it->mSpellId, it->mSourceName); MWBase::Environment::get().getWorld()->explodeSpell(pos, it->mEffects, caster, ESM::RT_Target, it->mSpellId, it->mSourceName);
it->mSound->stop(); MWBase::Environment::get().getSoundManager()->stopSound(it->mSound);
mParent->removeChild(it->mNode); mParent->removeChild(it->mNode);
it = mMagicBolts.erase(it); it = mMagicBolts.erase(it);
@ -264,7 +264,7 @@ namespace MWWorld
for (std::vector<MagicBoltState>::iterator it = mMagicBolts.begin(); it != mMagicBolts.end(); ++it) for (std::vector<MagicBoltState>::iterator it = mMagicBolts.begin(); it != mMagicBolts.end(); ++it)
{ {
mParent->removeChild(it->mNode); mParent->removeChild(it->mNode);
it->mSound->stop(); MWBase::Environment::get().getSoundManager()->stopSound(it->mSound);
} }
mMagicBolts.clear(); mMagicBolts.clear();
} }

2
apps/openmw/mwworld/weather.cpp
View file

@ -738,7 +738,7 @@ void WeatherManager::update(float duration, bool paused)
void WeatherManager::stopSounds() void WeatherManager::stopSounds()
{ {
if (mAmbientSound.get()) if (mAmbientSound.get())
mAmbientSound->stop(); MWBase::Environment::get().getSoundManager()->stopSound(mAmbientSound);
mAmbientSound.reset(); mAmbientSound.reset();
mPlayingSoundID.clear(); mPlayingSoundID.clear();
} }