OpenALDevice.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
 
#ifdef OPENAL_PLUGIN
#define AUD_BUILD_PLUGIN
#endif
 
#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 <al.h>
#include <alc.h>
#include <list>
#include <mutex>
#include <thread>
#include <string>
 
AUD_NAMESPACE_BEGIN
 
class AUD_PLUGIN_API OpenALDevice : public IDevice, public I3DDevice
{
private:
    class OpenALHandle : public IHandle, public I3DHandle
    {
    private:
        friend class OpenALDevice;
 
        static const int CYCLE_BUFFERS = 3;
 
        bool m_isBuffered;
 
        std::shared_ptr<IReader> m_reader;
 
        bool m_keep;
 
        ALenum m_format;
 
        ALuint m_source;
 
        ALuint m_buffers[CYCLE_BUFFERS];
 
        int m_current;
 
        bool m_eos;
 
        int m_loopcount;
 
        stopCallback m_stop;
 
        void* m_stop_data;
 
        Quaternion m_orientation;
 
        Status m_status;
 
        OpenALDevice* m_device;
 
        AUD_LOCAL bool pause(bool keep);
 
        // delete copy constructor and operator=
        OpenALHandle(const OpenALHandle&) = delete;
        OpenALHandle& operator=(const OpenALHandle&) = delete;
 
    public:
 
        OpenALHandle(OpenALDevice* device, ALenum format, std::shared_ptr<IReader> reader, bool keep);
 
        virtual ~OpenALHandle() {}
        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 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);
    };
 
    ALCdevice* m_device;
 
    ALCcontext* m_context;
 
    DeviceSpecs m_specs;
 
    bool m_useMC;
 
    std::list<std::shared_ptr<OpenALHandle> > m_playingSounds;
 
    std::list<std::shared_ptr<OpenALHandle> > m_pausedSounds;
 
    std::recursive_mutex m_mutex;
 
    std::thread m_thread;
 
    bool m_playing;
 
    int m_buffersize;
 
    Buffer m_buffer;
 
    Quaternion m_orientation;
 
    DefaultSynchronizer m_synchronizer;
 
    AUD_LOCAL void start();
 
    AUD_LOCAL void updateStreams();
 
    AUD_LOCAL bool getFormat(ALenum &format, Specs specs);
 
    // delete copy constructor and operator=
    OpenALDevice(const OpenALDevice&) = delete;
    OpenALDevice& operator=(const OpenALDevice&) = delete;
 
public:
    OpenALDevice(DeviceSpecs specs, int buffersize = AUD_DEFAULT_BUFFER_SIZE, std::string name = "");
 
    virtual ~OpenALDevice();
 
    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);
 
    static std::list<std::string> getDeviceNames();
 
    static void registerPlugin();
};
 
AUD_NAMESPACE_END