sound.h

Go to the documentation of this file.

/* xoreos - A reimplementation of BioWare's Aurora engine
 *
 * xoreos is the legal property of its developers, whose names
 * can be found in the AUTHORS file distributed with this source
 * distribution.
 *
 * xoreos is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or (at your option) any later version.
 *
 * xoreos 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with xoreos. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef SOUND_SOUND_H
#define SOUND_SOUND_H

// Mac OS X has to have this set up separately because of the include
// path for the OpenAL framework.
#ifdef MACOSX
    #include <OpenAL/al.h>
    #include <OpenAL/alc.h>
#else
    #include <AL/al.h>
    #include <AL/alc.h>
#endif

#include <list>
#include <map>

#include "src/common/types.h"
#include "src/common/scopedptr.h"
#include "src/common/disposableptr.h"
#include "src/common/singleton.h"
#include "src/common/thread.h"
#include "src/common/mutex.h"
#include "src/common/ustring.h"

#include "src/sound/types.h"

namespace Common {
    class SeekableReadStream;
}

namespace Sound {

class AudioStream;

class SoundManager : public Common::Singleton<SoundManager>, public Common::Thread {
public:
    SoundManager();
    ~SoundManager();

    void init();
    void deinit();

    bool ready() const;


    void triggerUpdate();


    // .--- Channel status
    bool isValidChannel(const ChannelHandle &handle) const;

    bool isPlaying(const ChannelHandle &handle);
    bool isPaused(const ChannelHandle &handle);

    uint64 getChannelSamplesPlayed(const ChannelHandle &handle);
    uint64 getChannelDurationPlayed(const ChannelHandle &handle);
    // '---

    // .--- Playing sounds
    ChannelHandle playSoundFile(Common::SeekableReadStream *wavStream,
                                SoundType type, bool loop = false);

    ChannelHandle playAudioStream(AudioStream *audStream,
                                  SoundType type, bool disposeAfterUse = true);
    // '---

    // .--- Starting/Pausing/Stopping channels
    void startChannel(ChannelHandle &handle);

    void pauseChannel(ChannelHandle &handle, bool pause);
    void pauseChannel(ChannelHandle &handle);

    void stopChannel(ChannelHandle &handle);
    // '---

    // .--- Pausing/Stopping all channels
    void pauseAll(bool pause);

    void stopAll();
    // '---


    // .--- Listener properties
    void setListenerGain(float gain);
    void setListenerPosition(float x, float y, float z);
    void setListenerOrientation(float dirX, float dirY, float dirZ, float upX, float upY, float upZ);
    // '---

    // .--- Channel properties
    void setChannelPosition(const ChannelHandle &handle, float x, float y, float z);

    void getChannelPosition(const ChannelHandle &handle, float &x, float &y, float &z);

    void setChannelGain(const ChannelHandle &handle, float gain);

    void setChannelPitch(const ChannelHandle &handle, float pitch);

    void setChannelRelative(const ChannelHandle &handle, bool relative);

    void setChannelDistance(const ChannelHandle &handle, float minDistance, float maxDistance);
    // '---

    // .--- Type properties
    void setTypeGain(SoundType type, float gain);
    // '---

    // .--- Utility methods
    static AudioStream *makeAudioStream(Common::SeekableReadStream *stream);

    Common::UString formatChannel(const ChannelHandle &handle) const;
    // '---

private:
    static const size_t kChannelCount = 65535; 

    struct Channel;
    typedef std::list<Channel *> TypeList;

    struct Type {
        float    gain; 
        TypeList list; 
    };

    struct Channel {
        uint32 id;    
        size_t index; 

        ALint state; 

        Common::DisposablePtr<AudioStream> stream;  

        ALuint source; 

        std::list<ALuint> buffers;     
        std::list<ALuint> freeBuffers; 

        std::map<ALuint, ALsizei> bufferSize; 

        SoundType type;            
        TypeList::iterator typeIt; 

        uint64 finishedBuffers;

        float gain; 

        Channel(uint32 i, size_t idx, SoundType t, const TypeList::iterator &ti, AudioStream *s, bool d);
    };

    bool _ready; 

    bool _hasSound; 

    bool _hasMultiChannel; 
    ALenum _format51; 

    Common::ScopedPtr<Channel> _channels[kChannelCount]; 
    Type _types[kSoundTypeMAX]; 

    uint32 _curID; 

    Common::Mutex _mutex;

    Common::Condition _needUpdate;

    ALCdevice *_dev;
    ALCcontext *_ctx;

    void checkReady();

    void update();

    ChannelHandle newChannel();

    void bufferData(Channel &channel);
    void bufferData(size_t channel);

    bool isPlaying(size_t channel) const;

    void pauseChannel(Channel *channel, bool pause);
    void pauseChannel(Channel *channe);

    void freeChannel(ChannelHandle &handle);
    void freeChannel(size_t channel);

    const Channel *getChannel(const ChannelHandle &handle) const;
    Channel *getChannel(const ChannelHandle &handle);

    void threadMethod();

    bool fillBuffer(const Channel &channel, ALuint alBuffer,
                    AudioStream *stream, ALsizei &bufferedSize) const;

    Common::UString formatChannel(const Channel *channel) const;
};

} // End of namespace Sound

#define SoundMan Sound::SoundManager::instance()

#endif // SOUND_SOUND_H