svn merge -r39781:39792 https://svn.blender.org/svnroot/bf-blender/trunk/blender...
[blender-staging.git] / intern / audaspace / OpenAL / AUD_OpenALDevice.h
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * Copyright 2009-2011 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 General Public License as published by
12  * the Free Software Foundation; either version 2 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 General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with Audaspace; if not, write to the Free Software Foundation,
22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file audaspace/OpenAL/AUD_OpenALDevice.h
28  *  \ingroup audopenal
29  */
30
31
32 #ifndef AUD_OPENALDEVICE
33 #define AUD_OPENALDEVICE
34
35 #include "AUD_IDevice.h"
36 #include "AUD_IHandle.h"
37 #include "AUD_I3DDevice.h"
38 #include "AUD_I3DHandle.h"
39 #include "AUD_Buffer.h"
40 //struct AUD_OpenALBufferedFactory;
41
42 #include <AL/al.h>
43 #include <AL/alc.h>
44 #include <list>
45 #include <pthread.h>
46
47 /**
48  * This device plays through OpenAL.
49  */
50 class AUD_OpenALDevice : public AUD_IDevice, public AUD_I3DDevice
51 {
52 private:
53         /// Saves the data for playback.
54         class AUD_OpenALHandle : public AUD_IHandle, public AUD_I3DHandle
55         {
56         public:
57                 static const int CYCLE_BUFFERS = 3;
58
59                 /// Whether it's a buffered or a streamed source.
60                 bool m_isBuffered;
61
62                 /// The reader source.
63                 AUD_Reference<AUD_IReader> m_reader;
64
65                 /// Whether to keep the source if end of it is reached.
66                 bool m_keep;
67
68                 /// OpenAL sample format.
69                 ALenum m_format;
70
71                 /// OpenAL source.
72                 ALuint m_source;
73
74                 /// OpenAL buffers.
75                 ALuint m_buffers[CYCLE_BUFFERS];
76
77                 /// The first buffer to be read next.
78                 int m_current;
79
80                 /// Whether the stream doesn't return any more data.
81                 bool m_eos;
82
83                 /// The loop count of the source.
84                 int m_loopcount;
85
86                 /// The stop callback.
87                 stopCallback m_stop;
88
89                 /// Stop callback data.
90                 void* m_stop_data;
91
92                 /// Orientation.
93                 AUD_Quaternion m_orientation;
94
95                 /// Current status of the handle
96                 AUD_Status m_status;
97
98                 /// Own device.
99                 AUD_OpenALDevice* m_device;
100
101         public:
102
103                 /**
104                  * Creates a new OpenAL handle.
105                  * \param device The OpenAL device the handle belongs to.
106                  * \param format The AL format.
107                  * \param reader The reader this handle plays.
108                  * \param keep Whether to keep the handle alive when the reader ends.
109                  */
110                 AUD_OpenALHandle(AUD_OpenALDevice* device, ALenum format, AUD_Reference<AUD_IReader> reader, bool keep);
111
112                 virtual ~AUD_OpenALHandle() {}
113                 virtual bool pause();
114                 virtual bool resume();
115                 virtual bool stop();
116                 virtual bool getKeep();
117                 virtual bool setKeep(bool keep);
118                 virtual bool seek(float position);
119                 virtual float getPosition();
120                 virtual AUD_Status getStatus();
121                 virtual float getVolume();
122                 virtual bool setVolume(float volume);
123                 virtual float getPitch();
124                 virtual bool setPitch(float pitch);
125                 virtual int getLoopCount();
126                 virtual bool setLoopCount(int count);
127                 virtual bool setStopCallback(stopCallback callback = 0, void* data = 0);
128
129                 virtual AUD_Vector3 getSourceLocation();
130                 virtual bool setSourceLocation(const AUD_Vector3& location);
131                 virtual AUD_Vector3 getSourceVelocity();
132                 virtual bool setSourceVelocity(const AUD_Vector3& velocity);
133                 virtual AUD_Quaternion getSourceOrientation();
134                 virtual bool setSourceOrientation(const AUD_Quaternion& orientation);
135                 virtual bool isRelative();
136                 virtual bool setRelative(bool relative);
137                 virtual float getVolumeMaximum();
138                 virtual bool setVolumeMaximum(float volume);
139                 virtual float getVolumeMinimum();
140                 virtual bool setVolumeMinimum(float volume);
141                 virtual float getDistanceMaximum();
142                 virtual bool setDistanceMaximum(float distance);
143                 virtual float getDistanceReference();
144                 virtual bool setDistanceReference(float distance);
145                 virtual float getAttenuation();
146                 virtual bool setAttenuation(float factor);
147                 virtual float getConeAngleOuter();
148                 virtual bool setConeAngleOuter(float angle);
149                 virtual float getConeAngleInner();
150                 virtual bool setConeAngleInner(float angle);
151                 virtual float getConeVolumeOuter();
152                 virtual bool setConeVolumeOuter(float volume);
153         };
154
155         typedef std::list<AUD_Reference<AUD_OpenALHandle> >::iterator AUD_HandleIterator;
156
157         /**
158          * The OpenAL device handle.
159          */
160         ALCdevice* m_device;
161
162         /**
163          * The OpenAL context.
164          */
165         ALCcontext* m_context;
166
167         /**
168          * The specification of the device.
169          */
170         AUD_DeviceSpecs m_specs;
171
172         /**
173          * Whether the device has the AL_EXT_MCFORMATS extension.
174          */
175         bool m_useMC;
176
177         /**
178          * The list of sounds that are currently playing.
179          */
180         std::list<AUD_Reference<AUD_OpenALHandle> > m_playingSounds;
181
182         /**
183          * The list of sounds that are currently paused.
184          */
185         std::list<AUD_Reference<AUD_OpenALHandle> > m_pausedSounds;
186
187         /**
188          * The list of buffered factories.
189          */
190         //std::list<AUD_OpenALBufferedFactory*>* m_bufferedFactories;
191
192         /**
193          * The mutex for locking.
194          */
195         pthread_mutex_t m_mutex;
196
197         /**
198          * The streaming thread.
199          */
200         pthread_t m_thread;
201
202         /**
203          * The condition for streaming thread wakeup.
204          */
205         bool m_playing;
206
207         /**
208          * Buffer size.
209          */
210         int m_buffersize;
211
212         /**
213          * Device buffer.
214          */
215         AUD_Buffer m_buffer;
216
217         /**
218          * Orientation.
219          */
220         AUD_Quaternion m_orientation;
221
222         /**
223          * Starts the streaming thread.
224          * \param Whether the previous thread should be joined.
225          */
226         void start(bool join = true);
227
228         /**
229          * Gets the format according to the specs.
230          * \param format The variable to put the format into.
231          * \param specs The specs to read the channel count from.
232          * \return Whether the format is valid or not.
233          */
234         bool getFormat(ALenum &format, AUD_Specs specs);
235
236         // hide copy constructor and operator=
237         AUD_OpenALDevice(const AUD_OpenALDevice&);
238         AUD_OpenALDevice& operator=(const AUD_OpenALDevice&);
239
240 public:
241         /**
242          * Opens the OpenAL audio device for playback.
243          * \param specs The wanted audio specification.
244          * \param buffersize The size of the internal buffer.
245          * \note The specification really used for opening the device may differ.
246          * \note The buffersize will be multiplicated by three for this device.
247          * \exception AUD_Exception Thrown if the audio device cannot be opened.
248          */
249         AUD_OpenALDevice(AUD_DeviceSpecs specs,
250                                          int buffersize = AUD_DEFAULT_BUFFER_SIZE);
251
252         /**
253          * Streaming thread main function.
254          */
255         void updateStreams();
256
257         virtual ~AUD_OpenALDevice();
258
259         virtual AUD_DeviceSpecs getSpecs() const;
260         virtual AUD_Reference<AUD_IHandle> play(AUD_Reference<AUD_IReader> reader, bool keep = false);
261         virtual AUD_Reference<AUD_IHandle> play(AUD_Reference<AUD_IFactory> factory, bool keep = false);
262         virtual void stopAll();
263         virtual void lock();
264         virtual void unlock();
265         virtual float getVolume() const;
266         virtual void setVolume(float volume);
267
268         virtual AUD_Vector3 getListenerLocation() const;
269         virtual void setListenerLocation(const AUD_Vector3& location);
270         virtual AUD_Vector3 getListenerVelocity() const;
271         virtual void setListenerVelocity(const AUD_Vector3& velocity);
272         virtual AUD_Quaternion getListenerOrientation() const;
273         virtual void setListenerOrientation(const AUD_Quaternion& orientation);
274         virtual float getSpeedOfSound() const;
275         virtual void setSpeedOfSound(float speed);
276         virtual float getDopplerFactor() const;
277         virtual void setDopplerFactor(float factor);
278         virtual AUD_DistanceModel getDistanceModel() const;
279         virtual void setDistanceModel(AUD_DistanceModel model);
280 };
281
282 #endif //AUD_OPENALDEVICE