cAudio 2.3.0
3d Audio Engine
Loading...
Searching...
No Matches
cEffect.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 "cEffect.h"
6#include "cLogger.h"
7#include "cUtils.h"
8#include "cAudio.h"
9
10#if CAUDIO_EFX_ENABLED == 1
11
12namespace cAudio
13{
14 cEffect::cEffect(cEFXFunctions* oALFunctions) : EFX(oALFunctions), Type(EET_NULL),
15 Volume(1.0f), IgnoreAttenuation(false), LastUpdated(0), Valid(false), Filter(NULL),
16 Effect(0), EffectSlot(0)
17 {
18 cAudioMutexBasicLock lock(Mutex);
19 if(EFX)
20 {
21 if(EFX->Supported)
22 {
23 cAudioMutexBasicLock lock(EFX->Mutex);
24
25 //Create Effect Slot
26 EFX->alGenAuxiliaryEffectSlots(1, &EffectSlot);
27 bool error = CheckError();
28 if(error)
29 {
30 EffectSlot = 0;
31 return;
32 }
33
34 //Create the effect object
35 EFX->alGenEffects(1, &Effect);
36 error = CheckError();
37 if(error)
38 {
39 EFX->alDeleteAuxiliaryEffectSlots(1, &EffectSlot);
40 EffectSlot = 0;
41 Effect = 0;
42 return;
43 }
44
45 //Bind the effect to the effect slot
46 EFX->alAuxiliaryEffectSloti(EffectSlot, AL_EFFECTSLOT_EFFECT, Effect);
47 error = CheckError();
48 if(error)
49 {
50 EFX->alDeleteEffects(1, &Effect);
51 EFX->alDeleteAuxiliaryEffectSlots(1, &EffectSlot);
52 EffectSlot = 0;
53 Effect = 0;
54 return;
55 }
56
57 //Everything worked, effect is ready to use
58 Valid = true;
59 }
60 }
61 }
62
63 cEffect::~cEffect()
64 {
65 cAudioMutexBasicLock lock(Mutex);
66 if(EFX && EFX->Supported)
67 {
68 cAudioMutexBasicLock lock(EFX->Mutex);
69 EFX->alAuxiliaryEffectSloti(EffectSlot, AL_EFFECTSLOT_EFFECT, AL_EFFECT_NULL);
70
71 if(Effect)
72 {
73 EFX->alDeleteEffects(1, &Effect);
74 }
75
76 if(EffectSlot)
77 {
78 EFX->alDeleteAuxiliaryEffectSlots(1, &EffectSlot);
79 }
80 }
81 }
82
83 const EffectTypes& cEffect::getType() const
84 {
85 return Type;
86 }
87
88 void cEffect::setType(const EffectTypes& type)
89 {
90 cAudioMutexBasicLock lock(Mutex);
91 Type = type;
92 UpdateEffect();
93 }
94
95 const sEAXReverbParameters& cEffect::getEAXReverbParameters() const
96 {
97 return EAXReverbParam;
98 }
99
100 void cEffect::setEAXReverbParameters(const sEAXReverbParameters& param)
101 {
102 cAudioMutexBasicLock lock(Mutex);
103 EAXReverbParam = param;
104 UpdateEffect();
105 }
106
107 const sReverbParameters& cEffect::getReverbParameters() const
108 {
109 return ReverbParam;
110 }
111
112 void cEffect::setReverbParameters(const sReverbParameters& param)
113 {
114 cAudioMutexBasicLock lock(Mutex);
115 ReverbParam = param;
116 UpdateEffect();
117 }
118
119 const sChorusParameters& cEffect::getChorusParameters() const
120 {
121 return ChorusParam;
122 }
123
124 void cEffect::setChorusParameters(const sChorusParameters& param)
125 {
126 cAudioMutexBasicLock lock(Mutex);
127 ChorusParam = param;
128 UpdateEffect();
129 }
130
131 const sDistortionParameters& cEffect::getDistortionParameters() const
132 {
133 return DistortionParam;
134 }
135
136 void cEffect::setDistortionParameters(const sDistortionParameters& param)
137 {
138 cAudioMutexBasicLock lock(Mutex);
139 DistortionParam = param;
140 UpdateEffect();
141 }
142
143 const sEchoParameters& cEffect::getEchoParameters() const
144 {
145 return EchoParam;
146 }
147
148 void cEffect::setEchoParameters(const sEchoParameters& param)
149 {
150 cAudioMutexBasicLock lock(Mutex);
151 EchoParam = param;
152 UpdateEffect();
153 }
154
155 const sFlangerParameters& cEffect::getFlangerParameters() const
156 {
157 return FlangerParam;
158 }
159
160 void cEffect::setFlangerParameters(const sFlangerParameters& param)
161 {
162 cAudioMutexBasicLock lock(Mutex);
163 FlangerParam = param;
164 UpdateEffect();
165 }
166
167 const sFrequencyShiftParameters& cEffect::getFrequencyShiftParameters() const
168 {
169 return FrequencyShiftParam;
170 }
171
172 void cEffect::setFrequencyShiftParameters(const sFrequencyShiftParameters& param)
173 {
174 cAudioMutexBasicLock lock(Mutex);
175 FrequencyShiftParam = param;
176 UpdateEffect();
177 }
178
179 const sVocalMorpherParameters& cEffect::getVocalMorpherParameters() const
180 {
181 return VocalMorpherParam;
182 }
183
184 void cEffect::setVocalMorpherParameters(const sVocalMorpherParameters& param)
185 {
186 cAudioMutexBasicLock lock(Mutex);
187 VocalMorpherParam = param;
188 UpdateEffect();
189 }
190
191 const sPitchShifterParameters& cEffect::getPitchShifterParameters() const
192 {
193 return PitchShifterParam;
194 }
195
196 void cEffect::setPitchShifterParameters(const sPitchShifterParameters& param)
197 {
198 cAudioMutexBasicLock lock(Mutex);
199 PitchShifterParam = param;
200 UpdateEffect();
201 }
202
203 const sRingModulatorParameters& cEffect::getRingModulatorParameters() const
204 {
205 return RingModulatorParam;
206 }
207
208 void cEffect::setRingModulatorParameters(const sRingModulatorParameters& param)
209 {
210 cAudioMutexBasicLock lock(Mutex);
211 RingModulatorParam = param;
212 UpdateEffect();
213 }
214
215 const sAutowahParameters& cEffect::getAutowahParameters() const
216 {
217 return AutowahParam;
218 }
219
220 void cEffect::setAutowahParameters(const sAutowahParameters& param)
221 {
222 cAudioMutexBasicLock lock(Mutex);
223 AutowahParam = param;
224 UpdateEffect();
225 }
226
227 const sCompressorParameters& cEffect::getCompressorParameters() const
228 {
229 return CompressorParam;
230 }
231
232 void cEffect::setCompressorParameters(const sCompressorParameters& param)
233 {
234 cAudioMutexBasicLock lock(Mutex);
235 CompressorParam = param;
236 UpdateEffect();
237 }
238
239 const sEqualizerParameters& cEffect::getEqualizerParameters() const
240 {
241 return EqualizerParam;
242 }
243
244 void cEffect::setEqualizerParameters(const sEqualizerParameters& param)
245 {
246 cAudioMutexBasicLock lock(Mutex);
247 EqualizerParam = param;
248 UpdateEffect();
249 }
250
251 float cEffect::getMasterVolume() const
252 {
253 return Volume;
254 }
255
256 void cEffect::setMasterVolume(const float& volume)
257 {
258 cAudioMutexBasicLock lock(Mutex);
259 Volume = volume;
260 UpdateEffect();
261 }
262
263 bool cEffect::isIgnoringAttenuation() const
264 {
265 return IgnoreAttenuation;
266 }
267
268 void cEffect::ignoreAttenuation(const bool& ignore)
269 {
270 cAudioMutexBasicLock lock(Mutex);
271 IgnoreAttenuation = ignore;
272 UpdateEffect();
273 }
274
275 IFilter* cEffect::getFilter() const
276 {
277 return Filter;
278 }
279
280 void cEffect::attachFilter(IFilter* filter)
281 {
282 cAudioMutexBasicLock lock(Mutex);
283 Filter = filter;
284
285 if(Filter)
286 Filter->grab();
287 UpdateEffect();
288 }
289
290 void cEffect::removeFilter()
291 {
292 cAudioMutexBasicLock lock(Mutex);
293 if(Filter)
294 Filter->drop();
295 Filter = NULL;
296 }
297
298 unsigned int cEffect::getLastUpdated() const
299 {
300 return LastUpdated;
301 }
302
303 bool cEffect::isValid() const
304 {
305 return Valid;
306 }
307
308 ALuint cEffect::getOpenALEffect() const
309 {
310 return Effect;
311 }
312
313 ALuint cEffect::getOpenALEffectSlot() const
314 {
315 return EffectSlot;
316 }
317
318 bool cEffect::UpdateEffect()
319 {
320 ++LastUpdated;
321
322 ALenum alEffectType = ConvertEffectEnum(Type);
323
324 if(EFX && EFX->Supported && EffectSlot && Effect)
325 {
326 cAudioMutexBasicLock lock(EFX->Mutex);
327 EFX->alEffecti(Effect, AL_EFFECT_TYPE, alEffectType);
328 Valid = !CheckError();
329 if(!Valid)
330 return false;
331
332 EFX->alAuxiliaryEffectSlotf(EffectSlot, AL_EFFECTSLOT_GAIN, Volume);
333 Valid = !CheckError();
334 if(!Valid)
335 return false;
336
337 EFX->alAuxiliaryEffectSloti(EffectSlot, AL_EFFECTSLOT_AUXILIARY_SEND_AUTO, IgnoreAttenuation ? AL_TRUE : AL_FALSE);
338 Valid = !CheckError();
339 if(!Valid)
340 return false;
341
342 if(Type == EET_EAX_REVERB)
343 {
344 EFX->alEffectf(Effect, AL_EAXREVERB_DENSITY, EAXReverbParam.Density);
345 EFX->alEffectf(Effect, AL_EAXREVERB_DIFFUSION, EAXReverbParam.Diffusion);
346 EFX->alEffectf(Effect, AL_EAXREVERB_GAIN, EAXReverbParam.Gain);
347 EFX->alEffectf(Effect, AL_EAXREVERB_GAINHF, EAXReverbParam.GainHF);
348 EFX->alEffectf(Effect, AL_EAXREVERB_GAINLF, EAXReverbParam.GainLF);
349 EFX->alEffectf(Effect, AL_EAXREVERB_DECAY_TIME, EAXReverbParam.DecayTime);
350 EFX->alEffectf(Effect, AL_EAXREVERB_DECAY_HFRATIO, EAXReverbParam.DecayHFRatio);
351 EFX->alEffectf(Effect, AL_EAXREVERB_DECAY_LFRATIO, EAXReverbParam.DecayLFRatio);
352 EFX->alEffectf(Effect, AL_EAXREVERB_REFLECTIONS_GAIN, EAXReverbParam.ReflectionsGain);
353 EFX->alEffectf(Effect, AL_EAXREVERB_REFLECTIONS_DELAY, EAXReverbParam.ReflectionsDelay);
354 EFX->alEffectfv(Effect, AL_EAXREVERB_REFLECTIONS_PAN, &EAXReverbParam.ReflectionsPan.x);
355 EFX->alEffectf(Effect, AL_EAXREVERB_LATE_REVERB_GAIN, EAXReverbParam.LateReverbGain);
356 EFX->alEffectf(Effect, AL_EAXREVERB_LATE_REVERB_DELAY, EAXReverbParam.LateReverbDelay);
357 EFX->alEffectfv(Effect, AL_EAXREVERB_LATE_REVERB_PAN, &EAXReverbParam.LateReverbPan.x);
358 EFX->alEffectf(Effect, AL_EAXREVERB_ECHO_TIME, EAXReverbParam.EchoTime);
359 EFX->alEffectf(Effect, AL_EAXREVERB_ECHO_DEPTH, EAXReverbParam.EchoDepth);
360 EFX->alEffectf(Effect, AL_EAXREVERB_MODULATION_TIME, EAXReverbParam.ModulationTime);
361 EFX->alEffectf(Effect, AL_EAXREVERB_MODULATION_DEPTH, EAXReverbParam.ModulationDepth);
362 EFX->alEffectf(Effect, AL_EAXREVERB_HFREFERENCE, EAXReverbParam.HFReference);
363 EFX->alEffectf(Effect, AL_EAXREVERB_LFREFERENCE, EAXReverbParam.LFReference);
364 EFX->alEffectf(Effect, AL_EAXREVERB_ROOM_ROLLOFF_FACTOR, EAXReverbParam.RoomRolloffFactor);
365 EFX->alEffectf(Effect, AL_EAXREVERB_AIR_ABSORPTION_GAINHF, EAXReverbParam.AirAbsorptionGainHF);
366 EFX->alEffecti(Effect, AL_EAXREVERB_DECAY_HFLIMIT, EAXReverbParam.DecayHFLimit ? AL_TRUE : AL_FALSE);
367 Valid = !CheckError();
368 return Valid;
369 }
370 else if(Type == EET_REVERB)
371 {
372 EFX->alEffectf(Effect, AL_REVERB_DENSITY, ReverbParam.Density);
373 EFX->alEffectf(Effect, AL_REVERB_DIFFUSION, ReverbParam.Diffusion);
374 EFX->alEffectf(Effect, AL_REVERB_GAIN, ReverbParam.Gain);
375 EFX->alEffectf(Effect, AL_REVERB_GAINHF, ReverbParam.GainHF);
376 EFX->alEffectf(Effect, AL_REVERB_DECAY_TIME, ReverbParam.DecayTime);
377 EFX->alEffectf(Effect, AL_REVERB_DECAY_HFRATIO, ReverbParam.DecayHFRatio);
378 EFX->alEffectf(Effect, AL_REVERB_REFLECTIONS_GAIN, ReverbParam.ReflectionsGain);
379 EFX->alEffectf(Effect, AL_REVERB_REFLECTIONS_DELAY, ReverbParam.ReflectionsDelay);
380 EFX->alEffectf(Effect, AL_REVERB_LATE_REVERB_GAIN, ReverbParam.LateReverbGain);
381 EFX->alEffectf(Effect, AL_REVERB_LATE_REVERB_DELAY, ReverbParam.LateReverbDelay);
382 EFX->alEffectf(Effect, AL_REVERB_ROOM_ROLLOFF_FACTOR, ReverbParam.RoomRolloffFactor);
383 EFX->alEffectf(Effect, AL_REVERB_AIR_ABSORPTION_GAINHF, ReverbParam.AirAbsorptionGainHF);
384 EFX->alEffecti(Effect, AL_REVERB_DECAY_HFLIMIT, ReverbParam.DecayHFLimit ? AL_TRUE : AL_FALSE);
385 Valid = !CheckError();
386 return Valid;
387 }
388 else if(Type == EET_CHORUS)
389 {
390 ALenum waveform = AL_CHORUS_DEFAULT_WAVEFORM;
391 switch(ChorusParam.Waveform)
392 {
393 case sChorusParameters::ECW_SINUSOID:
394 waveform = AL_CHORUS_WAVEFORM_SINUSOID;
395 break;
396 case sChorusParameters::ECW_TRIANGLE:
397 waveform = AL_CHORUS_WAVEFORM_TRIANGLE;
398 break;
399 default:
400 waveform = AL_CHORUS_DEFAULT_WAVEFORM;
401 break;
402 };
403 EFX->alEffecti(Effect, AL_CHORUS_WAVEFORM, waveform);
404 EFX->alEffecti(Effect, AL_CHORUS_PHASE, ChorusParam.Phase);
405 EFX->alEffectf(Effect, AL_CHORUS_RATE, ChorusParam.Rate);
406 EFX->alEffectf(Effect, AL_CHORUS_DEPTH, ChorusParam.Depth);
407 EFX->alEffectf(Effect, AL_CHORUS_FEEDBACK, ChorusParam.Feedback);
408 EFX->alEffectf(Effect, AL_CHORUS_DELAY, ChorusParam.Delay);
409 Valid = !CheckError();
410 return Valid;
411 }
412 else if(Type == EET_DISTORTION)
413 {
414 EFX->alEffectf(Effect, AL_DISTORTION_EDGE, DistortionParam.Edge);
415 EFX->alEffectf(Effect, AL_DISTORTION_GAIN, DistortionParam.Gain);
416 EFX->alEffectf(Effect, AL_DISTORTION_LOWPASS_CUTOFF, DistortionParam.LowpassCutoff);
417 EFX->alEffectf(Effect, AL_DISTORTION_EQCENTER, DistortionParam.EqCenter);
418 EFX->alEffectf(Effect, AL_DISTORTION_EQBANDWIDTH, DistortionParam.EqBandwidth);
419 Valid = !CheckError();
420 return Valid;
421 }
422 else if(Type == EET_ECHO)
423 {
424 EFX->alEffectf(Effect, AL_ECHO_DELAY, EchoParam.Delay);
425 EFX->alEffectf(Effect, AL_ECHO_LRDELAY, EchoParam.LRDelay);
426 EFX->alEffectf(Effect, AL_ECHO_DAMPING, EchoParam.Damping);
427 EFX->alEffectf(Effect, AL_ECHO_FEEDBACK, EchoParam.Feedback);
428 EFX->alEffectf(Effect, AL_ECHO_SPREAD, EchoParam.Spread);
429 Valid = !CheckError();
430 return Valid;
431 }
432 else if(Type == EET_FLANGER)
433 {
434 ALenum waveform = AL_FLANGER_DEFAULT_WAVEFORM;
435 switch(FlangerParam.Waveform)
436 {
437 case sFlangerParameters::EFW_SINUSOID:
438 waveform = AL_FLANGER_WAVEFORM_SINUSOID;
439 break;
440 case sFlangerParameters::EFW_TRIANGLE:
441 waveform = AL_FLANGER_WAVEFORM_SINUSOID;
442 break;
443 default:
444 waveform = AL_FLANGER_DEFAULT_WAVEFORM;
445 break;
446 };
447 EFX->alEffecti(Effect, AL_FLANGER_WAVEFORM, waveform);
448 EFX->alEffecti(Effect, AL_FLANGER_PHASE, FlangerParam.Phase);
449 EFX->alEffectf(Effect, AL_FLANGER_RATE, FlangerParam.Rate);
450 EFX->alEffectf(Effect, AL_FLANGER_DEPTH, FlangerParam.Depth);
451 EFX->alEffectf(Effect, AL_FLANGER_FEEDBACK, FlangerParam.Feedback);
452 EFX->alEffectf(Effect, AL_FLANGER_DELAY, FlangerParam.Delay);
453 Valid = !CheckError();
454 return Valid;
455 }
456 else if(Type == EET_FREQUENCY_SHIFTER)
457 {
458 ALenum shiftleft = ConvertFrequencyShiftEnum(FrequencyShiftParam.Left);
459 ALenum shiftright = ConvertFrequencyShiftEnum(FrequencyShiftParam.Right);
460 EFX->alEffectf(Effect, AL_FREQUENCY_SHIFTER_FREQUENCY, FrequencyShiftParam.Frequency);
461 EFX->alEffecti(Effect, AL_FREQUENCY_SHIFTER_LEFT_DIRECTION, shiftleft);
462 EFX->alEffecti(Effect, AL_FREQUENCY_SHIFTER_RIGHT_DIRECTION, shiftright);
463 Valid = !CheckError();
464 return Valid;
465 }
466 else if(Type == EET_VOCAL_MORPHER)
467 {
468 ALenum pA = ConvertVocalMorphPhonemeEnum(VocalMorpherParam.PhonemeA);
469 ALenum pB = ConvertVocalMorphPhonemeEnum(VocalMorpherParam.PhonemeB);
470
471 ALenum waveform = AL_VOCAL_MORPHER_DEFAULT_WAVEFORM;
472 switch(VocalMorpherParam.Waveform)
473 {
474 case sVocalMorpherParameters::EMW_SINUSOID:
475 waveform = AL_VOCAL_MORPHER_WAVEFORM_SINUSOID;
476 break;
477 case sVocalMorpherParameters::EMW_TRIANGLE:
478 waveform = AL_VOCAL_MORPHER_WAVEFORM_TRIANGLE;
479 break;
480 case sVocalMorpherParameters::EMW_SAW:
481 waveform = AL_VOCAL_MORPHER_WAVEFORM_SAWTOOTH;
482 break;
483 default:
484 waveform = AL_VOCAL_MORPHER_DEFAULT_WAVEFORM;
485 break;
486 };
487
488 EFX->alEffecti(Effect, AL_VOCAL_MORPHER_PHONEMEA, pA);
489 EFX->alEffecti(Effect, AL_VOCAL_MORPHER_PHONEMEB, pB);
490 EFX->alEffecti(Effect, AL_VOCAL_MORPHER_PHONEMEA_COARSE_TUNING, VocalMorpherParam.PhonemeACoarseTune);
491 EFX->alEffecti(Effect, AL_VOCAL_MORPHER_PHONEMEB_COARSE_TUNING, VocalMorpherParam.PhonemeBCoarseTune);
492 EFX->alEffecti(Effect, AL_VOCAL_MORPHER_WAVEFORM, waveform);
493 EFX->alEffectf(Effect, AL_VOCAL_MORPHER_RATE, VocalMorpherParam.Rate);
494 Valid = !CheckError();
495 return Valid;
496 }
497 else if(Type == EET_PITCH_SHIFTER)
498 {
499 EFX->alEffecti(Effect, AL_PITCH_SHIFTER_COARSE_TUNE, PitchShifterParam.CoarseTune);
500 EFX->alEffecti(Effect, AL_PITCH_SHIFTER_FINE_TUNE, PitchShifterParam.FineTune);
501 Valid = !CheckError();
502 return Valid;
503 }
504 else if(Type == EET_RING_MODULATOR)
505 {
506 ALenum waveform = AL_RING_MODULATOR_DEFAULT_WAVEFORM;
507 switch(RingModulatorParam.Waveform)
508 {
509 case sRingModulatorParameters::EMW_SINUSOID:
510 waveform = AL_RING_MODULATOR_SINUSOID;
511 break;
512 case sRingModulatorParameters::EMW_SAW:
513 waveform = AL_RING_MODULATOR_SAWTOOTH;
514 break;
515 case sRingModulatorParameters::EMW_SQUARE:
516 waveform = AL_RING_MODULATOR_SQUARE;
517 break;
518 default:
519 waveform = AL_RING_MODULATOR_DEFAULT_WAVEFORM;
520 break;
521 };
522
523 EFX->alEffectf(Effect, AL_RING_MODULATOR_FREQUENCY, RingModulatorParam.Frequency);
524 EFX->alEffectf(Effect, AL_RING_MODULATOR_HIGHPASS_CUTOFF, RingModulatorParam.HighPassCutoff);
525 EFX->alEffecti(Effect, AL_RING_MODULATOR_WAVEFORM, waveform);
526 Valid = !CheckError();
527 return Valid;
528 }
529 else if(Type == EET_AUTOWAH)
530 {
531 EFX->alEffectf(Effect, AL_AUTOWAH_ATTACK_TIME, AutowahParam.AttackTime);
532 EFX->alEffectf(Effect, AL_AUTOWAH_RELEASE_TIME, AutowahParam.ReleaseTime);
533 EFX->alEffectf(Effect, AL_AUTOWAH_RESONANCE, AutowahParam.Resonance);
534 EFX->alEffectf(Effect, AL_AUTOWAH_PEAK_GAIN, AutowahParam.PeakGain);
535 Valid = !CheckError();
536 return Valid;
537 }
538 else if(Type == EET_COMPRESSOR)
539 {
540 EFX->alEffecti(Effect, AL_COMPRESSOR_ONOFF, CompressorParam.Active ? AL_TRUE : AL_FALSE);
541 Valid = !CheckError();
542 return Valid;
543 }
544 else if(Type == EET_EQUALIZER)
545 {
546 EFX->alEffectf(Effect, AL_EQUALIZER_LOW_GAIN, EqualizerParam.LowGain);
547 EFX->alEffectf(Effect, AL_EQUALIZER_LOW_CUTOFF, EqualizerParam.LowCutoff);
548 EFX->alEffectf(Effect, AL_EQUALIZER_MID1_GAIN, EqualizerParam.Mid1Gain);
549 EFX->alEffectf(Effect, AL_EQUALIZER_MID1_CENTER, EqualizerParam.Mid1Center);
550 EFX->alEffectf(Effect, AL_EQUALIZER_MID1_WIDTH, EqualizerParam.Mid1Width);
551 EFX->alEffectf(Effect, AL_EQUALIZER_MID2_GAIN, EqualizerParam.Mid2Gain);
552 EFX->alEffectf(Effect, AL_EQUALIZER_MID2_CENTER, EqualizerParam.Mid2Center);
553 EFX->alEffectf(Effect, AL_EQUALIZER_MID2_WIDTH, EqualizerParam.Mid2Width);
554 EFX->alEffectf(Effect, AL_EQUALIZER_HIGH_GAIN, EqualizerParam.HighGain);
555 EFX->alEffectf(Effect, AL_EQUALIZER_HIGH_CUTOFF, EqualizerParam.HighCutoff);
556 Valid = !CheckError();
557 return Valid;
558 }
559 else
560 {
561 return true;
562 }
563 }
564 return false;
565 }
566
567 bool cEffect::CheckError()
568 {
569 int error = alGetError();
570 const char* errorString;
571
572 if (error != AL_NO_ERROR)
573 {
574 errorString = alGetString(error);
575 if(error == AL_OUT_OF_MEMORY)
576 getLogger()->logCritical("Audio Effect", "OpenAL Error: %s.", errorString);
577 else
578 getLogger()->logError("Audio Effect", "OpenAL Error: %s.", errorString);
579 return true;
580 }
581 return false;
582 }
583
584 ALenum cEffect::ConvertEffectEnum(EffectTypes type)
585 {
586 switch(type)
587 {
588 case EET_NULL:
589 return AL_EFFECT_NULL;
590 case EET_EAX_REVERB:
591 return AL_EFFECT_EAXREVERB;
592 case EET_REVERB:
593 return AL_EFFECT_REVERB;
594 case EET_CHORUS:
595 return AL_EFFECT_CHORUS;
596 case EET_DISTORTION:
597 return AL_EFFECT_DISTORTION;
598 case EET_ECHO:
599 return AL_EFFECT_ECHO;
600 case EET_FLANGER:
601 return AL_EFFECT_FLANGER;
602 case EET_FREQUENCY_SHIFTER:
603 return AL_EFFECT_FREQUENCY_SHIFTER;
604 case EET_VOCAL_MORPHER:
605 return AL_EFFECT_VOCAL_MORPHER;
606 case EET_PITCH_SHIFTER:
607 return AL_EFFECT_PITCH_SHIFTER;
608 case EET_RING_MODULATOR:
609 return AL_EFFECT_RING_MODULATOR;
610 case EET_AUTOWAH:
611 return AL_EFFECT_AUTOWAH;
612 case EET_COMPRESSOR:
613 return AL_EFFECT_COMPRESSOR;
614 case EET_EQUALIZER:
615 return AL_EFFECT_EQUALIZER;
616 default:
617 return AL_EFFECT_NULL;
618 };
619 }
620
621 ALenum cEffect::ConvertFrequencyShiftEnum(sFrequencyShiftParameters::ShiftDirection shift)
622 {
623 switch(shift)
624 {
625 case sFrequencyShiftParameters::ESD_DOWN:
626 return AL_FREQUENCY_SHIFTER_DIRECTION_DOWN;
627 case sFrequencyShiftParameters::ESD_UP:
628 return AL_FREQUENCY_SHIFTER_DIRECTION_UP;
629 case sFrequencyShiftParameters::ESD_OFF:
630 return AL_FREQUENCY_SHIFTER_DIRECTION_OFF;
631 default:
632 return AL_FREQUENCY_SHIFTER_DIRECTION_DOWN;
633 };
634 }
635
636 ALenum cEffect::ConvertVocalMorphPhonemeEnum(sVocalMorpherParameters::MorpherPhoneme phoneme)
637 {
638 switch(phoneme)
639 {
640 case sVocalMorpherParameters::EMP_A:
641 return AL_VOCAL_MORPHER_PHONEME_A;
642 case sVocalMorpherParameters::EMP_E:
643 return AL_VOCAL_MORPHER_PHONEME_E;
644 case sVocalMorpherParameters::EMP_I:
645 return AL_VOCAL_MORPHER_PHONEME_I;
646 case sVocalMorpherParameters::EMP_O:
647 return AL_VOCAL_MORPHER_PHONEME_O;
648 case sVocalMorpherParameters::EMP_U:
649 return AL_VOCAL_MORPHER_PHONEME_U;
650 case sVocalMorpherParameters::EMP_AA:
651 return AL_VOCAL_MORPHER_PHONEME_AA;
652 case sVocalMorpherParameters::EMP_AE:
653 return AL_VOCAL_MORPHER_PHONEME_AE;
654 case sVocalMorpherParameters::EMP_AH:
655 return AL_VOCAL_MORPHER_PHONEME_AH;
656 case sVocalMorpherParameters::EMP_AO:
657 return AL_VOCAL_MORPHER_PHONEME_AO;
658 case sVocalMorpherParameters::EMP_EH:
659 return AL_VOCAL_MORPHER_PHONEME_EH;
660 case sVocalMorpherParameters::EMP_ER:
661 return AL_VOCAL_MORPHER_PHONEME_ER;
662 case sVocalMorpherParameters::EMP_IH:
663 return AL_VOCAL_MORPHER_PHONEME_IH;
664 case sVocalMorpherParameters::EMP_IY:
665 return AL_VOCAL_MORPHER_PHONEME_IY;
666 case sVocalMorpherParameters::EMP_UH:
667 return AL_VOCAL_MORPHER_PHONEME_UH;
668 case sVocalMorpherParameters::EMP_UW:
669 return AL_VOCAL_MORPHER_PHONEME_UW;
670 case sVocalMorpherParameters::EMP_B:
671 return AL_VOCAL_MORPHER_PHONEME_B;
672 case sVocalMorpherParameters::EMP_D:
673 return AL_VOCAL_MORPHER_PHONEME_D;
674 case sVocalMorpherParameters::EMP_F:
675 return AL_VOCAL_MORPHER_PHONEME_F;
676 case sVocalMorpherParameters::EMP_G:
677 return AL_VOCAL_MORPHER_PHONEME_G;
678 case sVocalMorpherParameters::EMP_J:
679 return AL_VOCAL_MORPHER_PHONEME_J;
680 case sVocalMorpherParameters::EMP_K:
681 return AL_VOCAL_MORPHER_PHONEME_K;
682 case sVocalMorpherParameters::EMP_L:
683 return AL_VOCAL_MORPHER_PHONEME_L;
684 case sVocalMorpherParameters::EMP_M:
685 return AL_VOCAL_MORPHER_PHONEME_M;
686 case sVocalMorpherParameters::EMP_N:
687 return AL_VOCAL_MORPHER_PHONEME_N;
688 case sVocalMorpherParameters::EMP_P:
689 return AL_VOCAL_MORPHER_PHONEME_P;
690 case sVocalMorpherParameters::EMP_R:
691 return AL_VOCAL_MORPHER_PHONEME_R;
692 case sVocalMorpherParameters::EMP_S:
693 return AL_VOCAL_MORPHER_PHONEME_S;
694 case sVocalMorpherParameters::EMP_T:
695 return AL_VOCAL_MORPHER_PHONEME_T;
696 case sVocalMorpherParameters::EMP_V:
697 return AL_VOCAL_MORPHER_PHONEME_V;
698 case sVocalMorpherParameters::EMP_Z:
699 return AL_VOCAL_MORPHER_PHONEME_Z;
700 default:
701 return AL_VOCAL_MORPHER_DEFAULT_PHONEMEA;
702 };
703 }
704};
705
706#endif
cAudio::ILogger::logCritical
virtual void logCritical(const char *sender, const char *msg,...)=0
Used to log a critical error message to the logging system.
cAudio::ILogger::logError
virtual void logError(const char *sender, const char *msg,...)=0
Used to log an error message to the logging system.
cAudio
Main namespace for the entire cAudio library.
Definition: cAudioCapture.h:16
cAudio::getLogger
CAUDIO_API ILogger * getLogger()
Gets the interface to the logger.
Definition: cAudio.cpp:45
Generated on Mon Mar 20 2023 00:00:00 for cAudio by doxygen 1.9.6