openmw-tes3mp/apps/openmw/mwsound/openal_output.hpp

#ifndef GAME_SOUND_OPENAL_OUTPUT_H
#define GAME_SOUND_OPENAL_OUTPUT_H

#include <string>
#include <vector>
#include <map>
#include <deque>

#include "alc.h"
#include "al.h"

#include "sound_output.hpp"

namespace MWSound
{
    class SoundManager;
    class Sound;

    class OpenAL_Output : public Sound_Output
    {
        ALCdevice *mDevice;
        ALCcontext *mContext;

        typedef std::deque<ALuint> IDDq;
        IDDq mFreeSources;

        typedef std::vector<MWBase::SoundPtr> SoundVec;
        SoundVec mActiveSounds;
        typedef std::vector<MWBase::SoundStreamPtr> StreamVec;
        StreamVec mActiveStreams;

        osg::Vec3f mListenerPos;
        Environment mListenerEnv;

        struct StreamThread;
        std::auto_ptr<StreamThread> mStreamThread;

        void initCommon2D(ALuint source, const osg::Vec3f &pos, ALfloat gain, ALfloat pitch, bool loop, bool useenv);
        void initCommon3D(ALuint source, const osg::Vec3f &pos, ALfloat mindist, ALfloat maxdist, ALfloat gain, ALfloat pitch, bool loop, bool useenv);

        void updateCommon(ALuint source, const osg::Vec3f &pos, ALfloat maxdist, ALfloat gain, ALfloat pitch, bool useenv, bool is3d);

        OpenAL_Output& operator=(const OpenAL_Output &rhs);
        OpenAL_Output(const OpenAL_Output &rhs);

    public:
        virtual std::vector<std::string> enumerate();
        virtual void init(const std::string &devname=std::string());
        virtual void deinit();

        virtual std::vector<std::string> enumerateHrtf();
        virtual void enableHrtf(const std::string &hrtfname, bool auto_enable);
        virtual void disableHrtf();

        virtual Sound_Handle loadSound(const std::string &fname);
        virtual void unloadSound(Sound_Handle data);
        virtual size_t getSoundDataSize(Sound_Handle data) const;

        virtual void playSound(MWBase::SoundPtr sound, Sound_Handle data, float offset);
        virtual void playSound3D(MWBase::SoundPtr sound, Sound_Handle data, float offset);
        virtual void finishSound(MWBase::SoundPtr sound);
        virtual bool isSoundPlaying(MWBase::SoundPtr sound);
        virtual void updateSound(MWBase::SoundPtr sound);

        virtual void streamSound(DecoderPtr decoder, MWBase::SoundStreamPtr sound);
        virtual void streamSound3D(DecoderPtr decoder, MWBase::SoundStreamPtr sound, bool getLoudnessData);
        virtual void finishStream(MWBase::SoundStreamPtr sound);
        virtual double getStreamDelay(MWBase::SoundStreamPtr sound);
        virtual double getStreamOffset(MWBase::SoundStreamPtr sound);
        virtual float getStreamLoudness(MWBase::SoundStreamPtr sound);
        virtual bool isStreamPlaying(MWBase::SoundStreamPtr sound);
        virtual void updateStream(MWBase::SoundStreamPtr sound);

        virtual void startUpdate();
        virtual void finishUpdate();

        virtual void updateListener(const osg::Vec3f &pos, const osg::Vec3f &atdir, const osg::Vec3f &updir, Environment env);

        virtual void pauseSounds(int types);
        virtual void resumeSounds(int types);

        OpenAL_Output(SoundManager &mgr);
        virtual ~OpenAL_Output();
    };
#ifndef DEFAULT_OUTPUT
#define DEFAULT_OUTPUT(x) ::MWSound::OpenAL_Output((x))
#endif
}

#endif
Add a skeleton output classs using OpenAL 2012-03-17 05:12:17 +00:00			`#ifndef GAME_SOUND_OPENAL_OUTPUT_H`
			`#define GAME_SOUND_OPENAL_OUTPUT_H`

Move Sound_Output's definition to a separate header 2012-03-17 06:40:07 +00:00			`#include <string>`
Allocate OpenAL sources when opening the device This allows sources to be more efficiently retrieved and returned 2012-03-19 14:11:01 +00:00			`#include <vector>`
Cache OpenAL buffers for easy reuse 2012-03-19 17:33:06 +00:00			`#include <map>`
			`#include <deque>`
Add a skeleton output classs using OpenAL 2012-03-17 05:12:17 +00:00
			`#include "alc.h"`
			`#include "al.h"`

Move Sound_Output's definition to a separate header 2012-03-17 06:40:07 +00:00			`#include "sound_output.hpp"`

Add a skeleton output classs using OpenAL 2012-03-17 05:12:17 +00:00			`namespace MWSound`
			`{`
Move Sound_Output's definition to a separate header 2012-03-17 06:40:07 +00:00			`class SoundManager;`
Add a function to stream sounds 2012-03-17 09:55:08 +00:00			`class Sound;`
Move Sound_Output's definition to a separate header 2012-03-17 06:40:07 +00:00
Add a skeleton output classs using OpenAL 2012-03-17 05:12:17 +00:00			`class OpenAL_Output : public Sound_Output`
			`{`
Rename some more sound class member variables and functions 2012-03-18 18:30:53 +00:00			`ALCdevice *mDevice;`
			`ALCcontext *mContext;`
Add a skeleton output classs using OpenAL 2012-03-17 05:12:17 +00:00
Use a deque fpr OpenAL's free sources 2012-03-28 12:35:51 +00:00			`typedef std::deque<ALuint> IDDq;`
			`IDDq mFreeSources;`
Enforce a 15MB limit on the sound buffer cache 2012-03-19 20:19:22 +00:00
Avoid inheriting from Sound for sound types 2015-11-30 13:42:51 +00:00			`typedef std::vector<MWBase::SoundPtr> SoundVec;`
Keep track of the actual active sounds 2012-12-18 05:50:01 +00:00			`SoundVec mActiveSounds;`
Use a separate type for streams They're basically the same, but it's to help avoid accidents with passing non- streaming sounds to the stream functions, or vice-versa. 2015-11-30 15:32:42 +00:00			`typedef std::vector<MWBase::SoundStreamPtr> StreamVec;`
Use separate lists for openal sounds and streams 2015-11-23 15:51:52 +00:00			`StreamVec mActiveStreams;`
Keep track of the actual active sounds 2012-12-18 05:50:01 +00:00
Rename a couple members to avoid confusion 2015-11-30 16:00:02 +00:00			`osg::Vec3f mListenerPos;`
			`Environment mListenerEnv;`
Implement a basic underwater sound environment 2012-03-31 17:06:12 +00:00
Rename a couple members to avoid confusion 2015-11-30 16:00:02 +00:00			`struct StreamThread;`
			`std::auto_ptr<StreamThread> mStreamThread;`

Combine duplicate code 2015-12-02 17:55:51 +00:00			`void initCommon2D(ALuint source, const osg::Vec3f &pos, ALfloat gain, ALfloat pitch, bool loop, bool useenv);`
			`void initCommon3D(ALuint source, const osg::Vec3f &pos, ALfloat mindist, ALfloat maxdist, ALfloat gain, ALfloat pitch, bool loop, bool useenv);`

			`void updateCommon(ALuint source, const osg::Vec3f &pos, ALfloat maxdist, ALfloat gain, ALfloat pitch, bool useenv, bool is3d);`

Rename a couple members to avoid confusion 2015-11-30 16:00:02 +00:00			`OpenAL_Output& operator=(const OpenAL_Output &rhs);`
			`OpenAL_Output(const OpenAL_Output &rhs);`

			`public:`
Add an enumerate method to the sound output interface 2012-03-22 03:15:01 +00:00			`virtual std::vector<std::string> enumerate();`
Add an option to select and enable HRTF 2015-12-04 20:54:41 +00:00			`virtual void init(const std::string &devname=std::string());`
Rename some more sound class member variables and functions 2012-03-18 18:30:53 +00:00			`virtual void deinit();`
Add a skeleton output classs using OpenAL 2012-03-17 05:12:17 +00:00
Add an option to select and enable HRTF 2015-12-04 20:54:41 +00:00			`virtual std::vector<std::string> enumerateHrtf();`
			`virtual void enableHrtf(const std::string &hrtfname, bool auto_enable);`
			`virtual void disableHrtf();`

Stream voice clips Voices tend to be a bit long, and not individually replayed often. So it's better to stream them instead of loading theminto a sound buffer. The loudness data is very small, though, so that can be kept buffered indefinitely. 2015-11-24 04:13:24 +00:00			`virtual Sound_Handle loadSound(const std::string &fname);`
Load the sound as needed and pass it directly to the play methods This breaks say sounds, loudness handling, and the cache limit. Fixes are forthcoming. 2015-11-23 09:01:20 +00:00			`virtual void unloadSound(Sound_Handle data);`
Limit the sound buffer cache to 15MB 2015-11-23 14:52:37 +00:00			`virtual size_t getSoundDataSize(Sound_Handle data) const;`
Load the sound as needed and pass it directly to the play methods This breaks say sounds, loudness handling, and the cache limit. Fixes are forthcoming. 2015-11-23 09:01:20 +00:00
Use a premade Sound object for the output's playSound functions 2015-12-02 14:35:35 +00:00			`virtual void playSound(MWBase::SoundPtr sound, Sound_Handle data, float offset);`
			`virtual void playSound3D(MWBase::SoundPtr sound, Sound_Handle data, float offset);`
Rename stopSound/stopStream to finishSound/finishStream Since they're also used to clean up output resources, not just stopping. 2015-12-11 23:13:14 +00:00			`virtual void finishSound(MWBase::SoundPtr sound);`
Avoid inheriting from Sound for sound types 2015-11-30 13:42:51 +00:00			`virtual bool isSoundPlaying(MWBase::SoundPtr sound);`
Update sound and stream parameters 2015-11-30 22:34:14 +00:00			`virtual void updateSound(MWBase::SoundPtr sound);`
Avoid inheriting from Sound for sound types 2015-11-30 13:42:51 +00:00
Use a premade SoundStream object for the output's streamSound functions 2015-12-02 16:04:30 +00:00			`virtual void streamSound(DecoderPtr decoder, MWBase::SoundStreamPtr sound);`
Don't analyze the loudness for sounds that don't need it 2016-06-27 19:37:02 +00:00			`virtual void streamSound3D(DecoderPtr decoder, MWBase::SoundStreamPtr sound, bool getLoudnessData);`
Rename stopSound/stopStream to finishSound/finishStream Since they're also used to clean up output resources, not just stopping. 2015-12-11 23:13:14 +00:00			`virtual void finishStream(MWBase::SoundStreamPtr sound);`
Use a separate type for streams They're basically the same, but it's to help avoid accidents with passing non- streaming sounds to the stream functions, or vice-versa. 2015-11-30 15:32:42 +00:00			`virtual double getStreamDelay(MWBase::SoundStreamPtr sound);`
			`virtual double getStreamOffset(MWBase::SoundStreamPtr sound);`
Analyze the loudness data as the stream is decoded for playback Instead of getting the loudness data for the whole file in advance, we now get it piece by piece as the sound is streamed. The benefit is that we need to decode the audio just once instead of twice. We no longer need to rewind() the stream when the first decoding is done, this should hopefully fix bug #3453 . 2016-06-27 18:54:42 +00:00			`virtual float getStreamLoudness(MWBase::SoundStreamPtr sound);`
Use a separate type for streams They're basically the same, but it's to help avoid accidents with passing non- streaming sounds to the stream functions, or vice-versa. 2015-11-30 15:32:42 +00:00			`virtual bool isStreamPlaying(MWBase::SoundStreamPtr sound);`
Update sound and stream parameters 2015-11-30 22:34:14 +00:00			`virtual void updateStream(MWBase::SoundStreamPtr sound);`
Add a function to stream sounds 2012-03-17 09:55:08 +00:00
Batch update changes together, when possible Certain OpenAL implementations, including Rapture3D, Creative's hardware drivers, and more recent versions of OpenAL Soft, can batch together changes so that they all occur at once, avoiding potential discontinuities with one sound being changed before another, or the listeenr being changed before sounds are. On other implementaitons, this is a no-op and maintains existing behavior. 2015-11-25 04:37:38 +00:00			`virtual void startUpdate();`
			`virtual void finishUpdate();`

Readded sound listener 2015-05-12 17:02:56 +00:00			`virtual void updateListener(const osg::Vec3f &pos, const osg::Vec3f &atdir, const osg::Vec3f &updir, Environment env);`
Add a function to update the sound listener 2012-03-17 11:22:54 +00:00
Allow pausing only certain types of sounds 2012-12-18 12:19:35 +00:00			`virtual void pauseSounds(int types);`
			`virtual void resumeSounds(int types);`
Add methods to pause and stop all playing sounds (and music) 2012-12-12 10:33:12 +00:00
Add a skeleton output classs using OpenAL 2012-03-17 05:12:17 +00:00			`OpenAL_Output(SoundManager &mgr);`
			`virtual ~OpenAL_Output();`
			`};`
			`#ifndef DEFAULT_OUTPUT`
Fix DEFAULT_OUTPUT declaration 2012-12-18 18:22:40 +00:00			`#define DEFAULT_OUTPUT(x) ::MWSound::OpenAL_Output((x))`
Add a skeleton output classs using OpenAL 2012-03-17 05:12:17 +00:00			`#endif`
disabling gcc extensions 2012-10-09 15:10:25 +00:00			`}`
Add a skeleton output classs using OpenAL 2012-03-17 05:12:17 +00:00
			`#endif`