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