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 "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;

    uint64_t m_synchronizerPosition{0};
    int m_synchronizerState{0};
 
    // 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 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);
 
    virtual void seekSynchronizer(double time);
    virtual double getSynchronizerPosition();
    virtual void playSynchronizer();
    virtual void stopSynchronizer();
    virtual void setSyncCallback(syncFunction function, void* data);
    virtual int isSynchronizerPlaying();
};
 
AUD_NAMESPACE_END