tmp
[blender.git] / extern / audaspace / include / devices / SoftwareDevice.h
1 /*******************************************************************************
2  * Copyright 2009-2016 Jörg Müller
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *   http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  ******************************************************************************/
16
17 #pragma once
18
19 /**
20  * @file SoftwareDevice.h
21  * @ingroup devices
22  * The SoftwareDevice class.
23  */
24
25 #include "devices/IDevice.h"
26 #include "devices/IHandle.h"
27 #include "devices/I3DDevice.h"
28 #include "devices/I3DHandle.h"
29 #include "devices/DefaultSynchronizer.h"
30 #include "util/Buffer.h"
31
32 #include <list>
33 #include <mutex>
34
35 AUD_NAMESPACE_BEGIN
36
37 class Mixer;
38 class PitchReader;
39 class ResampleReader;
40 class ChannelMapperReader;
41
42 /**
43  * The software device is a generic device with software mixing.
44  * It is a base class for all software mixing classes.
45  * Classes implementing this have to:
46  *  - Implement the playing function.
47  *  - Prepare the m_specs, m_mixer variables.
48  *  - Call the create and destroy functions.
49  *  - Call the mix function to retrieve their audio data.
50  */
51 class AUD_API SoftwareDevice : public IDevice, public I3DDevice
52 {
53 protected:
54         /// Saves the data for playback.
55         class AUD_API SoftwareHandle : public IHandle, public I3DHandle
56         {
57         private:
58                 // delete copy constructor and operator=
59                 SoftwareHandle(const SoftwareHandle&) = delete;
60                 SoftwareHandle& operator=(const SoftwareHandle&) = delete;
61
62         public:
63                 /// The reader source.
64                 std::shared_ptr<IReader> m_reader;
65
66                 /// The pitch reader in between.
67                 std::shared_ptr<PitchReader> m_pitch;
68
69                 /// The resample reader in between.
70                 std::shared_ptr<ResampleReader> m_resampler;
71
72                 /// The channel mapper reader in between.
73                 std::shared_ptr<ChannelMapperReader> m_mapper;
74
75                 /// Whether to keep the source if end of it is reached.
76                 bool m_keep;
77
78                 /// The user set pitch of the source.
79                 float m_user_pitch;
80
81                 /// The user set volume of the source.
82                 float m_user_volume;
83
84                 /// The user set panning for non-3D sources
85                 float m_user_pan;
86
87                 /// The calculated final volume of the source.
88                 float m_volume;
89
90                 /// The previous calculated final volume of the source.
91                 float m_old_volume;
92
93                 /// The loop count of the source.
94                 int m_loopcount;
95
96                 /// Location in 3D Space.
97                 Vector3 m_location;
98
99                 /// Velocity in 3D Space.
100                 Vector3 m_velocity;
101
102                 /// Orientation in 3D Space.
103                 Quaternion m_orientation;
104
105                 /// Whether the position to the listener is relative or absolute
106                 bool m_relative;
107
108                 /// Maximum volume.
109                 float m_volume_max;
110
111                 /// Minimum volume.
112                 float m_volume_min;
113
114                 /// Maximum distance.
115                 float m_distance_max;
116
117                 /// Reference distance;
118                 float m_distance_reference;
119
120                 /// Attenuation
121                 float m_attenuation;
122
123                 /// Cone outer angle.
124                 float m_cone_angle_outer;
125
126                 /// Cone inner angle.
127                 float m_cone_angle_inner;
128
129                 /// Cone outer volume.
130                 float m_cone_volume_outer;
131
132                 /// Rendering flags
133                 int m_flags;
134
135                 /// The stop callback.
136                 stopCallback m_stop;
137
138                 /// Stop callback data.
139                 void* m_stop_data;
140
141                 /// Current status of the handle
142                 Status m_status;
143
144                 /// Own device.
145                 SoftwareDevice* m_device;
146
147                 /**
148                  * This method is for internal use only.
149                  * @param keep Whether the sound should be marked stopped or paused.
150                  * @return Whether the action succeeded.
151                  */
152                 bool pause(bool keep);
153
154         public:
155                 /**
156                  * Creates a new software handle.
157                  * \param device The device this handle is from.
158                  * \param reader The reader to play.
159                  * \param pitch The pitch reader.
160                  * \param resampler The resampling reader.
161                  * \param mapper The channel mapping reader.
162                  * \param keep Whether to keep the handle when the sound ends.
163                  */
164                 SoftwareHandle(SoftwareDevice* device, std::shared_ptr<IReader> reader, std::shared_ptr<PitchReader> pitch, std::shared_ptr<ResampleReader> resampler, std::shared_ptr<ChannelMapperReader> mapper, bool keep);
165
166                 /**
167                  * Updates the handle's playback parameters.
168                  */
169                 void update();
170
171                 /**
172                  * Sets the audio output specification of the readers.
173                  * \param specs The output specification.
174                  */
175                 void setSpecs(Specs specs);
176
177                 virtual ~SoftwareHandle() {}
178                 virtual bool pause();
179                 virtual bool resume();
180                 virtual bool stop();
181                 virtual bool getKeep();
182                 virtual bool setKeep(bool keep);
183                 virtual bool seek(float position);
184                 virtual float getPosition();
185                 virtual Status getStatus();
186                 virtual float getVolume();
187                 virtual bool setVolume(float volume);
188                 virtual float getPitch();
189                 virtual bool setPitch(float pitch);
190                 virtual int getLoopCount();
191                 virtual bool setLoopCount(int count);
192                 virtual bool setStopCallback(stopCallback callback = 0, void* data = 0);
193
194                 virtual Vector3 getLocation();
195                 virtual bool setLocation(const Vector3& location);
196                 virtual Vector3 getVelocity();
197                 virtual bool setVelocity(const Vector3& velocity);
198                 virtual Quaternion getOrientation();
199                 virtual bool setOrientation(const Quaternion& orientation);
200                 virtual bool isRelative();
201                 virtual bool setRelative(bool relative);
202                 virtual float getVolumeMaximum();
203                 virtual bool setVolumeMaximum(float volume);
204                 virtual float getVolumeMinimum();
205                 virtual bool setVolumeMinimum(float volume);
206                 virtual float getDistanceMaximum();
207                 virtual bool setDistanceMaximum(float distance);
208                 virtual float getDistanceReference();
209                 virtual bool setDistanceReference(float distance);
210                 virtual float getAttenuation();
211                 virtual bool setAttenuation(float factor);
212                 virtual float getConeAngleOuter();
213                 virtual bool setConeAngleOuter(float angle);
214                 virtual float getConeAngleInner();
215                 virtual bool setConeAngleInner(float angle);
216                 virtual float getConeVolumeOuter();
217                 virtual bool setConeVolumeOuter(float volume);
218         };
219
220         /**
221          * The specification of the device.
222          */
223         DeviceSpecs m_specs;
224
225         /**
226          * The mixer.
227          */
228         std::shared_ptr<Mixer> m_mixer;
229
230         /**
231          * Whether to do high or low quality resampling.
232          */
233         bool m_quality;
234
235         /**
236          * Initializes member variables.
237          */
238         void create();
239
240         /**
241          * Uninitializes member variables.
242          */
243         void destroy();
244
245         /**
246          * Mixes the next samples into the buffer.
247          * \param buffer The target buffer.
248          * \param length The length in samples to be filled.
249          */
250         void mix(data_t* buffer, int length);
251
252         /**
253          * This function tells the device, to start or pause playback.
254          * \param playing True if device should playback.
255          */
256         virtual void playing(bool playing)=0;
257
258         /**
259          * Sets the audio output specification of the device.
260          * \param specs The output specification.
261          */
262         void setSpecs(Specs specs);
263
264         /**
265          * Empty default constructor. To setup the device call the function create()
266          * and to uninitialize call destroy().
267          */
268         SoftwareDevice();
269
270 private:
271         /**
272          * The reading buffer.
273          */
274         Buffer m_buffer;
275
276         /**
277          * The list of sounds that are currently playing.
278          */
279         std::list<std::shared_ptr<SoftwareHandle> > m_playingSounds;
280
281         /**
282          * The list of sounds that are currently paused.
283          */
284         std::list<std::shared_ptr<SoftwareHandle> > m_pausedSounds;
285
286         /**
287          * Whether there is currently playback.
288          */
289         bool m_playback;
290
291         /**
292          * The mutex for locking.
293          */
294         std::recursive_mutex m_mutex;
295
296         /**
297          * The overall volume of the device.
298          */
299         float m_volume;
300
301         /// Listener location.
302         Vector3 m_location;
303
304         /// Listener velocity.
305         Vector3 m_velocity;
306
307         /// Listener orientation.
308         Quaternion m_orientation;
309
310         /// Speed of Sound.
311         float m_speed_of_sound;
312
313         /// Doppler factor.
314         float m_doppler_factor;
315
316         /// Distance model.
317         DistanceModel m_distance_model;
318
319         /// Rendering flags
320         int m_flags;
321
322         /// Synchronizer.
323         DefaultSynchronizer m_synchronizer;
324
325         // delete copy constructor and operator=
326         SoftwareDevice(const SoftwareDevice&) = delete;
327         SoftwareDevice& operator=(const SoftwareDevice&) = delete;
328
329 public:
330
331         /**
332          * Sets the panning of a specific handle.
333          * \param handle The handle to set the panning from.
334          * \param pan The new panning value, should be in the range [-2, 2].
335          */
336         static void setPanning(IHandle* handle, float pan);
337
338         /**
339          * Sets the resampling quality.
340          * \param quality Low (false) or high (true) quality.
341          */
342         void setQuality(bool quality);
343
344         virtual DeviceSpecs getSpecs() const;
345         virtual std::shared_ptr<IHandle> play(std::shared_ptr<IReader> reader, bool keep = false);
346         virtual std::shared_ptr<IHandle> play(std::shared_ptr<ISound> sound, bool keep = false);
347         virtual void stopAll();
348         virtual void lock();
349         virtual void unlock();
350         virtual float getVolume() const;
351         virtual void setVolume(float volume);
352         virtual ISynchronizer* getSynchronizer();
353
354         virtual Vector3 getListenerLocation() const;
355         virtual void setListenerLocation(const Vector3& location);
356         virtual Vector3 getListenerVelocity() const;
357         virtual void setListenerVelocity(const Vector3& velocity);
358         virtual Quaternion getListenerOrientation() const;
359         virtual void setListenerOrientation(const Quaternion& orientation);
360         virtual float getSpeedOfSound() const;
361         virtual void setSpeedOfSound(float speed);
362         virtual float getDopplerFactor() const;
363         virtual void setDopplerFactor(float factor);
364         virtual DistanceModel getDistanceModel() const;
365         virtual void setDistanceModel(DistanceModel model);
366 };
367
368 AUD_NAMESPACE_END