3D Audio GSoC:
[blender.git] / intern / audaspace / intern / AUD_SoftwareDevice.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/intern/AUD_SoftwareDevice.h
28  *  \ingroup audaspaceintern
29  */
30
31
32 #ifndef AUD_SOFTWAREDEVICE
33 #define AUD_SOFTWAREDEVICE
34
35 #include "AUD_IDevice.h"
36 #include "AUD_IHandle.h"
37 #include "AUD_I3DDevice.h"
38 #include "AUD_I3DHandle.h"
39 #include "AUD_Mixer.h"
40 #include "AUD_Buffer.h"
41 #include "AUD_PitchReader.h"
42 #include "AUD_ChannelMapperReader.h"
43
44 #include <list>
45 #include <pthread.h>
46
47 /**
48  * This device plays is a generic device with software mixing.
49  * Classes implementing this have to:
50  *  - Implement the playing function.
51  *  - Prepare the m_specs, m_mixer variables.
52  *  - Call the create and destroy functions.
53  *  - Call the mix function to retrieve their audio data.
54  */
55 class AUD_SoftwareDevice : public AUD_IDevice, public AUD_I3DDevice
56 {
57 protected:
58         /// Saves the data for playback.
59         class AUD_SoftwareHandle : public AUD_IHandle, public AUD_I3DHandle
60         {
61         public:
62                 /// The reader source.
63                 AUD_Reference<AUD_IReader> m_reader;
64
65                 /// The pitch reader in between.
66                 AUD_Reference<AUD_PitchReader> m_pitch;
67
68                 /// The channel mapper reader in between.
69                 AUD_Reference<AUD_ChannelMapperReader> m_mapper;
70
71                 /// Whether to keep the source if end of it is reached.
72                 bool m_keep;
73
74                 /// The user set pitch of the source.
75                 float m_user_pitch;
76
77                 /// The user set volume of the source.
78                 float m_user_volume;
79
80                 /// The calculated final volume of the source.
81                 float m_volume;
82
83                 /// The loop count of the source.
84                 int m_loopcount;
85
86                 /// Location in 3D Space.
87                 AUD_Vector3 m_location;
88
89                 /// Velocity in 3D Space.
90                 AUD_Vector3 m_velocity;
91
92                 /// Orientation in 3D Space.
93                 AUD_Quaternion m_orientation;
94
95                 /// Whether the position to the listener is relative or absolute
96                 bool m_relative;
97
98                 /// Maximum volume.
99                 float m_volume_max;
100
101                 /// Minimum volume.
102                 float m_volume_min;
103
104                 /// Maximum distance.
105                 float m_distance_max;
106
107                 /// Reference distance;
108                 float m_distance_reference;
109
110                 /// Attenuation
111                 float m_attenuation;
112
113                 /// Cone outer angle.
114                 float m_cone_angle_outer;
115
116                 /// Cone inner angle.
117                 float m_cone_angle_inner;
118
119                 /// Cone outer volume.
120                 float m_cone_volume_outer;
121
122                 /// Rendering flags
123                 int m_flags;
124
125                 /// The stop callback.
126                 stopCallback m_stop;
127
128                 /// Stop callback data.
129                 void* m_stop_data;
130
131                 /// Current status of the handle
132                 AUD_Status m_status;
133
134                 /// Own device.
135                 AUD_SoftwareDevice* m_device;
136
137         public:
138
139                 AUD_SoftwareHandle(AUD_SoftwareDevice* device, AUD_Reference<AUD_IReader> reader, AUD_Reference<AUD_PitchReader> pitch, AUD_Reference<AUD_ChannelMapperReader> mapper, bool keep);
140
141                 void update();
142
143                 virtual ~AUD_SoftwareHandle() {}
144                 virtual bool pause();
145                 virtual bool resume();
146                 virtual bool stop();
147                 virtual bool getKeep();
148                 virtual bool setKeep(bool keep);
149                 virtual bool seek(float position);
150                 virtual float getPosition();
151                 virtual AUD_Status getStatus();
152                 virtual float getVolume();
153                 virtual bool setVolume(float volume);
154                 virtual float getPitch();
155                 virtual bool setPitch(float pitch);
156                 virtual int getLoopCount();
157                 virtual bool setLoopCount(int count);
158                 virtual bool setStopCallback(stopCallback callback = 0, void* data = 0);
159
160                 virtual AUD_Vector3 getSourceLocation();
161                 virtual bool setSourceLocation(const AUD_Vector3& location);
162                 virtual AUD_Vector3 getSourceVelocity();
163                 virtual bool setSourceVelocity(const AUD_Vector3& velocity);
164                 virtual AUD_Quaternion getSourceOrientation();
165                 virtual bool setSourceOrientation(const AUD_Quaternion& orientation);
166                 virtual bool isRelative();
167                 virtual bool setRelative(bool relative);
168                 virtual float getVolumeMaximum();
169                 virtual bool setVolumeMaximum(float volume);
170                 virtual float getVolumeMinimum();
171                 virtual bool setVolumeMinimum(float volume);
172                 virtual float getDistanceMaximum();
173                 virtual bool setDistanceMaximum(float distance);
174                 virtual float getDistanceReference();
175                 virtual bool setDistanceReference(float distance);
176                 virtual float getAttenuation();
177                 virtual bool setAttenuation(float factor);
178                 virtual float getConeAngleOuter();
179                 virtual bool setConeAngleOuter(float angle);
180                 virtual float getConeAngleInner();
181                 virtual bool setConeAngleInner(float angle);
182                 virtual float getConeVolumeOuter();
183                 virtual bool setConeVolumeOuter(float volume);
184         };
185
186         typedef std::list<AUD_Reference<AUD_SoftwareHandle> >::iterator AUD_HandleIterator;
187
188         /**
189          * The specification of the device.
190          */
191         AUD_DeviceSpecs m_specs;
192
193         /**
194          * The mixer.
195          */
196         AUD_Reference<AUD_Mixer> m_mixer;
197
198         /**
199          * Initializes member variables.
200          */
201         void create();
202
203         /**
204          * Uninitializes member variables.
205          */
206         void destroy();
207
208         /**
209          * Mixes the next samples into the buffer.
210          * \param buffer The target buffer.
211          * \param length The length in samples to be filled.
212          */
213         void mix(data_t* buffer, int length);
214
215         /**
216          * This function tells the device, to start or pause playback.
217          * \param playing True if device should playback.
218          */
219         virtual void playing(bool playing)=0;
220
221 private:
222         /**
223          * The reading buffer.
224          */
225         AUD_Buffer m_buffer;
226
227         /**
228          * The list of sounds that are currently playing.
229          */
230         std::list<AUD_Reference<AUD_SoftwareHandle> > m_playingSounds;
231
232         /**
233          * The list of sounds that are currently paused.
234          */
235         std::list<AUD_Reference<AUD_SoftwareHandle> > m_pausedSounds;
236
237         /**
238          * Whether there is currently playback.
239          */
240         bool m_playback;
241
242         /**
243          * The mutex for locking.
244          */
245         pthread_mutex_t m_mutex;
246
247         /**
248          * The overall volume of the device.
249          */
250         float m_volume;
251
252         /// Listener location.
253         AUD_Vector3 m_location;
254
255         /// Listener velocity.
256         AUD_Vector3 m_velocity;
257
258         /// Listener orientation.
259         AUD_Quaternion m_orientation;
260
261         /// Speed of Sound.
262         float m_speed_of_sound;
263
264         /// Doppler factor.
265         float m_doppler_factor;
266
267         /// Distance model.
268         AUD_DistanceModel m_distance_model;
269
270         /// Rendering flags
271         int m_flags;
272
273 public:
274         virtual AUD_DeviceSpecs getSpecs() const;
275         virtual AUD_Reference<AUD_IHandle> play(AUD_Reference<AUD_IReader> reader, bool keep = false);
276         virtual AUD_Reference<AUD_IHandle> play(AUD_Reference<AUD_IFactory> factory, bool keep = false);
277         virtual void lock();
278         virtual void unlock();
279         virtual float getVolume() const;
280         virtual void setVolume(float volume);
281
282         virtual AUD_Vector3 getListenerLocation() const;
283         virtual void setListenerLocation(const AUD_Vector3& location);
284         virtual AUD_Vector3 getListenerVelocity() const;
285         virtual void setListenerVelocity(const AUD_Vector3& velocity);
286         virtual AUD_Quaternion getListenerOrientation() const;
287         virtual void setListenerOrientation(const AUD_Quaternion& orientation);
288         virtual float getSpeedOfSound() const;
289         virtual void setSpeedOfSound(float speed);
290         virtual float getDopplerFactor() const;
291         virtual void setDopplerFactor(float factor);
292         virtual AUD_DistanceModel getDistanceModel() const;
293         virtual void setDistanceModel(AUD_DistanceModel model);
294 };
295
296 #endif //AUD_SOFTWAREDEVICE