Merge with trunk r37757.
[blender.git] / intern / audaspace / OpenAL / AUD_OpenALDevice.h
index cb8c83ab810e247e5bfdf972d543a9e997bfc9aa..ea4f9ca1ea818667ec058d567c82db12add38886 100644 (file)
@@ -1,36 +1,43 @@
 /*
  * $Id$
  *
- * ***** BEGIN LGPL LICENSE BLOCK *****
+ * ***** BEGIN GPL LICENSE BLOCK *****
  *
- * Copyright 2009 Jörg Hermann Müller
+ * 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 Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
+ * 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 Lesser General Public License for more details.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with AudaSpace.  If not, see <http://www.gnu.org/licenses/>.
+ * 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 LGPL LICENSE BLOCK *****
+ * ***** END GPL LICENSE BLOCK *****
  */
 
+/** \file audaspace/OpenAL/AUD_OpenALDevice.h
+ *  \ingroup audopenal
+ */
+
+
 #ifndef AUD_OPENALDEVICE
 #define AUD_OPENALDEVICE
 
 #include "AUD_IDevice.h"
+#include "AUD_IHandle.h"
 #include "AUD_I3DDevice.h"
-struct AUD_OpenALHandle;
-struct AUD_OpenALBufferedFactory;
-class AUD_ConverterFactory;
+#include "AUD_I3DHandle.h"
+#include "AUD_Buffer.h"
+//struct AUD_OpenALBufferedFactory;
 
 #include <AL/al.h>
 #include <AL/alc.h>
@@ -43,6 +50,100 @@ class AUD_ConverterFactory;
 class AUD_OpenALDevice : public AUD_IDevice, public AUD_I3DDevice
 {
 private:
+       /// Saves the data for playback.
+       class AUD_OpenALHandle : public AUD_IHandle, public AUD_I3DHandle
+       {
+       public:
+               static const int CYCLE_BUFFERS = 3;
+
+               /// Whether it's a buffered or a streamed source.
+               bool m_isBuffered;
+
+               /// The reader source.
+               AUD_Reference<AUD_IReader> m_reader;
+
+               /// Whether to keep the source if end of it is reached.
+               bool m_keep;
+
+               /// OpenAL sample format.
+               ALenum m_format;
+
+               /// OpenAL source.
+               ALuint m_source;
+
+               /// OpenAL buffers.
+               ALuint m_buffers[CYCLE_BUFFERS];
+
+               /// The first buffer to be read next.
+               int m_current;
+
+               /// Whether the stream doesn't return any more data.
+               bool m_eos;
+
+               /// The loop count of the source.
+               int m_loopcount;
+
+               /// The stop callback.
+               stopCallback m_stop;
+
+               /// Stop callback data.
+               void* m_stop_data;
+
+               /// Current status of the handle
+               AUD_Status m_status;
+
+               /// Own device.
+               AUD_OpenALDevice* m_device;
+
+       public:
+
+               AUD_OpenALHandle(AUD_OpenALDevice* device, ALenum format, AUD_Reference<AUD_IReader> reader, bool keep);
+
+               virtual ~AUD_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 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_OpenALHandle> >::iterator AUD_HandleIterator;
+
        /**
         * The OpenAL device handle.
         */
@@ -63,25 +164,20 @@ private:
         */
        bool m_useMC;
 
-       /**
-       * The converter factory for readers with wrong input format.
-       */
-       AUD_ConverterFactory* m_converter;
-
        /**
         * The list of sounds that are currently playing.
         */
-       std::list<AUD_OpenALHandle*>* m_playingSounds;
+       std::list<AUD_Reference<AUD_OpenALHandle> > m_playingSounds;
 
        /**
         * The list of sounds that are currently paused.
         */
-       std::list<AUD_OpenALHandle*>* m_pausedSounds;
+       std::list<AUD_Reference<AUD_OpenALHandle> > m_pausedSounds;
 
        /**
         * The list of buffered factories.
         */
-       std::list<AUD_OpenALBufferedFactory*>* m_bufferedFactories;
+       //std::list<AUD_OpenALBufferedFactory*>* m_bufferedFactories;
 
        /**
         * The mutex for locking.
@@ -104,16 +200,14 @@ private:
        int m_buffersize;
 
        /**
-        * Starts the streaming thread.
+        * Device buffer.
         */
-       void start();
+       AUD_Buffer m_buffer;
 
        /**
-        * Checks if a handle is valid.
-        * \param handle The handle to check.
-        * \return Whether the handle is valid.
+        * Starts the streaming thread.
         */
-       bool isValid(AUD_Handle* handle);
+       void start();
 
        /**
         * Gets the format according to the specs.
@@ -123,6 +217,10 @@ private:
         */
        bool getFormat(ALenum &format, AUD_Specs specs);
 
+       // hide copy constructor and operator=
+       AUD_OpenALDevice(const AUD_OpenALDevice&);
+       AUD_OpenALDevice& operator=(const AUD_OpenALDevice&);
+
 public:
        /**
         * Opens the OpenAL audio device for playback.
@@ -142,31 +240,26 @@ public:
 
        virtual ~AUD_OpenALDevice();
 
-       virtual AUD_DeviceSpecs getSpecs();
-       virtual AUD_Handle* play(AUD_IFactory* factory, bool keep = false);
-       virtual bool pause(AUD_Handle* handle);
-       virtual bool resume(AUD_Handle* handle);
-       virtual bool stop(AUD_Handle* handle);
-       virtual bool setKeep(AUD_Handle* handle, bool keep);
-       virtual bool sendMessage(AUD_Handle* handle, AUD_Message &message);
-       virtual bool seek(AUD_Handle* handle, float position);
-       virtual float getPosition(AUD_Handle* handle);
-       virtual AUD_Status getStatus(AUD_Handle* handle);
+       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 lock();
        virtual void unlock();
-       virtual bool checkCapability(int capability);
-       virtual bool setCapability(int capability, void *value);
-       virtual bool getCapability(int capability, void *value);
-
-       virtual AUD_Handle* play3D(AUD_IFactory* factory, bool keep = false);
-       virtual bool updateListener(AUD_3DData &data);
-       virtual bool setSetting(AUD_3DSetting setting, float value);
-       virtual float getSetting(AUD_3DSetting setting);
-       virtual bool updateSource(AUD_Handle* handle, AUD_3DData &data);
-       virtual bool setSourceSetting(AUD_Handle* handle,
-                                                                 AUD_3DSourceSetting setting, float value);
-       virtual float getSourceSetting(AUD_Handle* handle,
-                                                                  AUD_3DSourceSetting setting);
+       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_OPENALDEVICE