soundemitter.h

/***************************************************************************
 *   Copyright (C) 2005-2011 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          *
 ***************************************************************************/

#ifndef FIFE_SOUNDEMITTER_H_
#define FIFE_SOUNDEMITTER_H_

// Standard C++ library includes

// Platform specific includes

// 3rd party library includes
#include <boost/function.hpp>

// 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/time/timeevent.h"

#include "soundclip.h"

namespace FIFE {

    class SoundManager;

    class SoundEmitter : private TimeEvent {
    public:
        typedef boost::function0<void> type_callback;

        SoundEmitter(SoundManager* manager, uint32_t uid);
        ~SoundEmitter();

        uint32_t getId() const{
            return m_emitterid;
        }

        void setPositioning(bool relative) {
            alSourcei(m_source, AL_SOURCE_RELATIVE, relative ? AL_TRUE : AL_FALSE);
        }

        void setRolloff(float rolloff) {
            alSourcef (m_source, AL_ROLLOFF_FACTOR,  rolloff);
        }

        void setSoundClip(SoundClipPtr soundclip);

        SoundClipPtr getSoundClip() { return m_soundclip; };

        void setCallback(const type_callback& cb);

        void reset(bool defaultall = false);

        void release();

        void setLooping(bool loop);

        void play();

        void stop();

        void pause() {
            if (m_soundclip) {
                alSourcePause(m_source);
            }
        }

        void setGain(float gain) {
            alSourcef(m_source, AL_GAIN, gain);
        }

        float getGain() {
            float tmp;
            alGetSourcef(m_source, AL_GAIN, &tmp);
            return tmp;
        }

        bool isStereo() {
            if (m_soundclip) {
                return m_soundclip->getDecoder()->isStereo();
            }
            return false;
        }

        int16_t getBitResolution() {
            if (m_soundclip) {
                return m_soundclip->getDecoder()->getBitResolution();
            }
            return 0;
        }

        uint64_t getSampleRate() {
            if (m_soundclip) {
                return m_soundclip->getDecoder()->getSampleRate();
            }
            return 0;
        }

        uint64_t getDecodedLength() {
            if (m_soundclip) {
                return m_soundclip->getDecoder()->getDecodedLength();

            }
            return 0;
        }

        uint64_t getDuration() {
            if (m_soundclip) {
                double samplerate = static_cast<double>(getSampleRate()) / 1000.0;  //convert to milliseconds
                double bitres = static_cast<double>(getBitResolution());
                double size = static_cast<double>(getDecodedLength()) * 8.0;  //convert to bits
                double stereo = (isStereo() ? 2.0 : 1.0);
                double time = ( size / (samplerate * bitres) ) / stereo;

                return static_cast<uint64_t>(time);
            }
            return 0;
         }

        void setCursor(SoundPositionType type, float value);

        float getCursor(SoundPositionType type);

        void setPosition(float x, float y, float z) {
            alSource3f(m_source, AL_POSITION, x, y, z);
        }

        void setVelocity(float x, float y, float z) {
            alSource3f(m_source, AL_VELOCITY, x, y, z);
        }

    private:
        virtual void updateEvent(uint32_t time);

        void attachSoundClip();

        SoundManager*   m_manager;
        ALuint          m_source;           // The openAL-source
        SoundClipPtr    m_soundclip;    // the attached soundclip
        uint32_t    m_soundclipid;// id of the attached soundclip
        uint32_t    m_streamid;     // the id of the stream
        uint32_t    m_emitterid;    // the emitter-id
        bool            m_loop;             // loop?
        type_callback   m_callback;
    };
}

#endif