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

        ALint m_relative;

        OpenALDevice* m_device;

        AUD_LOCAL bool pause(bool keep);

        AUD_LOCAL bool reinitialize();

        // 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(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);
    };

    ALCdevice* m_device;

    ALCcontext* m_context;

    DeviceSpecs m_specs;

    std::string m_name;

    bool m_useMC;

    bool m_checkDisconnect;

    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;

    uint64_t m_synchronizerPosition{0};
    std::shared_ptr<IHandle> m_silenceHandle;

    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, const 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 void seekSynchronizer(double time);
    virtual double getSynchronizerPosition();
    virtual void playSynchronizer();
    virtual void stopSynchronizer();
    virtual void setSyncCallback(syncFunction function, void* data);
    virtual int isSynchronizerPlaying();

    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