AUD_SoftwareDevice.h

Go to the documentation of this file.

/*
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * Copyright 2009-2011 Jörg Hermann Müller
 *
 * This file is part of AudaSpace.
 *
 * Audaspace 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 2 of the License, or
 * (at your option) any later version.
 *
 * AudaSpace 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 Audaspace; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * ***** END GPL LICENSE BLOCK *****
 */

#ifndef AUD_SOFTWAREDEVICE
#define AUD_SOFTWAREDEVICE

#include "AUD_IDevice.h"
#include "AUD_IHandle.h"
#include "AUD_I3DDevice.h"
#include "AUD_I3DHandle.h"
#include "AUD_Mixer.h"
#include "AUD_Buffer.h"
#include "AUD_PitchReader.h"
#include "AUD_ResampleReader.h"
#include "AUD_ChannelMapperReader.h"

#include <list>
#include <pthread.h>

class AUD_SoftwareDevice : public AUD_IDevice, public AUD_I3DDevice
{
protected:
    class AUD_SoftwareHandle : public AUD_IHandle, public AUD_I3DHandle
    {
    public:
        AUD_Reference<AUD_IReader> m_reader;

        AUD_Reference<AUD_PitchReader> m_pitch;

        AUD_Reference<AUD_ResampleReader> m_resampler;

        AUD_Reference<AUD_ChannelMapperReader> m_mapper;

        bool m_keep;

        float m_user_pitch;

        float m_user_volume;

        float m_user_pan;

        float m_volume;

        int m_loopcount;

        AUD_Vector3 m_location;

        AUD_Vector3 m_velocity;

        AUD_Quaternion m_orientation;

        bool m_relative;

        float m_volume_max;

        float m_volume_min;

        float m_distance_max;

        float m_distance_reference;

        float m_attenuation;

        float m_cone_angle_outer;

        float m_cone_angle_inner;

        float m_cone_volume_outer;

        int m_flags;

        stopCallback m_stop;

        void* m_stop_data;

        AUD_Status m_status;

        AUD_SoftwareDevice* m_device;

    public:

        AUD_SoftwareHandle(AUD_SoftwareDevice* device, AUD_Reference<AUD_IReader> reader, AUD_Reference<AUD_PitchReader> pitch, AUD_Reference<AUD_ResampleReader> resampler, AUD_Reference<AUD_ChannelMapperReader> mapper, bool keep);

        void update();

        void setSpecs(AUD_Specs specs);

        virtual ~AUD_SoftwareHandle() {}
        virtual bool pause();
        virtual bool resume();
        virtual bool stop();
        virtual bool getKeep();
        virtual bool setKeep(bool keep);
        virtual bool seek(float position);
        virtual float getPosition();
        virtual AUD_Status getStatus();
        virtual float getVolume();
        virtual bool setVolume(float volume);
        virtual float getPitch();
        virtual bool setPitch(float pitch);
        virtual int getLoopCount();
        virtual bool setLoopCount(int count);
        virtual bool setStopCallback(stopCallback callback = 0, void* data = 0);

        virtual AUD_Vector3 getSourceLocation();
        virtual bool setSourceLocation(const AUD_Vector3& location);
        virtual AUD_Vector3 getSourceVelocity();
        virtual bool setSourceVelocity(const AUD_Vector3& velocity);
        virtual AUD_Quaternion getSourceOrientation();
        virtual bool setSourceOrientation(const AUD_Quaternion& orientation);
        virtual bool isRelative();
        virtual bool setRelative(bool relative);
        virtual float getVolumeMaximum();
        virtual bool setVolumeMaximum(float volume);
        virtual float getVolumeMinimum();
        virtual bool setVolumeMinimum(float volume);
        virtual float getDistanceMaximum();
        virtual bool setDistanceMaximum(float distance);
        virtual float getDistanceReference();
        virtual bool setDistanceReference(float distance);
        virtual float getAttenuation();
        virtual bool setAttenuation(float factor);
        virtual float getConeAngleOuter();
        virtual bool setConeAngleOuter(float angle);
        virtual float getConeAngleInner();
        virtual bool setConeAngleInner(float angle);
        virtual float getConeVolumeOuter();
        virtual bool setConeVolumeOuter(float volume);
    };

    typedef std::list<AUD_Reference<AUD_SoftwareHandle> >::iterator AUD_HandleIterator;

    AUD_DeviceSpecs m_specs;

    AUD_Reference<AUD_Mixer> m_mixer;

    bool m_quality;

    void create();

    void destroy();

    void mix(data_t* buffer, int length);

    virtual void playing(bool playing)=0;

    void setSpecs(AUD_Specs specs);

private:
    AUD_Buffer m_buffer;

    std::list<AUD_Reference<AUD_SoftwareHandle> > m_playingSounds;

    std::list<AUD_Reference<AUD_SoftwareHandle> > m_pausedSounds;

    bool m_playback;

    pthread_mutex_t m_mutex;

    float m_volume;

    AUD_Vector3 m_location;

    AUD_Vector3 m_velocity;

    AUD_Quaternion m_orientation;

    float m_speed_of_sound;

    float m_doppler_factor;

    AUD_DistanceModel m_distance_model;

    int m_flags;

public:

    static void setPanning(AUD_IHandle* handle, float pan);

    void setQuality(bool quality);

    virtual AUD_DeviceSpecs getSpecs() const;
    virtual AUD_Reference<AUD_IHandle> play(AUD_Reference<AUD_IReader> reader, bool keep = false);
    virtual AUD_Reference<AUD_IHandle> play(AUD_Reference<AUD_IFactory> factory, bool keep = false);
    virtual void stopAll();
    virtual void lock();
    virtual void unlock();
    virtual float getVolume() const;
    virtual void setVolume(float volume);

    virtual AUD_Vector3 getListenerLocation() const;
    virtual void setListenerLocation(const AUD_Vector3& location);
    virtual AUD_Vector3 getListenerVelocity() const;
    virtual void setListenerVelocity(const AUD_Vector3& velocity);
    virtual AUD_Quaternion getListenerOrientation() const;
    virtual void setListenerOrientation(const AUD_Quaternion& orientation);
    virtual float getSpeedOfSound() const;
    virtual void setSpeedOfSound(float speed);
    virtual float getDopplerFactor() const;
    virtual void setDopplerFactor(float factor);
    virtual AUD_DistanceModel getDistanceModel() const;
    virtual void setDistanceModel(AUD_DistanceModel model);
};

#endif //AUD_SOFTWAREDEVICE