cAudio  2.3.0
3d Audio Engine
cAudioEffects.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 "cAudioEffects.h"
6 #include "cFilter.h"
7 #include "cEffect.h"
8 #include "cUtils.h"
9 
10 #if CAUDIO_EFX_ENABLED == 1
11 
12 //Number of effect slots to try to create
13 #define EFFECT_SLOTS_TO_TEST 256
14 
15 namespace cAudio
16 {
17  cAudioEffects::cAudioEffects() : MaxEffectsSupported(0)
18  {
19  for(int i=0; i<EET_COUNT; ++i)
20  SupportedEffects[i] = false;
21 
22  for(int i=0; i<EFT_COUNT; ++i)
23  SupportedFilters[i] = false;
24  }
25 
26  cAudioEffects::~cAudioEffects()
27  {
28 
29  }
30 
31  IEffect* cAudioEffects::createEffect()
32  {
33  cAudioMutexBasicLock lock(Mutex);
34  IEffect* effect = CAUDIO_NEW cEffect(&EFXInterface);
35 
36  if(effect && effect->isValid())
37  return effect;
38 
39  return NULL;
40  }
41 
42  IFilter* cAudioEffects::createFilter()
43  {
44  cAudioMutexBasicLock lock(Mutex);
45  IFilter* filter = CAUDIO_NEW cFilter(&EFXInterface);
46 
47  if(filter && filter->isValid())
48  return filter;
49 
50  return NULL;
51  }
52 
53  unsigned int cAudioEffects::getMaxEffectsSupported() const
54  {
55  return MaxEffectsSupported;
56  }
57 
58  bool cAudioEffects::isEffectSupported(const EffectTypes& type) const
59  {
60  return SupportedEffects[type];
61  }
62 
63  bool cAudioEffects::isFilterSupported(const FilterTypes& type) const
64  {
65  return SupportedFilters[type];
66  }
67 
68  bool cAudioEffects::addEAXReverbEffectPreset(const char* name, const sEAXReverbParameters& setting)
69  {
70  cAudioMutexBasicLock lock(Mutex);
71  cAudioString safeName = fromUTF8(name);
72  EAXReverbPresets[safeName] = setting;
73  return true;
74  }
75 
76  bool cAudioEffects::addReverbEffectPreset(const char* name, const sReverbParameters& setting)
77  {
78  cAudioMutexBasicLock lock(Mutex);
79  cAudioString safeName = fromUTF8(name);
80  ReverbPresets[safeName] = setting;
81  return true;
82  }
83 
84  bool cAudioEffects::addChorusEffectPreset(const char* name, const sChorusParameters& setting)
85  {
86  cAudioMutexBasicLock lock(Mutex);
87  cAudioString safeName = fromUTF8(name);
88  ChorusPresets[safeName] = setting;
89  return true;
90  }
91 
92  bool cAudioEffects::addDistortionEffectPreset(const char* name, const sDistortionParameters& setting)
93  {
94  cAudioMutexBasicLock lock(Mutex);
95  cAudioString safeName = fromUTF8(name);
96  DistortionPresets[safeName] = setting;
97  return true;
98  }
99 
100  bool cAudioEffects::addEchoEffectPreset(const char* name, const sEchoParameters& setting)
101  {
102  cAudioMutexBasicLock lock(Mutex);
103  cAudioString safeName = fromUTF8(name);
104  EchoPresets[safeName] = setting;
105  return true;
106  }
107 
108  bool cAudioEffects::addFlangerEffectPreset(const char* name, const sFlangerParameters& setting)
109  {
110  cAudioMutexBasicLock lock(Mutex);
111  cAudioString safeName = fromUTF8(name);
112  FlangerPresets[safeName] = setting;
113  return true;
114  }
115 
116  bool cAudioEffects::addFrequencyShiftEffectPreset(const char* name, const sFrequencyShiftParameters& setting)
117  {
118  cAudioMutexBasicLock lock(Mutex);
119  cAudioString safeName = fromUTF8(name);
120  FrequencyShiftPresets[safeName] = setting;
121  return true;
122  }
123 
124  bool cAudioEffects::addVocalMorpherEffectPreset(const char* name, const sVocalMorpherParameters& setting)
125  {
126  cAudioMutexBasicLock lock(Mutex);
127  cAudioString safeName = fromUTF8(name);
128  VocalMorpherPresets[safeName] = setting;
129  return true;
130  }
131 
132  bool cAudioEffects::addPitchShifterEffectPreset(const char* name, const sPitchShifterParameters& setting)
133  {
134  cAudioMutexBasicLock lock(Mutex);
135  cAudioString safeName = fromUTF8(name);
136  PitchShifterPresets[safeName] = setting;
137  return true;
138  }
139 
140  bool cAudioEffects::addRingModulatorEffectPreset(const char* name, const sRingModulatorParameters& setting)
141  {
142  cAudioMutexBasicLock lock(Mutex);
143  cAudioString safeName = fromUTF8(name);
144  RingModulatorPresets[safeName] = setting;
145  return true;
146  }
147 
148  bool cAudioEffects::addAutowahEffectPreset(const char* name, const sAutowahParameters& setting)
149  {
150  cAudioMutexBasicLock lock(Mutex);
151  cAudioString safeName = fromUTF8(name);
152  AutowahPresets[safeName] = setting;
153  return true;
154  }
155 
156  bool cAudioEffects::addCompressorEffectPreset(const char* name, const sCompressorParameters& setting)
157  {
158  cAudioMutexBasicLock lock(Mutex);
159  cAudioString safeName = fromUTF8(name);
160  CompressorPresets[safeName] = setting;
161  return true;
162  }
163 
164  bool cAudioEffects::addEqualizerEffectPreset(const char* name, const sEqualizerParameters& setting)
165  {
166  cAudioMutexBasicLock lock(Mutex);
167  cAudioString safeName = fromUTF8(name);
168  EqualizerPresets[safeName] = setting;
169  return true;
170  }
171 
172  sEAXReverbParameters cAudioEffects::getEAXReverbEffectPreset(const char* name)
173  {
174  cAudioMutexBasicLock lock(Mutex);
175  cAudioString safeName = fromUTF8(name);
176  cAudioMap<cAudioString, sEAXReverbParameters>::Type::iterator it = EAXReverbPresets.find(safeName);
177  if(it != EAXReverbPresets.end())
178  {
179  return it->second;
180  }
181  return sEAXReverbParameters();
182  }
183 
184  sReverbParameters cAudioEffects::getReverbEffectPreset(const char* name)
185  {
186  cAudioMutexBasicLock lock(Mutex);
187  cAudioString safeName = fromUTF8(name);
188  cAudioMap<cAudioString, sReverbParameters>::Type::iterator it = ReverbPresets.find(safeName);
189  if(it != ReverbPresets.end())
190  {
191  return it->second;
192  }
193  return sReverbParameters();
194  }
195 
196  sChorusParameters cAudioEffects::getChorusEffectPreset(const char* name)
197  {
198  cAudioMutexBasicLock lock(Mutex);
199  cAudioString safeName = fromUTF8(name);
200  cAudioMap<cAudioString, sChorusParameters>::Type::iterator it = ChorusPresets.find(safeName);
201  if(it != ChorusPresets.end())
202  {
203  return it->second;
204  }
205  return sChorusParameters();
206  }
207 
208  sDistortionParameters cAudioEffects::getDistortionEffectPreset(const char* name)
209  {
210  cAudioMutexBasicLock lock(Mutex);
211  cAudioString safeName = fromUTF8(name);
212  cAudioMap<cAudioString, sDistortionParameters>::Type::iterator it = DistortionPresets.find(safeName);
213  if(it != DistortionPresets.end())
214  {
215  return it->second;
216  }
217  return sDistortionParameters();
218  }
219 
220  sEchoParameters cAudioEffects::getEchoEffectPreset(const char* name)
221  {
222  cAudioMutexBasicLock lock(Mutex);
223  cAudioString safeName = fromUTF8(name);
224  cAudioMap<cAudioString, sEchoParameters>::Type::iterator it = EchoPresets.find(safeName);
225  if(it != EchoPresets.end())
226  {
227  return it->second;
228  }
229  return sEchoParameters();
230  }
231 
232  sFlangerParameters cAudioEffects::getFlangerEffectPreset(const char* name)
233  {
234  cAudioMutexBasicLock lock(Mutex);
235  cAudioString safeName = fromUTF8(name);
236  cAudioMap<cAudioString, sFlangerParameters>::Type::iterator it = FlangerPresets.find(safeName);
237  if(it != FlangerPresets.end())
238  {
239  return it->second;
240  }
241  return sFlangerParameters();
242  }
243 
244  sFrequencyShiftParameters cAudioEffects::getFrequencyShiftEffectPreset(const char* name)
245  {
246  cAudioMutexBasicLock lock(Mutex);
247  cAudioString safeName = fromUTF8(name);
248  cAudioMap<cAudioString, sFrequencyShiftParameters>::Type::iterator it = FrequencyShiftPresets.find(safeName);
249  if(it != FrequencyShiftPresets.end())
250  {
251  return it->second;
252  }
253  return sFrequencyShiftParameters();
254  }
255 
256  sVocalMorpherParameters cAudioEffects::getVocalMorpherEffectPreset(const char* name)
257  {
258  cAudioMutexBasicLock lock(Mutex);
259  cAudioString safeName = fromUTF8(name);
260  cAudioMap<cAudioString, sVocalMorpherParameters>::Type::iterator it = VocalMorpherPresets.find(safeName);
261  if(it != VocalMorpherPresets.end())
262  {
263  return it->second;
264  }
265  return sVocalMorpherParameters();
266  }
267 
268  sPitchShifterParameters cAudioEffects::getPitchShifterEffectPreset(const char* name)
269  {
270  cAudioMutexBasicLock lock(Mutex);
271  cAudioString safeName = fromUTF8(name);
272  cAudioMap<cAudioString, sPitchShifterParameters>::Type::iterator it = PitchShifterPresets.find(safeName);
273  if(it != PitchShifterPresets.end())
274  {
275  return it->second;
276  }
277  return sPitchShifterParameters();
278  }
279 
280  sRingModulatorParameters cAudioEffects::getRingModulatorEffectPreset(const char* name)
281  {
282  cAudioMutexBasicLock lock(Mutex);
283  cAudioString safeName = fromUTF8(name);
284  cAudioMap<cAudioString, sRingModulatorParameters>::Type::iterator it = RingModulatorPresets.find(safeName);
285  if(it != RingModulatorPresets.end())
286  {
287  return it->second;
288  }
289  return sRingModulatorParameters();
290  }
291 
292  sAutowahParameters cAudioEffects::getAutowahEffectPreset(const char* name)
293  {
294  cAudioMutexBasicLock lock(Mutex);
295  cAudioString safeName = fromUTF8(name);
296  cAudioMap<cAudioString, sAutowahParameters>::Type::iterator it = AutowahPresets.find(safeName);
297  if(it != AutowahPresets.end())
298  {
299  return it->second;
300  }
301  return sAutowahParameters();
302  }
303 
304  sCompressorParameters cAudioEffects::getCompressorEffectPreset(const char* name)
305  {
306  cAudioMutexBasicLock lock(Mutex);
307  cAudioString safeName = fromUTF8(name);
308  cAudioMap<cAudioString, sCompressorParameters>::Type::iterator it = CompressorPresets.find(safeName);
309  if(it != CompressorPresets.end())
310  {
311  return it->second;
312  }
313  return sCompressorParameters();
314  }
315 
316  sEqualizerParameters cAudioEffects::getEqualizerEffectPreset(const char* name)
317  {
318  cAudioMutexBasicLock lock(Mutex);
319  cAudioString safeName = fromUTF8(name);
320  cAudioMap<cAudioString, sEqualizerParameters>::Type::iterator it = EqualizerPresets.find(safeName);
321  if(it != EqualizerPresets.end())
322  {
323  return it->second;
324  }
325  return sEqualizerParameters();
326  }
327 
328  void cAudioEffects::removeEffectPreset(const EffectTypes& type, const char* name)
329  {
330  cAudioMutexBasicLock lock(Mutex);
331  cAudioString safeName = fromUTF8(name);
332  switch(type)
333  {
334  case EET_EAX_REVERB:
335  EAXReverbPresets.erase(safeName);
336  break;
337  case EET_REVERB:
338  ReverbPresets.erase(safeName);
339  break;
340  case EET_CHORUS:
341  ChorusPresets.erase(safeName);
342  break;
343  case EET_DISTORTION:
344  DistortionPresets.erase(safeName);
345  break;
346  case EET_ECHO:
347  EchoPresets.erase(safeName);
348  break;
349  case EET_FLANGER:
350  FlangerPresets.erase(safeName);
351  break;
352  case EET_FREQUENCY_SHIFTER:
353  FrequencyShiftPresets.erase(safeName);
354  break;
355  case EET_VOCAL_MORPHER:
356  VocalMorpherPresets.erase(safeName);
357  break;
358  case EET_PITCH_SHIFTER:
359  PitchShifterPresets.erase(safeName);
360  break;
361  case EET_RING_MODULATOR:
362  RingModulatorPresets.erase(safeName);
363  break;
364  case EET_AUTOWAH:
365  AutowahPresets.erase(safeName);
366  break;
367  case EET_COMPRESSOR:
368  CompressorPresets.erase(safeName);
369  break;
370  case EET_EQUALIZER:
371  EqualizerPresets.erase(safeName);
372  break;
373  default:
374  break;
375  }
376  }
377 
378  bool cAudioEffects::isEffectPresetRegistered(const EffectTypes& type, const char* name)
379  {
380  cAudioMutexBasicLock lock(Mutex);
381  cAudioString safeName = fromUTF8(name);
382  switch(type)
383  {
384  case EET_EAX_REVERB:
385  return (EAXReverbPresets.find(safeName) != EAXReverbPresets.end());
386  break;
387  case EET_REVERB:
388  return (ReverbPresets.find(safeName) != ReverbPresets.end());
389  break;
390  case EET_CHORUS:
391  return (ChorusPresets.find(safeName) != ChorusPresets.end());
392  break;
393  case EET_DISTORTION:
394  return (DistortionPresets.find(safeName) != DistortionPresets.end());
395  break;
396  case EET_ECHO:
397  return (EchoPresets.find(safeName) != EchoPresets.end());
398  break;
399  case EET_FLANGER:
400  return (FlangerPresets.find(safeName) != FlangerPresets.end());
401  break;
402  case EET_FREQUENCY_SHIFTER:
403  return (FrequencyShiftPresets.find(safeName) != FrequencyShiftPresets.end());
404  break;
405  case EET_VOCAL_MORPHER:
406  return (VocalMorpherPresets.find(safeName) != VocalMorpherPresets.end());
407  break;
408  case EET_PITCH_SHIFTER:
409  return (PitchShifterPresets.find(safeName) != PitchShifterPresets.end());
410  break;
411  case EET_RING_MODULATOR:
412  return (RingModulatorPresets.find(safeName) != RingModulatorPresets.end());
413  break;
414  case EET_AUTOWAH:
415  return (AutowahPresets.find(safeName) != AutowahPresets.end());
416  break;
417  case EET_COMPRESSOR:
418  return (CompressorPresets.find(safeName) != CompressorPresets.end());
419  break;
420  case EET_EQUALIZER:
421  return (EqualizerPresets.find(safeName) != EqualizerPresets.end());
422  break;
423  default:
424  return false;
425  break;
426  }
427  }
428 
429  void cAudioEffects::removeAllEffectPresets(const EffectTypes& type)
430  {
431  switch(type)
432  {
433  case EET_EAX_REVERB:
434  EAXReverbPresets.clear();
435  break;
436  case EET_REVERB:
437  ReverbPresets.clear();
438  break;
439  case EET_CHORUS:
440  ChorusPresets.clear();
441  break;
442  case EET_DISTORTION:
443  DistortionPresets.clear();
444  break;
445  case EET_ECHO:
446  EchoPresets.clear();
447  break;
448  case EET_FLANGER:
449  FlangerPresets.clear();
450  break;
451  case EET_FREQUENCY_SHIFTER:
452  FrequencyShiftPresets.clear();
453  break;
454  case EET_VOCAL_MORPHER:
455  VocalMorpherPresets.clear();
456  break;
457  case EET_PITCH_SHIFTER:
458  PitchShifterPresets.clear();
459  break;
460  case EET_RING_MODULATOR:
461  RingModulatorPresets.clear();
462  break;
463  case EET_AUTOWAH:
464  AutowahPresets.clear();
465  break;
466  case EET_COMPRESSOR:
467  CompressorPresets.clear();
468  break;
469  case EET_EQUALIZER:
470  EqualizerPresets.clear();
471  break;
472  default:
473  EAXReverbPresets.clear();
474  ReverbPresets.clear();
475  ChorusPresets.clear();
476  DistortionPresets.clear();
477  EchoPresets.clear();
478  FlangerPresets.clear();
479  FrequencyShiftPresets.clear();
480  VocalMorpherPresets.clear();
481  PitchShifterPresets.clear();
482  RingModulatorPresets.clear();
483  AutowahPresets.clear();
484  CompressorPresets.clear();
485  EqualizerPresets.clear();
486  break;
487  }
488  }
489 
490  cEFXFunctions* cAudioEffects::getEFXInterface()
491  {
492  return &EFXInterface;
493  }
494 
495  void cAudioEffects::checkEFXSupportDetails()
496  {
497  cAudioMutexBasicLock lock(Mutex);
498  if(EFXInterface.Supported)
499  {
500  cAudioMutexBasicLock lock(EFXInterface.Mutex);
501 
502  //Count the number of effect slots this device supports (limits the max number of effects available)
503  unsigned int count = 0;
504  ALuint effectSlots[EFFECT_SLOTS_TO_TEST];
505  for(count=0; count<EFFECT_SLOTS_TO_TEST; ++count)
506  {
507  EFXInterface.alGenAuxiliaryEffectSlots(1, &effectSlots[count]);
508  if(alGetError() != AL_NO_ERROR)
509  break;
510  }
511 
512  MaxEffectsSupported = count;
513 
514  //Check what effects are supported
515  ALuint Effect;
516  EFXInterface.alGenEffects(1, &Effect);
517  if (alGetError() == AL_NO_ERROR)
518  {
519  SupportedEffects[EET_NULL] = true;
520 
521  // Try setting Effect Type to known Effects
522  EFXInterface.alEffecti(Effect, AL_EFFECT_TYPE, AL_EFFECT_REVERB);
523  SupportedEffects[EET_REVERB] = (alGetError() == AL_NO_ERROR);
524 
525  EFXInterface.alEffecti(Effect, AL_EFFECT_TYPE, AL_EFFECT_EAXREVERB);
526  SupportedEffects[EET_EAX_REVERB] = (alGetError() == AL_NO_ERROR);
527 
528  EFXInterface.alEffecti(Effect, AL_EFFECT_TYPE, AL_EFFECT_CHORUS);
529  SupportedEffects[EET_CHORUS] = (alGetError() == AL_NO_ERROR);
530 
531  EFXInterface.alEffecti(Effect, AL_EFFECT_TYPE, AL_EFFECT_DISTORTION);
532  SupportedEffects[EET_DISTORTION] = (alGetError() == AL_NO_ERROR);
533 
534  EFXInterface.alEffecti(Effect, AL_EFFECT_TYPE, AL_EFFECT_ECHO);
535  SupportedEffects[EET_ECHO] = (alGetError() == AL_NO_ERROR);
536 
537  EFXInterface.alEffecti(Effect, AL_EFFECT_TYPE, AL_EFFECT_FLANGER);
538  SupportedEffects[EET_FLANGER] = (alGetError() == AL_NO_ERROR);
539 
540  EFXInterface.alEffecti(Effect, AL_EFFECT_TYPE, AL_EFFECT_FREQUENCY_SHIFTER);
541  SupportedEffects[EET_FREQUENCY_SHIFTER] = (alGetError() == AL_NO_ERROR);
542 
543  EFXInterface.alEffecti(Effect, AL_EFFECT_TYPE, AL_EFFECT_VOCAL_MORPHER);
544  SupportedEffects[EET_VOCAL_MORPHER] = (alGetError() == AL_NO_ERROR);
545 
546  EFXInterface.alEffecti(Effect, AL_EFFECT_TYPE, AL_EFFECT_PITCH_SHIFTER);
547  SupportedEffects[EET_PITCH_SHIFTER] = (alGetError() == AL_NO_ERROR);
548 
549  EFXInterface.alEffecti(Effect, AL_EFFECT_TYPE, AL_EFFECT_RING_MODULATOR);
550  SupportedEffects[EET_RING_MODULATOR] = (alGetError() == AL_NO_ERROR);
551 
552  EFXInterface.alEffecti(Effect, AL_EFFECT_TYPE, AL_EFFECT_AUTOWAH);
553  SupportedEffects[EET_AUTOWAH] = (alGetError() == AL_NO_ERROR);
554 
555  EFXInterface.alEffecti(Effect, AL_EFFECT_TYPE, AL_EFFECT_COMPRESSOR);
556  SupportedEffects[EET_COMPRESSOR] = (alGetError() == AL_NO_ERROR);
557 
558  EFXInterface.alEffecti(Effect, AL_EFFECT_TYPE, AL_EFFECT_EQUALIZER);
559  SupportedEffects[EET_EQUALIZER] = (alGetError() == AL_NO_ERROR);
560  }
561 
562  // Delete Effect
563  EFXInterface.alDeleteEffects(1, &Effect);
564 
565  // Generate a Filter to use to determine what Filter Types are supported
566  ALuint Filter;
567  EFXInterface.alGenFilters(1, &Filter);
568  if (alGetError() == AL_NO_ERROR)
569  {
570  SupportedFilters[EFT_NULL] = true;
571 
572  // Try setting the Filter type to known Filters
573  EFXInterface.alFilteri(Filter, AL_FILTER_TYPE, AL_FILTER_LOWPASS);
574  SupportedFilters[EFT_LOWPASS] = (alGetError() == AL_NO_ERROR);
575 
576  EFXInterface.alFilteri(Filter, AL_FILTER_TYPE, AL_FILTER_HIGHPASS);
577  SupportedFilters[EFT_HIGHPASS] = (alGetError() == AL_NO_ERROR);
578 
579  EFXInterface.alFilteri(Filter, AL_FILTER_TYPE, AL_FILTER_BANDPASS);
580  SupportedFilters[EFT_BANDPASS] = (alGetError() == AL_NO_ERROR);
581  }
582 
583  // Delete Filter
584  EFXInterface.alDeleteFilters(1, &Filter);
585 
586  //Cleanup the slots we created
587  while(count > 0)
588  {
589  EFXInterface.alDeleteAuxiliaryEffectSlots(1, &effectSlots[--count]);
590  }
591  }
592  }
593 
594 };
595 
596 #endif
cAudio
Main namespace for the entire cAudio library.
Definition: cAudioCapture.h:16