cAudio  2.3.0
3d Audio Engine
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 
12 namespace 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
virtual void logError(const char *sender, const char *msg,...)=0
Used to log an error message to the logging system.
cAudioMutex Mutex
Mutex for thread synchronization.
Definition: cAudioSource.h:96
virtual void logCritical(const char *sender, const char *msg,...)=0
Used to log a critical error message to the logging system.
CAUDIO_API ILogger * getLogger()
Gets the interface to the logger.
Definition: cAudio.cpp:45
Main namespace for the entire cAudio library.
Definition: cAudioCapture.h:15