cAudio 2.3.0
3d Audio Engine
Loading...
Searching...
No Matches
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
15namespace 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
Generated on Mon Mar 20 2023 00:00:00 for cAudio by doxygen 1.9.6