svn merge -r 31145:31210 https://svn.blender.org/svnroot/bf-blender/trunk/blender
[blender.git] / intern / audaspace / OpenAL / AUD_OpenALDevice.h
1 /*
2  * $Id$
3  *
4  * ***** BEGIN LGPL LICENSE BLOCK *****
5  *
6  * Copyright 2009 Jörg Hermann Müller
7  *
8  * This file is part of AudaSpace.
9  *
10  * AudaSpace is free software: you can redistribute it and/or modify
11  * it under the terms of the GNU Lesser General Public License as published by
12  * the Free Software Foundation, either version 3 of the License, or
13  * (at your option) any later version.
14  *
15  * AudaSpace is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public License
21  * along with AudaSpace.  If not, see <http://www.gnu.org/licenses/>.
22  *
23  * ***** END LGPL LICENSE BLOCK *****
24  */
25
26 #ifndef AUD_OPENALDEVICE
27 #define AUD_OPENALDEVICE
28
29 #include "AUD_IDevice.h"
30 #include "AUD_I3DDevice.h"
31 struct AUD_OpenALHandle;
32 struct AUD_OpenALBufferedFactory;
33
34 #include <AL/al.h>
35 #include <AL/alc.h>
36 #include <list>
37 #include <pthread.h>
38
39 /**
40  * This device plays through OpenAL.
41  */
42 class AUD_OpenALDevice : public AUD_IDevice, public AUD_I3DDevice
43 {
44 private:
45         /**
46          * The OpenAL device handle.
47          */
48         ALCdevice* m_device;
49
50         /**
51          * The OpenAL context.
52          */
53         ALCcontext* m_context;
54
55         /**
56          * The specification of the device.
57          */
58         AUD_DeviceSpecs m_specs;
59
60         /**
61          * Whether the device has the AL_EXT_MCFORMATS extension.
62          */
63         bool m_useMC;
64
65         /**
66          * The list of sounds that are currently playing.
67          */
68         std::list<AUD_OpenALHandle*>* m_playingSounds;
69
70         /**
71          * The list of sounds that are currently paused.
72          */
73         std::list<AUD_OpenALHandle*>* m_pausedSounds;
74
75         /**
76          * The list of buffered factories.
77          */
78         std::list<AUD_OpenALBufferedFactory*>* m_bufferedFactories;
79
80         /**
81          * The mutex for locking.
82          */
83         pthread_mutex_t m_mutex;
84
85         /**
86          * The streaming thread.
87          */
88         pthread_t m_thread;
89
90         /**
91          * The condition for streaming thread wakeup.
92          */
93         bool m_playing;
94
95         /**
96          * Buffer size.
97          */
98         int m_buffersize;
99
100         /**
101          * Starts the streaming thread.
102          */
103         void start();
104
105         /**
106          * Checks if a handle is valid.
107          * \param handle The handle to check.
108          * \return Whether the handle is valid.
109          */
110         bool isValid(AUD_Handle* handle);
111
112         /**
113          * Gets the format according to the specs.
114          * \param format The variable to put the format into.
115          * \param specs The specs to read the channel count from.
116          * \return Whether the format is valid or not.
117          */
118         bool getFormat(ALenum &format, AUD_Specs specs);
119
120         // hide copy constructor and operator=
121         AUD_OpenALDevice(const AUD_OpenALDevice&);
122         AUD_OpenALDevice& operator=(const AUD_OpenALDevice&);
123
124 public:
125         /**
126          * Opens the OpenAL audio device for playback.
127          * \param specs The wanted audio specification.
128          * \param buffersize The size of the internal buffer.
129          * \note The specification really used for opening the device may differ.
130          * \note The buffersize will be multiplicated by three for this device.
131          * \exception AUD_Exception Thrown if the audio device cannot be opened.
132          */
133         AUD_OpenALDevice(AUD_DeviceSpecs specs,
134                                          int buffersize = AUD_DEFAULT_BUFFER_SIZE);
135
136         /**
137          * Streaming thread main function.
138          */
139         void updateStreams();
140
141         virtual ~AUD_OpenALDevice();
142
143         virtual AUD_DeviceSpecs getSpecs() const;
144         virtual AUD_Handle* play(AUD_IFactory* factory, bool keep = false);
145         virtual bool pause(AUD_Handle* handle);
146         virtual bool resume(AUD_Handle* handle);
147         virtual bool stop(AUD_Handle* handle);
148         virtual bool getKeep(AUD_Handle* handle);
149         virtual bool setKeep(AUD_Handle* handle, bool keep);
150         virtual bool seek(AUD_Handle* handle, float position);
151         virtual float getPosition(AUD_Handle* handle);
152         virtual AUD_Status getStatus(AUD_Handle* handle);
153         virtual void lock();
154         virtual void unlock();
155         virtual float getVolume() const;
156         virtual void setVolume(float volume);
157         virtual float getVolume(AUD_Handle* handle);
158         virtual bool setVolume(AUD_Handle* handle, float volume);
159         virtual float getPitch(AUD_Handle* handle);
160         virtual bool setPitch(AUD_Handle* handle, float pitch);
161         virtual int getLoopCount(AUD_Handle* handle);
162         virtual bool setLoopCount(AUD_Handle* handle, int count);
163         virtual bool setStopCallback(AUD_Handle* handle, stopCallback callback = NULL, void* data = NULL);
164
165         virtual AUD_Vector3 getListenerLocation() const;
166         virtual void setListenerLocation(const AUD_Vector3& location);
167         virtual AUD_Vector3 getListenerVelocity() const;
168         virtual void setListenerVelocity(const AUD_Vector3& velocity);
169         virtual AUD_Quaternion getListenerOrientation() const;
170         virtual void setListenerOrientation(const AUD_Quaternion& orientation);
171         virtual float getSpeedOfSound() const;
172         virtual void setSpeedOfSound(float speed);
173         virtual float getDopplerFactor() const;
174         virtual void setDopplerFactor(float factor);
175         virtual AUD_DistanceModel getDistanceModel() const;
176         virtual void setDistanceModel(AUD_DistanceModel model);
177         virtual AUD_Vector3 getSourceLocation(AUD_Handle* handle);
178         virtual bool setSourceLocation(AUD_Handle* handle, const AUD_Vector3& location);
179         virtual AUD_Vector3 getSourceVelocity(AUD_Handle* handle);
180         virtual bool setSourceVelocity(AUD_Handle* handle, const AUD_Vector3& velocity);
181         virtual AUD_Quaternion getSourceOrientation(AUD_Handle* handle);
182         virtual bool setSourceOrientation(AUD_Handle* handle, const AUD_Quaternion& orientation);
183         virtual bool isRelative(AUD_Handle* handle);
184         virtual bool setRelative(AUD_Handle* handle, bool relative);
185         virtual float getVolumeMaximum(AUD_Handle* handle);
186         virtual bool setVolumeMaximum(AUD_Handle* handle, float volume);
187         virtual float getVolumeMinimum(AUD_Handle* handle);
188         virtual bool setVolumeMinimum(AUD_Handle* handle, float volume);
189         virtual float getDistanceMaximum(AUD_Handle* handle);
190         virtual bool setDistanceMaximum(AUD_Handle* handle, float distance);
191         virtual float getDistanceReference(AUD_Handle* handle);
192         virtual bool setDistanceReference(AUD_Handle* handle, float distance);
193         virtual float getAttenuation(AUD_Handle* handle);
194         virtual bool setAttenuation(AUD_Handle* handle, float factor);
195         virtual float getConeAngleOuter(AUD_Handle* handle);
196         virtual bool setConeAngleOuter(AUD_Handle* handle, float angle);
197         virtual float getConeAngleInner(AUD_Handle* handle);
198         virtual bool setConeAngleInner(AUD_Handle* handle, float angle);
199         virtual float getConeVolumeOuter(AUD_Handle* handle);
200         virtual bool setConeVolumeOuter(AUD_Handle* handle, float volume);
201 };
202
203 #endif //AUD_OPENALDEVICE