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 };
cAudio::ILogger::logError
virtual void logError(const char *sender, const char *msg,...)=0
Used to log an error message to the logging system.
cAudio::cOpenALDeviceContext
Definition: cOpenALDeviceContext.h:17
cAudio::AudioFormats
AudioFormats
Enumeration of audio formats supported by the engine.
Definition: EAudioFormats.h:11
cAudio::cAudioMutexBasicLock
Definition: cMutex.h:49
cAudio::cAudioManager::createFromMemory
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.
Definition: cAudioManager.cpp:344
cAudio::cAudioManager::unRegisterAllDataSources
virtual void unRegisterAllDataSources()
Removes all previously registered data sources.
Definition: cAudioManager.cpp:556
cAudio::cMemorySource
Class used to read from a memory buffer.
Definition: cMemorySource.h:14
cAudio::cAudioManager::releaseAllSources
virtual void releaseAllSources()
Releases ALL Audio Sources (but does not shutdown the manager)
Definition: cAudioManager.cpp:662
cAudio::cAudioManager::setSpeedOfSound
virtual void setSpeedOfSound(float speed)
Set Speed of Sound (for doppler computations)
Definition: cAudioManager.cpp:238
cAudio::IAudioDecoderFactory
Interface for factories that create Audio Decoders for cAudio.
Definition: IAudioDecoderFactory.h:13
cAudio::cAudioSleep
CAUDIO_API void cAudioSleep(unsigned int ms)
Causes the current thread to give up control for a certain duration.
Definition: cAudioSleep.cpp:17
cAudio::cAudioManager::unRegisterEventHandler
virtual void unRegisterEventHandler(IManagerEventHandler *handler)
Unregisters a previously registered event handler from the manager.
Definition: cAudioManager.cpp:571
cAudio::cAudioManager::getSpeedOfSound
virtual float getSpeedOfSound() const
Get Speed of Sound (for doppler computations)
Definition: cAudioManager.cpp:244
cAudio::IDataSourceFactory::CreateDataSource
virtual IDataSource * CreateDataSource(const char *filename, bool streamingRequested)=0
Creates a data source instance for use with the engine.
cAudio::IAudioDecoder
Interface for all Audio Decoders in cAudio.
Definition: IAudioDecoder.h:16
cAudio::IDataSource::isValid
virtual bool isValid()=0
Returns whether the source is valid.
cAudio::cAudioManager::getDataSourceFactory
virtual IDataSourceFactory * getDataSourceFactory(const char *name)
Returns a previously registered data source factory.
Definition: cAudioManager.cpp:544
cAudio::IManagerEventHandler
Interface for event handlers for playback manager events.
Definition: IManagerEventHandler.h:11
cAudio::cAudioManager::createFromRaw
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.
Definition: cAudioManager.cpp:376
cAudio::IAudioSource::update
virtual bool update()=0
Normally called every frame by the audio manager to update the internal buffers. Note: For internal u...
cAudio::IAudioBuffer
interface for a sample (audio buffer): completely loaded into memory, shareable across sources
Definition: IAudioSource.h:19
cAudio::IAudioDecoder::isValid
virtual bool isValid()=0
Returns whether the stream is valid for this codec.
cAudio::cVector3
Class for manipulating vectors in 3D space.
Definition: cVector3.h:23
cAudio::cAudioManager::stopAllSounds
virtual void stopAllSounds()
Stops all playing sounds.
Definition: cAudioManager.cpp:260
cAudio::IAudioSource::isStopped
virtual bool isStopped() const =0
Returns if the source is stopped.
cAudio::cAudioManager::registerAudioDecoder
virtual bool registerAudioDecoder(IAudioDecoderFactory *factory, const char *extension)
Register an Audio Decoder.
Definition: cAudioManager.cpp:449
cAudio::cAudioManager::createFromAudioBuffer
virtual IAudioSource * createFromAudioBuffer(const char *name, AudioCaptureBuffer *pBiffer, unsigned int frequency, AudioFormats format)
Creates an Audio Source from AudioCaptureBuffer in a memory buffer.
Definition: cAudioManager.cpp:371
cAudio
Main namespace for the entire cAudio library.
Definition: cAudioCapture.h:16
cAudio::cAudioManager::isDataSourceRegistered
virtual bool isDataSourceRegistered(const char *name)
Returns whether a data source is currently registered under a certain name.
Definition: cAudioManager.cpp:536
cAudio::cAudioManager::getDopplerFactor
virtual float getDopplerFactor() const
Get Doppler Factor.
Definition: cAudioManager.cpp:255
cAudio::cAudioManager::update
virtual void update()
If threading is disabled, you must call this function every frame to update the playback buffers of a...
Definition: cAudioManager.cpp:84
cAudio::cAudioManager::release
virtual void release(IAudioSource *source)
Releases a single Audio Source, removing it from the manager.
Definition: cAudioManager.cpp:701
cAudio::getExt
cAudioString getExt(const cAudioString &filename)
Grabs the current extention of a given string.
Definition: cUtils.h:26
cAudio::cAudioManager::create
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...
Definition: cAudioManager.cpp:306
cAudio::cAudioManager::unRegisterAllEventHandlers
virtual void unRegisterAllEventHandlers()
Unregisters all previously registered event handlers from the manager.
Definition: cAudioManager.cpp:579
cAudio::cAudioManager::play2D
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...
Definition: cAudioManager.cpp:167
cAudio::IAudioSource::isValid
virtual bool isValid() const =0
Returns if the source is ready to be used.
cAudio::cAudioStaticSource
Definition: cAudioStaticSource.h:89
cAudio::cAudioManager::registerDataSource
virtual bool registerDataSource(IDataSourceFactory *factory, const char *name, int priority)
Registers a data source with this manager.
Definition: cAudioManager.cpp:501
cAudio::IAudioDecoderFactory::CreateAudioDecoder
virtual IAudioDecoder * CreateAudioDecoder(IDataSource *stream)=0
Returns an audio decoder.
cAudio::cMemorySource::isValid
virtual bool isValid()
Returns whether the source is valid.
Definition: cMemorySource.cpp:37
cAudio::cAudioManager::isUpdateThreadRunning
virtual bool isUpdateThreadRunning()
Returns if the thread used to update all Audio Managers is running.
Definition: cAudioManager.cpp:151
cAudio::cAudioManager::getMasterVolume
virtual float getMasterVolume() const
Get the master volume.
Definition: cAudioManager.cpp:233
cAudio::cAudioManager::getSoundByName
virtual IAudioSource * getSoundByName(const char *name)
Returns an Audio Source by its "name" and NULL if the name is not found.
Definition: cAudioManager.cpp:650
cAudio::cAudioManager::unRegisterAudioDecoder
virtual void unRegisterAudioDecoder(const char *extension)
Unregister a previously registered Audio Decoder.
Definition: cAudioManager.cpp:458
cAudio::cAudioManager::createStatic
virtual IAudioSource * createStatic(IAudioBuffer *buffer)
Creates an Audio Source from an Audio Buffer object (see createAudioBuffer())
Definition: cAudioManager.cpp:440
cAudio::IRefCounted::grab
virtual void grab()
Increments the reference count by one.
Definition: IRefCounted.h:19
cAudio::cAudioVector
Definition: cSTLAllocator.h:133
cAudio::cRawAudioDecoderFactory
Definition: cRawAudioDecoderFactory.h:14
cAudio::cAudioManager::createBuffer
virtual IAudioBuffer * createBuffer(const char *filename)
Creates a Audio Sample using the highest priority data source that has the referenced filename.
Definition: cAudioManager.cpp:402
cAudio::IDataSourceFactory
Interface for creating data sources for use with the engine.
Definition: IDataSourceFactory.h:13
cAudio::cAudioBuffer
Definition: cAudioStaticSource.h:7
cAudio::IAudioSource::play3d
virtual bool play3d(const cVector3 &position, const float &soundstr=1.0, const bool &toLoop=false)=0
Plays the source in 3D mode.
cAudio::IRefCounted::getReferenceCount
int getReferenceCount() const
Returns the current reference count of this object.
Definition: IRefCounted.h:37
cAudio::cAudioManager::getAudioDecoderFactory
virtual IAudioDecoderFactory * getAudioDecoderFactory(const char *extension)
Returns a registered audio decoder factory.
Definition: cAudioManager.cpp:478
cAudio::cAudioManager::shutDown
virtual void shutDown()
Shuts the manager down, cleaning up audio sources in the process. Does not clean up decoders,...
Definition: cAudioManager.cpp:52
cAudio::cAudioManager::isAudioDecoderRegistered
virtual bool isAudioDecoderRegistered(const char *extension)
Returns whether an audio decoder is currently registered for this file type.
Definition: cAudioManager.cpp:470
cAudio::cAudioManager::initialize
virtual bool initialize(const char *deviceName=0x0, int outputFrequency=-1, int eaxEffectSlots=4)
Initializes the manager.
Definition: cAudioManager.cpp:29
cAudio::AudioCaptureBuffer
Definition: IAudioCapture.h:114
cAudio::cAudioThread
Definition: cThread.h:20
cAudio::cAudioManager::unRegisterDataSource
virtual void unRegisterDataSource(const char *name)
Removes a previously registered data source.
Definition: cAudioManager.cpp:513
cAudio::IAudioSource
Interface for a single audio source, which allow you to manipulate sound sources (speakers) in 2D or ...
Definition: IAudioSource.h:33
cAudio::cAudioManager::play3D
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...
Definition: cAudioManager.cpp:196
cAudio::cAudioManager::unRegisterAllAudioDecoders
virtual void unRegisterAllAudioDecoders()
Unregisters all attached Audio Decoders.
Definition: cAudioManager.cpp:490
cAudio::IAudioSource::play2d
virtual bool play2d(const bool &toLoop=false)=0
Plays the source in 2D mode.
cAudio::IRefCounted::drop
virtual bool drop()
Decrements the reference count by one. If it hits zero, this object is deleted.
Definition: IRefCounted.h:25
cAudio::cAudioManager::setDopplerFactor
virtual void setDopplerFactor(float factor) const
Set Doppler Factor.
Definition: cAudioManager.cpp:249
cAudio::cAudioManager::setMasterVolume
virtual void setMasterVolume(float vol)
Sets master volume. (valid range [0 - 1.0])
Definition: cAudioManager.cpp:222
cAudio::IDataSource
Interface for data providers in cAudio.
Definition: IDataSource.h:13
cAudio::cAudioSource
Definition: cAudioSource.h:116
cAudio::cAudioList
Definition: cSTLAllocator.h:132
cAudio::IAudioDecoder::getType
virtual cAudioString getType() const =0
Returns the IAudioDecoderType.
cAudio::cAudioManager::registerEventHandler
virtual void registerEventHandler(IManagerEventHandler *handler)
Registers a new event handler with the manager.
Definition: cAudioManager.cpp:563
cAudio::ILogger::logInfo
virtual void logInfo(const char *sender, const char *msg,...)=0
Used to log an informational message to the logging system.
cAudio::getLogger
CAUDIO_API ILogger * getLogger()
Gets the interface to the logger.
Definition: cAudio.cpp:45