Audaspace  1.4.0
A high level audio library.
OpenALDevice.h
Go to the documentation of this file.
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 #ifdef OPENAL_PLUGIN
20 #define AUD_BUILD_PLUGIN
21 #endif
22 
29 #include "devices/IDevice.h"
30 #include "devices/IHandle.h"
31 #include "devices/I3DDevice.h"
32 #include "devices/I3DHandle.h"
34 #include "util/Buffer.h"
35 
36 #include <al.h>
37 #include <alc.h>
38 #include <list>
39 #include <mutex>
40 #include <thread>
41 #include <string>
42 
44 
49 {
50 private:
52  class OpenALHandle : public IHandle, public I3DHandle
53  {
54  private:
55  friend class OpenALDevice;
56 
57  static const int CYCLE_BUFFERS = 3;
58 
60  bool m_isBuffered;
61 
63  std::shared_ptr<IReader> m_reader;
64 
66  bool m_keep;
67 
69  ALenum m_format;
70 
72  ALuint m_source;
73 
75  ALuint m_buffers[CYCLE_BUFFERS];
76 
78  int m_current;
79 
81  bool m_eos;
82 
84  int m_loopcount;
85 
87  stopCallback m_stop;
88 
90  void* m_stop_data;
91 
93  Quaternion m_orientation;
94 
96  Status m_status;
97 
99  ALint m_relative;
100 
102  OpenALDevice* m_device;
103 
104  AUD_LOCAL bool pause(bool keep);
105 
106  AUD_LOCAL bool reinitialize();
107 
108  // delete copy constructor and operator=
109  OpenALHandle(const OpenALHandle&) = delete;
110  OpenALHandle& operator=(const OpenALHandle&) = delete;
111 
112  public:
113 
121  OpenALHandle(OpenALDevice* device, ALenum format, std::shared_ptr<IReader> reader, bool keep);
122 
123  virtual ~OpenALHandle() {}
124  virtual bool pause();
125  virtual bool resume();
126  virtual bool stop();
127  virtual bool getKeep();
128  virtual bool setKeep(bool keep);
129  virtual bool seek(double position);
130  virtual double getPosition();
131  virtual Status getStatus();
132  virtual float getVolume();
133  virtual bool setVolume(float volume);
134  virtual float getPitch();
135  virtual bool setPitch(float pitch);
136  virtual int getLoopCount();
137  virtual bool setLoopCount(int count);
138  virtual bool setStopCallback(stopCallback callback = 0, void* data = 0);
139 
140  virtual Vector3 getLocation();
141  virtual bool setLocation(const Vector3& location);
142  virtual Vector3 getVelocity();
143  virtual bool setVelocity(const Vector3& velocity);
144  virtual Quaternion getOrientation();
145  virtual bool setOrientation(const Quaternion& orientation);
146  virtual bool isRelative();
147  virtual bool setRelative(bool relative);
148  virtual float getVolumeMaximum();
149  virtual bool setVolumeMaximum(float volume);
150  virtual float getVolumeMinimum();
151  virtual bool setVolumeMinimum(float volume);
152  virtual float getDistanceMaximum();
153  virtual bool setDistanceMaximum(float distance);
154  virtual float getDistanceReference();
155  virtual bool setDistanceReference(float distance);
156  virtual float getAttenuation();
157  virtual bool setAttenuation(float factor);
158  virtual float getConeAngleOuter();
159  virtual bool setConeAngleOuter(float angle);
160  virtual float getConeAngleInner();
161  virtual bool setConeAngleInner(float angle);
162  virtual float getConeVolumeOuter();
163  virtual bool setConeVolumeOuter(float volume);
164  };
165 
169  ALCdevice* m_device;
170 
174  ALCcontext* m_context;
175 
179  DeviceSpecs m_specs;
180 
184  std::string m_name;
185 
189  bool m_useMC;
190 
194  bool m_checkDisconnect;
195 
199  std::list<std::shared_ptr<OpenALHandle> > m_playingSounds;
200 
204  std::list<std::shared_ptr<OpenALHandle> > m_pausedSounds;
205 
209  std::recursive_mutex m_mutex;
210 
214  std::thread m_thread;
215 
219  bool m_playing;
220 
224  int m_buffersize;
225 
229  Buffer m_buffer;
230 
234  Quaternion m_orientation;
235 
237  DefaultSynchronizer m_synchronizer;
238 
243  AUD_LOCAL void start();
244 
248  AUD_LOCAL void updateStreams();
249 
256  AUD_LOCAL bool getFormat(ALenum &format, Specs specs);
257 
258  // delete copy constructor and operator=
259  OpenALDevice(const OpenALDevice&) = delete;
260  OpenALDevice& operator=(const OpenALDevice&) = delete;
261 
262 public:
272  OpenALDevice(DeviceSpecs specs, int buffersize = AUD_DEFAULT_BUFFER_SIZE, std::string name = "");
273 
274  virtual ~OpenALDevice();
275 
276  virtual DeviceSpecs getSpecs() const;
277  virtual std::shared_ptr<IHandle> play(std::shared_ptr<IReader> reader, bool keep = false);
278  virtual std::shared_ptr<IHandle> play(std::shared_ptr<ISound> sound, bool keep = false);
279  virtual void stopAll();
280  virtual void lock();
281  virtual void unlock();
282  virtual float getVolume() const;
283  virtual void setVolume(float volume);
284  virtual ISynchronizer* getSynchronizer();
285 
286  virtual Vector3 getListenerLocation() const;
287  virtual void setListenerLocation(const Vector3& location);
288  virtual Vector3 getListenerVelocity() const;
289  virtual void setListenerVelocity(const Vector3& velocity);
290  virtual Quaternion getListenerOrientation() const;
291  virtual void setListenerOrientation(const Quaternion& orientation);
292  virtual float getSpeedOfSound() const;
293  virtual void setSpeedOfSound(float speed);
294  virtual float getDopplerFactor() const;
295  virtual void setDopplerFactor(float factor);
296  virtual DistanceModel getDistanceModel() const;
297  virtual void setDistanceModel(DistanceModel model);
298 
303  static std::list<std::string> getDeviceNames();
304 
308  static void registerPlugin();
309 };
310 
This class represents a quaternion used for 3D rotations.
Definition: Math3D.h:205
This device plays through OpenAL.
Definition: OpenALDevice.h:48
#define AUD_NAMESPACE_BEGIN
Opens the audaspace namespace aud.
Definition: Audaspace.h:116
virtual float getDopplerFactor() const =0
Retrieves the doppler factor.
The IDevice interface.
virtual void stopAll()
Stops all playing sounds.
virtual std::shared_ptr< IHandle > play(std::shared_ptr< IReader > reader, bool keep=false)
Plays a sound source.
virtual DistanceModel getDistanceModel() const =0
Retrieves the distance model.
virtual float getVolume() const
Retrieves the overall device volume.
virtual void setVolume(float volume)
Sets the overall device volume.
This class enables global synchronization of several audio applications if supported.
Definition: ISynchronizer.h:38
virtual Vector3 getListenerLocation() const =0
Retrieves the listener location.
virtual void lock()
Locks the device.
virtual void setListenerOrientation(const Quaternion &orientation)=0
Sets the listener orientation.
virtual void unlock()
Unlocks the previously locked device.
Specification of a sound source.
Definition: Specification.h:109
virtual void setDistanceModel(DistanceModel model)=0
Sets the distance model.
The I3DHandle interface represents a playback handle for 3D sources.
Definition: I3DHandle.h:38
#define AUD_DEFAULT_BUFFER_SIZE
The default playback buffer size of a device.
Definition: Audaspace.h:103
static void registerPlugin()
Registers this plugin.
void(* stopCallback)(void *)
The stopCallback is called when a handle reaches the end of the stream and thus gets stopped...
Definition: IHandle.h:42
This class is a simple buffer in RAM which is 32 Byte aligned and provides resize functionality...
Definition: Buffer.h:33
virtual DeviceSpecs getSpecs() const
Returns the specification of the device.
Specification of a sound device.
Definition: Specification.h:119
static std::list< std::string > getDeviceNames()
Retrieves a list of available hardware devices to open with OpenAL.
virtual void setListenerVelocity(const Vector3 &velocity)=0
Sets the listener velocity.
virtual float getSpeedOfSound() const =0
Retrieves the speed of sound.
The I3DDevice interface represents an output device for 3D sound.
Definition: I3DDevice.h:52
Defines the IHandle interface as well as possible states of the handle.
virtual Quaternion getListenerOrientation() const =0
Retrieves the listener orientation.
The DefaultSynchronizer class.
#define AUD_NAMESPACE_END
Closes the audaspace namespace aud.
Definition: Audaspace.h:119
The IHandle interface represents a playback handles of a specific device.
Definition: IHandle.h:48
virtual Vector3 getListenerVelocity() const =0
Retrieves the listener velocity.
The I3DHandle interface.
Defines the I3DDevice interface as well as the different distance models.
#define AUD_PLUGIN_API
Used for exporting symbols in the shared library.
Definition: Audaspace.h:94
The IDevice interface represents an output device for sound sources.
Definition: IDevice.h:46
virtual void setDopplerFactor(float factor)=0
Sets the doppler factor.
This class represents a 3 dimensional vector.
Definition: Math3D.h:35
#define AUD_LOCAL
Used for hiding symbols from export in the shared library.
Definition: Audaspace.h:80
This class is a default ISynchronizer implementation that actually does no synchronization and is int...
Definition: DefaultSynchronizer.h:33
The Buffer class.
virtual void setSpeedOfSound(float speed)=0
Sets the speed of sound.
virtual void setListenerLocation(const Vector3 &location)=0
Sets the listener location.
Status
Status of a playback handle.
Definition: IHandle.h:30
DistanceModel
Possible distance models for the 3D device.
Definition: I3DDevice.h:34
virtual ISynchronizer * getSynchronizer()
Retrieves the synchronizer for this device, which enables accurate synchronization between audio play...