cAudio  2.3.0
3d Audio Engine
cAudioManager.cpp
1 // Copyright (c) 2008-2011 Raynaldo (Wildicv) Rivera, Joshua (Dark_Kilauea) Jones, Murat (wolfmanfx) Sari
2 // This file is part of the "cAudio Engine"
3 // For conditions of distribution and use, see copyright notice in cAudio.h
4 
5 #include "cAudioManager.h"
6 #include "cAudio.h"
7 #include "cAudioSource.h"
8 #include "cAudioStaticSource.h"
9 #include "cAudioPlatform.h"
10 #include "cAudioSleep.h"
11 #include "cUtils.h"
12 #include "cThread.h"
13 #include "cLogger.h"
14 #include "cPluginManager.h"
15 #include "cThread.h"
16 #include "cMemorySource.h"
17 #include "cRawAudioDecoderFactory.h"
18 #include <string.h>
19 #include <algorithm>
20 #include "cOpenALDeviceContext.h"
21 
22 namespace cAudio
23 {
24  cAudioManager::~cAudioManager()
25  {
27  }
28 
29  bool cAudioManager::initialize(const char* deviceName, int outputFrequency, int eaxEffectSlots)
30  {
31  cAudioMutexBasicLock lock(Mutex);
32 
33  if(Initialized)
34  return false;
35 
36  AudioContext = CAUDIO_NEW cOpenALDeviceContext(this);
37 
38  if(!AudioContext->initialize(deviceName, outputFrequency, eaxEffectSlots))
39  return false;
40 
41 #ifdef CAUDIO_USE_INTERNAL_THREAD
42  if (!AudioThread)
43  {
44  AudioThread = new cAudioThread(this);
45  }
46  AudioThread->start();
47 #endif
48  Initialized = true;
49  return true;
50  }
51 
53  {
54  if(Initialized)
55  {
56  if (AudioThread) // First wait for our update thread to finish up
57  {
58  AudioThread->join();
59  delete AudioThread;
60  AudioThread = NULL;
61  }
62 
63  cAudioMutexBasicLock lock(Mutex);
64 
68 
70 
71  if (AudioContext)
72  {
73  AudioContext->shutDown();
74  CAUDIO_DELETE AudioContext;
75  AudioContext = NULL;
76  }
77 
78  Initialized = false;
79 
80  getLogger()->logInfo("AudioManager", "Manager successfully shutdown.");
81  }
82  }
83 
85  {
86  updateSources.clear();
87 
88  {
89  cAudioMutexBasicLock lock(Mutex);
90  size_t count = audioSources.size();
91  for(size_t i=0; i<count; i++)
92  {
93  IAudioSource* source = audioSources[i];
94  if (source->isValid())
95  {
96  source->grab();
97  updateSources.push_back(source);
98  }
99  }
100  }
101 
102  // not holding the mutex because this might take a while!
103  for (int i=0; i != updateSources.size(); i++)
104  {
105  IAudioSource *src = updateSources[i];
106  src->update();
107  src->drop();
108  }
109 
110  cAudioMutexBasicLock lock(Mutex);
111 
112  if (!managedAudioSources.empty())
113  {
114  size_t count = managedAudioSources.size();
115  for(size_t i=0; i<count; i++)
116  {
117  IAudioSource* source = managedAudioSources[i];
118  if (source->isValid())
119  {
120  source->update();
121  if (source->isStopped())
122  {
123  managedAudioSourcesDelBuffer.push_back(source);
124  }
125  }
126  }
127 
128  count = managedAudioSourcesDelBuffer.size();
129  for(size_t i=0; i<count; i++)
130  {
131  IAudioSource* source = managedAudioSourcesDelBuffer[i];
132  cAudioVector<IAudioSource*>::Type::iterator it = std::find(managedAudioSources.begin(), managedAudioSources.end(), source);
133  if (it != managedAudioSources.end())
134  {
135  managedAudioSources.erase(it);
136  CAUDIO_DELETE source;
137  }
138  }
139  managedAudioSourcesDelBuffer.clear();
140  }
141  }
142 
143  void cAudioManager::run()
144  {
145  if(!audioSources.empty())
146  update();
147 
148  cAudioSleep(1);
149  }
150 
152  {
153  return (AudioThread != NULL && AudioThread->isRunning());
154  }
155 
156 #if CAUDIO_EFX_ENABLED == 1
157  IAudioEffects* cAudioManager::getEffects()
158  {
159  if (AudioContext)
160  {
161  return AudioContext->getEffects();
162  }
163  return NULL;
164  }
165 #endif
166 
167  IAudioSource* cAudioManager::play2D(const char* filename, bool playLooped, bool startPaused)
168  {
169  cAudioMutexBasicLock lock(Mutex);
170  IAudioSource* pAudioSrc = create("", filename, true);
171 
172  if (!pAudioSrc)
173  return NULL;
174 
175  if (!playLooped && !startPaused)
176  {
177  cAudioVector<IAudioSource*>::Type::iterator it = std::find(audioSources.begin(), audioSources.end(), pAudioSrc);
178  if (it != audioSources.end())
179  {
180  audioSources.erase(it);
181  }
182  managedAudioSources.push_back(pAudioSrc);
183 
184  pAudioSrc->play2d();
185  return NULL;
186  }
187 
188  if (playLooped && !startPaused)
189  {
190  pAudioSrc->play2d(true);
191  }
192 
193  return pAudioSrc;
194  }
195 
196  IAudioSource* cAudioManager::play3D(const char* filename, cVector3 position, bool playLooped, bool startPaused)
197  {
198  cAudioMutexBasicLock lock(Mutex);
199  IAudioSource* pAudioSrc = create("", filename, true);
200 
201  if (!playLooped && !startPaused)
202  {
203  cAudioVector<IAudioSource*>::Type::iterator it = std::find(audioSources.begin(), audioSources.end(), pAudioSrc);
204  if (it != audioSources.end())
205  {
206  audioSources.erase(it);
207  }
208  managedAudioSources.push_back(pAudioSrc);
209 
210  pAudioSrc->play3d(position);
211  return NULL;
212  }
213 
214  if (playLooped && !startPaused)
215  {
216  pAudioSrc->play3d(position, 1.0, true);
217  }
218 
219  return pAudioSrc;
220  }
221 
223  {
224  cAudioMutexBasicLock lock(Mutex);
225  MasterVolume = vol;
226  size_t count = audioSources.size();
227  for(size_t i=0; i<count; i++)
228  {
229  audioSources[i]->setVolume(audioSources[i]->getVolume());
230  }
231  }
232 
234  {
235  return MasterVolume;
236  }
237 
239  {
240  alSpeedOfSound(speed);
241  checkALError();
242  }
243 
245  {
246  return alGetFloat(AL_SPEED_OF_SOUND);
247  }
248 
249  void cAudioManager::setDopplerFactor(float factor) const
250  {
251  alDopplerFactor(factor);
252  checkALError();
253  }
254 
256  {
257  return alGetFloat(AL_DOPPLER_FACTOR);
258  }
259 
261  {
262  cAudioMutexBasicLock lock(Mutex);
263  size_t count = audioSources.size();
264  for(size_t i=0; i<count; i++)
265  {
266  if(audioSources[i]->isPlaying())
267  audioSources[i]->stop();
268  }
269  }
270 
271  IAudioSource* cAudioManager::createAudioSource(IAudioDecoder* decoder, const cAudioString& audioName, const cAudioString& dataSource)
272  {
273  if (!decoder)
274  return NULL;
275 
276  if(decoder->isValid())
277  {
278 #if CAUDIO_EFX_ENABLED == 1
279  IAudioSource* audio = CAUDIO_NEW cAudioSource(decoder, AudioContext, ((cAudioEffects*)getEffects())->getEFXInterface());
280 #else
281  IAudioSource* audio = CAUDIO_NEW cAudioSource(decoder, AudioContext);
282 #endif
283  decoder->drop();
284 
285  if(audio && audio->isValid())
286  {
287  if(!audioName.empty())
288  audioIndex[audioName] = audio;
289 
290  audioSources.push_back(audio);
291  getLogger()->logInfo("AudioManager", "Audio Source (%s) created from Data Source %s.", toUTF8(audioName), toUTF8(dataSource));
292  return audio;
293  }
294 
295  getLogger()->logError("AudioManager", "Failed to create Audio Source (%s): Error creating audio source.", toUTF8(audioName));
296  audio->drop();
297  return NULL;
298  }
299  getLogger()->logError("AudioManager", "Failed to create Audio Source (%s): Audio data could not be decoded by (.%s) decoder.",
300  toUTF8(audioName), toUTF8(decoder->getType()));
301  decoder->drop();
302  return NULL;
303  }
304 
305 
306  IAudioSource* cAudioManager::create(const char* name, const char* filename, bool stream)
307  {
308  if(!Initialized) return NULL;
309 
310  cAudioMutexBasicLock lock(Mutex);
311  cAudioString audioName = fromUTF8(name);
312  cAudioString path = fromUTF8(filename);
313  cAudioString ext = getExt(path);
314  IAudioDecoderFactory* factory = getAudioDecoderFactory(toUTF8(ext));
315 
316  if(!factory) {
317  getLogger()->logError("AudioManager", "Failed to create Audio Source (%s): No decoder could be found for (.%s).", toUTF8(audioName), toUTF8(ext));
318  return NULL;
319  }
320 
321  for(size_t i=0; i<dataSourcePriorityList.size(); ++i)
322  {
323  const cAudioString dataSourceName = dataSourcePriorityList[i].second;
324  IDataSourceFactory* dataFactory = datasourcemap[dataSourceName];
325  if(dataFactory)
326  {
327  IDataSource* source = dataFactory->CreateDataSource(filename, stream);
328  if(source && source->isValid())
329  {
330  IAudioDecoder* decoder = factory->CreateAudioDecoder(source);
331  source->drop();
332 
333  IAudioSource* audio = createAudioSource(decoder, audioName, dataSourceName);
334  if(audio != NULL)
335  return audio;
336 
337  return NULL;
338  }
339  }
340  }
341  return NULL;
342  }
343 
344  IAudioSource* cAudioManager::createFromMemory(const char* name, const char* data, size_t length, const char* extension)
345  {
346  if(!Initialized) return NULL;
347 
348  cAudioMutexBasicLock lock(Mutex);
349  cAudioString audioName = fromUTF8(name);
350  cAudioString ext = fromUTF8(extension);
351  IAudioDecoderFactory* factory = getAudioDecoderFactory(toUTF8(ext));
352 
353  if(!factory) {
354  getLogger()->logError("AudioManager", "Failed to create Audio Source (%s): Codec (.%s) is not supported.", toUTF8(audioName), toUTF8(ext));
355  return NULL;
356  }
357 
358  cMemorySource* source = CAUDIO_NEW cMemorySource(data, length, true);
359  if(source && source->isValid())
360  {
361  IAudioDecoder* decoder = factory->CreateAudioDecoder(source);
362  source->drop();
363 
364  IAudioSource* audio = createAudioSource(decoder, audioName, _CTEXT("cMemorySource"));
365  if(audio != NULL)
366  return audio;
367  }
368  return NULL;
369  }
370 
371  IAudioSource* cAudioManager::createFromAudioBuffer(const char* name, AudioCaptureBuffer* pBiffer, unsigned int frequency, AudioFormats format)
372  {
373  return createFromRaw(name, pBiffer->getWriteBuffer(), pBiffer->getLength(), frequency, format);
374  }
375 
376  IAudioSource* cAudioManager::createFromRaw(const char* name, const char* data, size_t length, unsigned int frequency, AudioFormats format)
377  {
378  if(!Initialized) return NULL;
379 
380  cAudioMutexBasicLock lock(Mutex);
381  cAudioString audioName = fromUTF8(name);
383 
384  if(!factory) {
385  getLogger()->logError("AudioManager", "Failed to create Audio Source (%s): Codec (.raw) is not supported.", toUTF8(audioName));
386  return NULL;
387  }
388 
389  cMemorySource* source = CAUDIO_NEW cMemorySource(data, length, true);
390  if(source && source->isValid())
391  {
392  IAudioDecoder* decoder = ((cRawAudioDecoderFactory*)factory)->CreateAudioDecoder(source, frequency, format);
393  source->drop();
394 
395  IAudioSource* audio = createAudioSource(decoder, audioName, _CTEXT("cMemorySource"));
396  if(audio != NULL)
397  return audio;
398  }
399  return NULL;
400  }
401 
403  {
404  if(!Initialized) return NULL;
405 
406  cAudioMutexBasicLock lock(Mutex);
407  cAudioString path = fromUTF8(filename);
408  cAudioString ext = getExt(path);
409  IAudioDecoderFactory* factory = getAudioDecoderFactory(toUTF8(ext));
410 
411  if(!factory) {
412  getLogger()->logError("AudioManager", "Failed to create Audio Buffer: No decoder could be found for (.%s).", toUTF8(ext));
413  return NULL;
414  }
415 
416  for(size_t i=0; i<dataSourcePriorityList.size(); ++i)
417  {
418  const cAudioString dataSourceName = dataSourcePriorityList[i].second;
419  IDataSourceFactory* dataFactory = datasourcemap[dataSourceName];
420  if(dataFactory)
421  {
422  IDataSource* source = dataFactory->CreateDataSource(filename, false);
423  if(source && source->isValid())
424  {
425  IAudioDecoder* decoder = factory->CreateAudioDecoder(source);
426  source->drop();
427 
428  IAudioBuffer* buffer = CAUDIO_NEW cAudioBuffer(decoder);
429 
430  if(buffer != NULL)
431  return buffer;
432 
433  return NULL;
434  }
435  }
436  }
437  return NULL;
438  }
439 
441  {
442  if(!Initialized) return NULL;
443 
444  // FIXME save a reference?
445  IAudioSource *audio = CAUDIO_NEW cAudioStaticSource(buffer, AudioContext);
446  return audio;
447  }
448 
449  bool cAudioManager::registerAudioDecoder(IAudioDecoderFactory* factory, const char* extension)
450  {
451  cAudioMutexBasicLock lock(Mutex);
452  cAudioString ext = fromUTF8(extension);
453  decodermap[ext] = factory;
454  getLogger()->logInfo("AudioManager", "Audio Decoder for extension .%s registered.", toUTF8(ext));
455  return true;
456  }
457 
458  void cAudioManager::unRegisterAudioDecoder(const char* extension)
459  {
460  cAudioMutexBasicLock lock(Mutex);
461  cAudioString ext = fromUTF8(extension);
462  decodermapIterator it = decodermap.find(ext);
463  if(it != decodermap.end())
464  {
465  decodermap.erase(it);
466  getLogger()->logInfo("AudioManager", "Audio Decoder for extension .%s unregistered.", toUTF8(ext));
467  }
468  }
469 
470  bool cAudioManager::isAudioDecoderRegistered(const char* extension)
471  {
472  cAudioMutexBasicLock lock(Mutex);
473  cAudioString ext = fromUTF8(extension);
474  decodermapIterator it = decodermap.find(ext);
475  return (it != decodermap.end());
476  }
477 
479  {
480  cAudioMutexBasicLock lock(Mutex);
481  cAudioString ext = fromUTF8(extension);
482  decodermapIterator it = decodermap.find(ext);
483  if(it != decodermap.end())
484  {
485  return it->second;
486  }
487  return NULL;
488  }
489 
491  {
492  cAudioMutexBasicLock lock(Mutex);
493  decodermap.clear();
494  }
495 
496  bool compareDataSourcePriorities(std::pair<int, cAudioString> left, std::pair<int, cAudioString> right)
497  {
498  return (left.first > right.first);
499  }
500 
501  bool cAudioManager::registerDataSource(IDataSourceFactory* factory, const char* name, int priority)
502  {
503  cAudioMutexBasicLock lock(Mutex);
504  cAudioString safeName = fromUTF8(name);
505  datasourcemap[safeName] = factory;
506  dataSourcePriorityList.push_back(std::pair<int, cAudioString>(priority, safeName));
507  std::sort(dataSourcePriorityList.begin(), dataSourcePriorityList.end(), compareDataSourcePriorities);
508 
509  getLogger()->logInfo("AudioManager", "Data Source named %s registered (Priority %i).", toUTF8(safeName), priority);
510  return true;
511  }
512 
513  void cAudioManager::unRegisterDataSource(const char* name)
514  {
515  cAudioMutexBasicLock lock(Mutex);
516  cAudioString safeName = fromUTF8(name);
517  datasourcemapIterator it = datasourcemap.find(safeName);
518  if(it != datasourcemap.end())
519  {
520  datasourcemap.erase(it);
521  getLogger()->logInfo("AudioManager", "Data Source named %s unregistered.", toUTF8(safeName));
522  }
523 
524  for(size_t i=0; i<dataSourcePriorityList.size(); ++i)
525  {
526  if(dataSourcePriorityList[i].second == safeName)
527  {
528  dataSourcePriorityList.erase(dataSourcePriorityList.begin()+i);
529  break;
530  }
531  }
532 
533  std::sort(dataSourcePriorityList.begin(), dataSourcePriorityList.end(), compareDataSourcePriorities);
534  }
535 
537  {
538  cAudioMutexBasicLock lock(Mutex);
539  cAudioString safeName = fromUTF8(name);
540  datasourcemapIterator it = datasourcemap.find(safeName);
541  return (it != datasourcemap.end());
542  }
543 
545  {
546  cAudioMutexBasicLock lock(Mutex);
547  cAudioString safeName = fromUTF8(name);
548  datasourcemapIterator it = datasourcemap.find(safeName);
549  if(it != datasourcemap.end())
550  {
551  return it->second;
552  }
553  return NULL;
554  }
555 
557  {
558  cAudioMutexBasicLock lock(Mutex);
559  datasourcemap.clear();
560  dataSourcePriorityList.clear();
561  }
562 
564  {
565  if(handler)
566  {
567  eventHandlerList.push_back(handler);
568  }
569  }
570 
572  {
573  if(handler)
574  {
575  eventHandlerList.remove(handler);
576  }
577  }
578 
580  {
581  eventHandlerList.clear();
582  }
583 
584  void cAudioManager::signalEvent(Events sevent)
585  {
586  cAudioMutexBasicLock lock(Mutex);
587  cAudioList<IManagerEventHandler*>::Type::iterator it = eventHandlerList.begin();
588 
589  if(it != eventHandlerList.end())
590  {
591  switch(sevent)
592  {
593  case ON_INIT:
594 
595  for(; it != eventHandlerList.end(); it++)
596  {
597  (*it)->onInit();
598  }
599 
600  break;
601 
602  case ON_UPDATE:
603 
604  for(; it != eventHandlerList.end(); it++)
605  {
606  (*it)->onUpdate();
607  }
608 
609  break;
610 
611  case ON_RELEASE:
612 
613  for(; it != eventHandlerList.end(); it++)
614  {
615  (*it)->onRelease();
616  }
617 
618  break;
619 
620  case ON_SOURCECREATE:
621 
622  for(; it != eventHandlerList.end(); it++)
623  {
624  (*it)->onSourceCreate();
625  }
626 
627  break;
628 
629  case ON_DECODERREGISTER:
630 
631  for(; it != eventHandlerList.end(); it++)
632  {
633  (*it)->onDecoderRegister();
634  }
635 
636  break;
637 
638  case ON_DATASOURCEREGISTER:
639 
640  for(; it != eventHandlerList.end(); it++)
641  {
642  (*it)->onDataSourceRegister();
643  }
644 
645  break;
646  }
647  }
648  }
649 
651  {
652  cAudioMutexBasicLock lock(Mutex);
653  cAudioString audioName = fromUTF8(name);
654  audioIndexIterator i = audioIndex.find(audioName);
655  if (i == audioIndex.end())
656  {
657  return NULL;
658  }
659  return i->second;
660  }
661 
663  {
664  cAudioMutexBasicLock lock(Mutex);
666 
667  cAudioVector<IAudioSource*>::Type deleteSources;
668  for(audioSourcesIter = audioSources.begin(); audioSourcesIter != audioSources.end(); ++audioSourcesIter)
669  {
670  if((*audioSourcesIter))
671  deleteSources.push_back(*audioSourcesIter);
672  }
673  for(audioSourcesIter = deleteSources.begin(); audioSourcesIter != deleteSources.end(); ++audioSourcesIter)
674  (*audioSourcesIter)->drop();
675 
676  deleteSources.clear();
677  audioSources.clear();
678  audioIndex.clear();
679 
681  for(managedAudioIter = managedAudioSources.begin(); managedAudioIter != managedAudioSources.end(); managedAudioIter++)
682  {
683  if ((*managedAudioIter))
684  {
685  CAUDIO_DELETE (*managedAudioIter);
686  }
687  }
688  managedAudioSources.clear();
689 
690  cAudioVector<IAudioSource*>::Type::iterator managedAudioSourcesDelIter;
691  for(managedAudioSourcesDelIter = managedAudioSourcesDelBuffer.begin(); managedAudioSourcesDelIter != managedAudioSourcesDelBuffer.end(); managedAudioSourcesDelIter++)
692  {
693  if ((*managedAudioSourcesDelIter))
694  {
695  CAUDIO_DELETE (*managedAudioSourcesDelIter);
696  }
697  }
698  managedAudioSourcesDelBuffer.clear();
699  }
700 
702  {
703  if(source)
704  {
705  cAudioMutexBasicLock lock(Mutex);
706  audioIndexIterator it = audioIndex.begin();
707  for ( it=audioIndex.begin(); it != audioIndex.end(); it++ )
708  {
709  if( it->second == source )
710  {
711  audioIndex.erase(it);
712  break;
713  }
714  }
715  for(unsigned int i=0; i<audioSources.size(); ++i)
716  {
717  if(source == audioSources[i])
718  {
719  audioSources.erase(audioSources.begin()+i);
720 
721  if (source->getReferenceCount() <= 1)
722  CAUDIO_DELETE source;
723  else
724  source->drop();
725 
726  break;
727  }
728  }
729  }
730  }
731 };
virtual void logError(const char *sender, const char *msg,...)=0
Used to log an error message to the logging system.
virtual bool isStopped() const =0
Returns if the source is stopped.
virtual IAudioSource * createFromAudioBuffer(const char *name, AudioCaptureBuffer *pBiffer, unsigned int frequency, AudioFormats format)
Creates an Audio Source from AudioCaptureBuffer in a memory buffer.
virtual void setMasterVolume(float vol)
Sets master volume. (valid range [0 - 1.0])
virtual void stopAllSounds()
Stops all playing sounds.
virtual bool registerDataSource(IDataSourceFactory *factory, const char *name, int priority)
Registers a data source with this manager.
virtual IAudioSource * createFromMemory(const char *name, const char *data, size_t length, const char *extension)
Creates an Audio Source from a memory buffer using a specific audio codec.
virtual bool isValid() const =0
Returns if the source is ready to be used.
virtual bool isAudioDecoderRegistered(const char *extension)
Returns whether an audio decoder is currently registered for this file type.
Interface for data providers in cAudio.
Definition: IDataSource.h:12
virtual bool isValid()
Returns whether the source is valid.
virtual float getDopplerFactor() const
Get Doppler Factor.
virtual bool update()=0
Normally called every frame by the audio manager to update the internal buffers. Note: For internal u...
cAudioString getExt(const cAudioString &filename)
Grabs the current extention of a given string.
Definition: cUtils.h:26
virtual void unRegisterAllEventHandlers()
Unregisters all previously registered event handlers from the manager.
virtual IAudioSource * play3D(const char *filename, cVector3 position, bool playLooped=false, bool startPaused=false)
Creates an Audio Source object using the highest priority data source that has the referenced filenam...
virtual bool isValid()=0
Returns whether the source is valid.
virtual void logInfo(const char *sender, const char *msg,...)=0
Used to log an informational message to the logging system.
virtual void registerEventHandler(IManagerEventHandler *handler)
Registers a new event handler with the manager.
virtual bool isValid()=0
Returns whether the stream is valid for this codec.
Interface for event handlers for playback manager events.
virtual IDataSource * CreateDataSource(const char *filename, bool streamingRequested)=0
Creates a data source instance for use with the engine.
Interface for factories that create Audio Decoders for cAudio.
virtual void unRegisterAllDataSources()
Removes all previously registered data sources.
Interface for a single audio source, which allow you to manipulate sound sources (speakers) in 2D or ...
Definition: IAudioSource.h:32
virtual bool registerAudioDecoder(IAudioDecoderFactory *factory, const char *extension)
Register an Audio Decoder.
virtual bool initialize(const char *deviceName=0x0, int outputFrequency=-1, int eaxEffectSlots=4)
Initializes the manager.
virtual IDataSourceFactory * getDataSourceFactory(const char *name)
Returns a previously registered data source factory.
virtual void grab()
Increments the reference count by one.
Definition: IRefCounted.h:19
virtual void update()
If threading is disabled, you must call this function every frame to update the playback buffers of a...
virtual void releaseAllSources()
Releases ALL Audio Sources (but does not shutdown the manager)
virtual bool drop()
Decrements the reference count by one. If it hits zero, this object is deleted.
Definition: IRefCounted.h:25
virtual void unRegisterAudioDecoder(const char *extension)
Unregister a previously registered Audio Decoder.
virtual float getMasterVolume() const
Get the master volume.
virtual IAudioSource * getSoundByName(const char *name)
Returns an Audio Source by its "name" and NULL if the name is not found.
virtual void release(IAudioSource *source)
Releases a single Audio Source, removing it from the manager.
virtual IAudioBuffer * createBuffer(const char *filename)
Creates a Audio Sample using the highest priority data source that has the referenced filename...
virtual bool play3d(const cVector3 &position, const float &soundstr=1.0, const bool &toLoop=false)=0
Plays the source in 3D mode.
Class for manipulating vectors in 3D space.
Definition: cVector3.h:22
virtual IAudioSource * createFromRaw(const char *name, const char *data, size_t length, unsigned int frequency, AudioFormats format)
Creates an Audio Source from raw audio data in a memory buffer.
virtual void setDopplerFactor(float factor) const
Set Doppler Factor.
int getReferenceCount() const
Returns the current reference count of this object.
Definition: IRefCounted.h:37
virtual void shutDown()
Shuts the manager down, cleaning up audio sources in the process. Does not clean up decoders...
virtual bool isDataSourceRegistered(const char *name)
Returns whether a data source is currently registered under a certain name.
Interface for creating data sources for use with the engine.
virtual cAudioString getType() const =0
Returns the IAudioDecoderType.
Class used to read from a memory buffer.
Definition: cMemorySource.h:13
virtual IAudioDecoder * CreateAudioDecoder(IDataSource *stream)=0
Returns an audio decoder.
virtual void unRegisterDataSource(const char *name)
Removes a previously registered data source.
virtual bool isUpdateThreadRunning()
Returns if the thread used to update all Audio Managers is running.
virtual void unRegisterEventHandler(IManagerEventHandler *handler)
Unregisters a previously registered event handler from the manager.
interface for a sample (audio buffer): completely loaded into memory, shareable across sources ...
Definition: IAudioSource.h:18
virtual IAudioSource * createStatic(IAudioBuffer *buffer)
Creates an Audio Source from an Audio Buffer object (see createAudioBuffer())
virtual bool play2d(const bool &toLoop=false)=0
Plays the source in 2D mode.
virtual void unRegisterAllAudioDecoders()
Unregisters all attached Audio Decoders.
virtual void setSpeedOfSound(float speed)
Set Speed of Sound (for doppler computations)
virtual IAudioDecoderFactory * getAudioDecoderFactory(const char *extension)
Returns a registered audio decoder factory.
virtual float getSpeedOfSound() const
Get Speed of Sound (for doppler computations)
virtual IAudioSource * play2D(const char *filename, bool playLooped=false, bool startPaused=false)
Creates an Audio Source object using the highest priority data source that has the referenced filenam...
virtual IAudioSource * create(const char *name, const char *filename, bool stream=false)
Creates an Audio Source object using the highest priority data source that has the referenced filenam...
CAUDIO_API ILogger * getLogger()
Gets the interface to the logger.
Definition: cAudio.cpp:45
Interface for all Audio Decoders in cAudio.
Definition: IAudioDecoder.h:15
CAUDIO_API void cAudioSleep(unsigned int ms)
Causes the current thread to give up control for a certain duration.
Definition: cAudioSleep.cpp:17
AudioFormats
Enumeration of audio formats supported by the engine.
Definition: EAudioFormats.h:10
Main namespace for the entire cAudio library.
Definition: cAudioCapture.h:15