SoftwareDevice.h

Go to the documentation of this file.

/*******************************************************************************
 * Copyright 2009-2016 Jörg Müller
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************/
 
#pragma once
 
#include "devices/IDevice.h"
#include "devices/IHandle.h"
#include "devices/I3DDevice.h"
#include "devices/I3DHandle.h"
#include "devices/DefaultSynchronizer.h"
#include "util/Buffer.h"
 
#include <list>
#include <mutex>
 
AUD_NAMESPACE_BEGIN
 
class Mixer;
class PitchReader;
class ResampleReader;
class ChannelMapperReader;
 
class AUD_API SoftwareDevice : public IDevice, public I3DDevice
{
protected:
    class AUD_API SoftwareHandle : public IHandle, public I3DHandle
    {
    private:
        // delete copy constructor and operator=
        SoftwareHandle(const SoftwareHandle&) = delete;
        SoftwareHandle& operator=(const SoftwareHandle&) = delete;
 
    public:
        std::shared_ptr<IReader> m_reader;
 
        std::shared_ptr<PitchReader> m_pitch;
 
        std::shared_ptr<ResampleReader> m_resampler;
 
        std::shared_ptr<ChannelMapperReader> m_mapper;
 
        bool m_first_reading;
 
        bool m_keep;
 
        float m_user_pitch;
 
        float m_user_volume;
 
        float m_user_pan;
 
        float m_volume;
 
        float m_old_volume;
 
        int m_loopcount;
 
        Vector3 m_location;
 
        Vector3 m_velocity;
 
        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;
 
        Status m_status;
 
        SoftwareDevice* m_device;
 
        bool pause(bool keep);
 
    public:
        SoftwareHandle(SoftwareDevice* device, std::shared_ptr<IReader> reader, std::shared_ptr<PitchReader> pitch, std::shared_ptr<ResampleReader> resampler, std::shared_ptr<ChannelMapperReader> mapper, bool keep);
 
        void update();
 
        void setSpecs(Specs specs);
 
        virtual ~SoftwareHandle() {}
        virtual bool pause();
        virtual bool resume();
        virtual bool stop();
        virtual bool getKeep();
        virtual bool setKeep(bool keep);
        virtual bool seek(double position);
        virtual double getPosition();
        virtual 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 Vector3 getLocation();
        virtual bool setLocation(const Vector3& location);
        virtual Vector3 getVelocity();
        virtual bool setVelocity(const Vector3& velocity);
        virtual Quaternion getOrientation();
        virtual bool setOrientation(const 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);
    };
 
    DeviceSpecs m_specs;
 
    std::shared_ptr<Mixer> m_mixer;
 
    ResampleQuality m_quality;
 
    void create();
 
    void destroy();
 
    void mix(data_t* buffer, int length);
 
    virtual void playing(bool playing)=0;
 
    void setSpecs(Specs specs);
 
    void setSpecs(DeviceSpecs specs);
 
    SoftwareDevice();
 
private:
    Buffer m_buffer;
 
    std::list<std::shared_ptr<SoftwareHandle> > m_playingSounds;
 
    std::list<std::shared_ptr<SoftwareHandle> > m_pausedSounds;
 
    bool m_playback;
 
    std::recursive_mutex m_mutex;
 
    float m_volume;
 
    Vector3 m_location;
 
    Vector3 m_velocity;
 
    Quaternion m_orientation;
 
    float m_speed_of_sound;
 
    float m_doppler_factor;
 
    DistanceModel m_distance_model;
 
    int m_flags;
 
    DefaultSynchronizer m_synchronizer;
 
    // delete copy constructor and operator=
    SoftwareDevice(const SoftwareDevice&) = delete;
    SoftwareDevice& operator=(const SoftwareDevice&) = delete;
 
public:
 
    static void setPanning(IHandle* handle, float pan);
 
    void setQuality(ResampleQuality quality);
 
    virtual DeviceSpecs getSpecs() const;
    virtual std::shared_ptr<IHandle> play(std::shared_ptr<IReader> reader, bool keep = false);
    virtual std::shared_ptr<IHandle> play(std::shared_ptr<ISound> sound, bool keep = false);
    virtual void stopAll();
    virtual void lock();
    virtual void unlock();
    virtual float getVolume() const;
    virtual void setVolume(float volume);
    virtual ISynchronizer* getSynchronizer();
 
    virtual Vector3 getListenerLocation() const;
    virtual void setListenerLocation(const Vector3& location);
    virtual Vector3 getListenerVelocity() const;
    virtual void setListenerVelocity(const Vector3& velocity);
    virtual Quaternion getListenerOrientation() const;
    virtual void setListenerOrientation(const Quaternion& orientation);
    virtual float getSpeedOfSound() const;
    virtual void setSpeedOfSound(float speed);
    virtual float getDopplerFactor() const;
    virtual void setDopplerFactor(float factor);
    virtual DistanceModel getDistanceModel() const;
    virtual void setDistanceModel(DistanceModel model);
};
 
AUD_NAMESPACE_END