audio.cpp

 
#include <scolPlugin.h>
#include "audio.h"
 
extern int AUDIO_END_CB;
 
#include <cstring>
#include <thread>
 
cScolFileSource::cScolFileSource(const char* filename) : Valid(false), pFile(NULL), Filesize(0)
{
  cAudio::cAudioString safeFilename = cAudio::fromUTF8(filename);
  if (safeFilename.length() != 0)
  {
    pFile = fopen(cAudio::toUTF8(safeFilename), "rb");
    if (pFile)
    {
      Valid = true;
    }
  }
 
  if (Valid)
  {
    fseek(pFile, 0, SEEK_END);
    Filesize = ftell(pFile);
    fseek(pFile, 0, SEEK_SET);
  }
}
 
cScolFileSource::~cScolFileSource()
{
  if (pFile)
    fclose(pFile);
}
 
bool cScolFileSource::isValid()
{
  return Valid;
}
 
int cScolFileSource::getCurrentPos()
{
  return ftell(pFile);
}
 
int cScolFileSource::getSize()
{
  return Filesize;
}
 
int cScolFileSource::read(void* output, int size)
{
  return fread(output, sizeof(char), size, pFile);
}
 
bool cScolFileSource::seek(int amount, bool relative)
{
  if (relative == true)
  {
    int oldamount = ftell(pFile);
    fseek(pFile, amount, SEEK_CUR);
 
    //check against the absolute position
    if (oldamount + amount != ftell(pFile))
      return false;
  }
  else
  {
    fseek(pFile, amount, SEEK_SET);
    if (amount != ftell(pFile))
      return false;
  }
 
  return true;
}
 
SAudioManager::SAudioManager()
{
  // create cAudio manager
  mPaused = false;
  scolDataFactory = new cScolFileSourceFactory();
  manager = cAudio::createAudioManager(true);
  manager->registerDataSource(scolDataFactory, "ScolFileSystem", 100);
  manager->registerEventHandler(this);
 
#if CAUDIO_EFX_ENABLED == 1
  mEffect = 0;
  mFilter = 0;
 
  mFilterType = cAudio::EFT_NULL;
  mFilterLowFreqVolume = 0.1f;
  mFilterHighFreqVolume = 0.1f;
  mEffectType = cAudio::EET_NULL;
 
  InitEffects();
#endif
  //effects presets
  /*
  cAudio::IAudioEffects* effects = manager->getEffects();
  if (effects)
  {
    if (effects->isEffectSupported(cAudio::EET_REVERB))
    {
      cAudio::sReverbParameters param;
      // bathroom
      param.Gain = 0.316f;
                        param.GainHF = 0.251f;
                        param.Density = 0.17f;
                        param.DecayHFRatio = 0.54f;
                        param.ReflectionsGain = 0.653f;
                        param.ReflectionsDelay = 0.01f;
                        param.LateReverbDelay = 0.01f;
                        param.LateReverbGain = 3.273f;
 
      effects->addReverbEffectPreset("Default", param);
    }
 
    if (effects->isEffectSupported(cAudio::EET_AUTOWAH))
    {
      cAudio::sAutowahParameters param;
      effects->addAutowahEffectPreset("Default", param);
    }
    
    if (effects->isEffectSupported(cAudio::EET_CHORUS))
    {
      cAudio::sChorusParameters param;
      effects->addChorusEffectPreset("Default", param);
    }
 
    if (effects->isEffectSupported(cAudio::EET_COMPRESSOR))
    {
      cAudio::sCompressorParameters param;
      effects->addCompressorEffectPreset("Default", param);
    }
 
    if (effects->isEffectSupported(cAudio::EET_DISTORTION))
    {
      cAudio::sDistortionParameters param;
      effects->addDistortionEffectPreset("Default", param);
    }
    
    if (effects->isEffectSupported(cAudio::EET_ECHO))
    {
      cAudio::sEchoParameters param;
      effects->addEchoEffectPreset("Default", param);
    }
    
    if (effects->isEffectSupported(cAudio::EET_EQUALIZER))
    {
      cAudio::sEqualizerParameters param;
      effects->addEqualizerEffectPreset("Default", param);
    }
    
    if (effects->isEffectSupported(cAudio::EET_FLANGER))
    {
      cAudio::sFlangerParameters param;
      effects->addFlangerEffectPreset("Default", param);
    }
    
    if (effects->isEffectSupported(cAudio::EET_FREQUENCY_SHIFTER))
    {
      cAudio::sFrequencyShiftParameters param;
      effects->addFrequencyShiftEffectPreset("Default", param);
    }
    
    if (effects->isEffectSupported(cAudio::EET_PITCH_SHIFTER))
    {
      cAudio::sPitchShifterParameters param;
      effects->addPitchShifterEffectPreset("Default", param);
    }
    
    if (effects->isEffectSupported(cAudio::EET_RING_MODULATOR))
    {
      cAudio::sRingModulatorParameters param;
      effects->addRingModulatorEffectPreset("Default", param);
    }
    
    if (effects->isEffectSupported(cAudio::EET_VOCAL_MORPHER))
    {
      cAudio::sVocalMorpherParameters param;
      effects->addVocalMorpherEffectPreset("Default", param);
    }
  }
  */
}
 
#if CAUDIO_EFX_ENABLED == 1
void SAudioManager::InitEffects()
{
  cAudio::IAudioEffects* effects = manager->getEffects();
  if (effects)
  {
    mEffect = effects->createEffect();
    mFilter = effects->createFilter();
 
    if (mEffect && mEffect->isValid() && mFilter && mFilter->isValid())
    {
      mFilter->setHighFrequencyVolume(mFilterHighFreqVolume);
      mFilter->setLowFrequencyVolume(mFilterLowFreqVolume);
 
      //mSound->attachFilter(mFilter);
      //mSound->attachEffect(0, mEffect);
 
      /*
      if (effects->isEffectPresetRegistered(cAudio::EET_AUTOWAH, "Default"))
      mEffect->setAutowahParameters(effects->getAutowahEffectPreset("Default"));
 
      if (effects->isEffectPresetRegistered(cAudio::EET_CHORUS, "Default"))
      mEffect->setChorusParameters(effects->getChorusEffectPreset("Default"));
 
      if (effects->isEffectPresetRegistered(cAudio::EET_COMPRESSOR, "Default"))
      mEffect->setCompressorParameters(effects->getCompressorEffectPreset("Default"));
 
      if (effects->isEffectPresetRegistered(cAudio::EET_DISTORTION, "Default"))
      mEffect->setDistortionParameters(effects->getDistortionEffectPreset("Default"));
 
      if (effects->isEffectPresetRegistered(cAudio::EET_EAX_REVERB, "Psychotic"))
      mEffect->setEAXReverbParameters(effects->getEAXReverbEffectPreset("Psychotic"));
 
      if (effects->isEffectPresetRegistered(cAudio::EET_ECHO, "Default"))
      mEffect->setEchoParameters(effects->getEchoEffectPreset("Default"));
 
      if (effects->isEffectPresetRegistered(cAudio::EET_EQUALIZER, "Default"))
      mEffect->setEqualizerParameters(effects->getEqualizerEffectPreset("Default"));
 
      if (effects->isEffectPresetRegistered(cAudio::EET_FLANGER, "Default"))
      mEffect->setFlangerParameters(effects->getFlangerEffectPreset("Default"));
 
      if (effects->isEffectPresetRegistered(cAudio::EET_FREQUENCY_SHIFTER, "Default"))
      mEffect->setFrequencyShiftParameters(effects->getFrequencyShiftEffectPreset("Default"));
 
      if (effects->isEffectPresetRegistered(cAudio::EET_PITCH_SHIFTER, "Default"))
      mEffect->setPitchShifterParameters(effects->getPitchShifterEffectPreset("Default"));
 
      if (effects->isEffectPresetRegistered(cAudio::EET_REVERB, "Default"))
      mEffect->setReverbParameters(effects->getReverbEffectPreset("Default"));
 
      if (effects->isEffectPresetRegistered(cAudio::EET_RING_MODULATOR, "Default"))
      mEffect->setRingModulatorParameters(effects->getRingModulatorEffectPreset("Default"));
 
      if (effects->isEffectPresetRegistered(cAudio::EET_VOCAL_MORPHER, "Default"))
      mEffect->setVocalMorpherParameters(effects->getVocalMorpherEffectPreset("Default"));
      */
    }
  }
}
#endif
 
SAudioManager::~SAudioManager()
{
  // destroy cAudio manager
  if (manager != 0)
  {
    validInput.clear();
    validSounds.clear();
 
    SAFE_DELETE(scolDataFactory);
    manager->unRegisterDataSource("ScolFileSystem");
    manager->unRegisterEventHandler(this);
 
    /*
    cAudio::IAudioEffects* effects = manager->getEffects();
    if (effects)
    {
      if (effects->isEffectSupported(cAudio::EET_REVERB))
        effects->removeEffectPreset(cAudio::EET_REVERB, "Default");
 
      if (effects->isEffectSupported(cAudio::EET_AUTOWAH))
        effects->removeEffectPreset(cAudio::EET_AUTOWAH, "Default");
    
      if (effects->isEffectSupported(cAudio::EET_CHORUS))
        effects->removeEffectPreset(cAudio::EET_CHORUS, "Default");
 
      if (effects->isEffectSupported(cAudio::EET_COMPRESSOR))
        effects->removeEffectPreset(cAudio::EET_COMPRESSOR, "Default");
 
      if (effects->isEffectSupported(cAudio::EET_DISTORTION))
        effects->removeEffectPreset(cAudio::EET_DISTORTION, "Default");
    
      if (effects->isEffectSupported(cAudio::EET_ECHO))
        effects->removeEffectPreset(cAudio::EET_ECHO, "Default");
    
      if (effects->isEffectSupported(cAudio::EET_EQUALIZER))
        effects->removeEffectPreset(cAudio::EET_EQUALIZER, "Default");
    
      if (effects->isEffectSupported(cAudio::EET_FLANGER))
        effects->removeEffectPreset(cAudio::EET_FLANGER, "Default");
    
      if (effects->isEffectSupported(cAudio::EET_FREQUENCY_SHIFTER))
        effects->removeEffectPreset(cAudio::EET_FREQUENCY_SHIFTER, "Default");
    
      if (effects->isEffectSupported(cAudio::EET_PITCH_SHIFTER))
        effects->removeEffectPreset(cAudio::EET_PITCH_SHIFTER, "Default");
    
      if (effects->isEffectSupported(cAudio::EET_RING_MODULATOR))
        effects->removeEffectPreset(cAudio::EET_RING_MODULATOR, "Default");
    
      if (effects->isEffectSupported(cAudio::EET_VOCAL_MORPHER))
        effects->removeEffectPreset(cAudio::EET_VOCAL_MORPHER, "Default");
    }*/
 
 
#if CAUDIO_EFX_ENABLED == 1
    if (mEffect)
      mEffect->drop();
    if (mFilter)
      mFilter->drop();
#endif
    
    cAudio::destroyAudioManager(manager);
    manager = 0;
  }
}
 
#if CAUDIO_EFX_ENABLED == 1
bool SAudioManager::SetFilter(cAudio::FilterTypes type, float lowFreqVolume, float highFreqVolume)
{
  mFilterType = type;
  mFilterLowFreqVolume = lowFreqVolume;
  mFilterHighFreqVolume = highFreqVolume;
 
  cAudio::IAudioEffects* effects = manager->getEffects();
  if (mFilter && effects && effects->isFilterSupported(type))
  {
    mFilter->setType(type);
    mFilter->setLowFrequencyVolume(lowFreqVolume);
    mFilter->setHighFrequencyVolume(highFreqVolume);
 
    return true;
  }
 
  if (mFilter)
    mFilter->setType(cAudio::EFT_NULL);
 
  return false;
}
 
bool SAudioManager::SetEffect(cAudio::EffectTypes type, std::string preset)
{
  mEffectType = type;
  mEffectPreset = preset;
 
  cAudio::IAudioEffects* effects = manager->getEffects();
 
  if ((type == cAudio::EET_REVERB) && effects && effects->isEffectSupported(cAudio::EET_EAX_REVERB))
    type = cAudio::EET_EAX_REVERB;
 
  if (mEffect && effects && effects->isEffectSupported(type))
  {
    if (effects->isEffectPresetRegistered(type, preset.c_str()))
    {
      switch (type)
      {
      case cAudio::EET_AUTOWAH:
        mEffect->setAutowahParameters(effects->getAutowahEffectPreset(preset.c_str()));
        break;
 
      case cAudio::EET_CHORUS:
        mEffect->setChorusParameters(effects->getChorusEffectPreset(preset.c_str()));
        break;
 
      case cAudio::EET_COMPRESSOR:
        mEffect->setCompressorParameters(effects->getCompressorEffectPreset(preset.c_str()));
        break;
 
      case cAudio::EET_DISTORTION:
        mEffect->setDistortionParameters(effects->getDistortionEffectPreset(preset.c_str()));
        break;
 
      case cAudio::EET_EAX_REVERB:
        mEffect->setEAXReverbParameters(effects->getEAXReverbEffectPreset(preset.c_str()));
        break;
 
      case cAudio::EET_ECHO:
        mEffect->setEchoParameters(effects->getEchoEffectPreset(preset.c_str()));
        break;
 
      case cAudio::EET_EQUALIZER:
        mEffect->setEqualizerParameters(effects->getEqualizerEffectPreset(preset.c_str()));
        break;
 
      case cAudio::EET_FLANGER:
        mEffect->setFlangerParameters(effects->getFlangerEffectPreset(preset.c_str()));
        break;
 
      case cAudio::EET_FREQUENCY_SHIFTER:
        mEffect->setFrequencyShiftParameters(effects->getFrequencyShiftEffectPreset(preset.c_str()));
        break;
 
      case cAudio::EET_PITCH_SHIFTER:
        mEffect->setPitchShifterParameters(effects->getPitchShifterEffectPreset(preset.c_str()));
        break;
 
      case cAudio::EET_REVERB:
        mEffect->setReverbParameters(effects->getReverbEffectPreset(preset.c_str()));
        break;
 
      case cAudio::EET_RING_MODULATOR:
        mEffect->setRingModulatorParameters(effects->getRingModulatorEffectPreset(preset.c_str()));
        break;
 
      case cAudio::EET_VOCAL_MORPHER:
        mEffect->setVocalMorpherParameters(effects->getVocalMorpherEffectPreset(preset.c_str()));
        break;
      }
    }
 
    mEffect->setType(type);
    return true;
  }
 
  if (mEffect)
    mEffect->setType(cAudio::EET_NULL);
 
  return false;
}
 
bool SAudioManager::SetReverbEffectParam(cAudio::sReverbParameters param)
{
  cAudio::IAudioEffects* effects = manager->getEffects();
  if (mEffect && effects && effects->isEffectSupported(cAudio::EET_REVERB))
  {
    mEffect->setReverbParameters(param);
 
    /*
    cAudio::sReverbParameters param
    param.Gain = gain; //0.316f;
    param.GainHF = gainHF; //0.251f;
    param.Density = density; //0.17f;
    param.DecayHFRatio = decayHFRatio; //0.54f;
    param.ReflectionsGain = reflectionsGain ; //0.653f;
    param.ReflectionsDelay = reflectionsDelay; //0.01f;
    param.LateReverbDelay = lateReverbDelay; //0.01f;
    param.LateReverbGain = lateReverbGain; //3.273f;
    */
 
    return true;
  }
 
  return false;
}
 
bool SAudioManager::SetAutowahEffectParam(cAudio::sAutowahParameters param)
{
  cAudio::IAudioEffects* effects = manager->getEffects();
  if (mEffect && effects && effects->isEffectSupported(cAudio::EET_AUTOWAH))
  {
    mEffect->setAutowahParameters(param);
    return true;
  }
 
  return false;
}
 
bool SAudioManager::SetChorusEffectParam(cAudio::sChorusParameters param)
{
  cAudio::IAudioEffects* effects = manager->getEffects();
  if (mEffect && effects && effects->isEffectSupported(cAudio::EET_CHORUS))
  {
    mEffect->setChorusParameters(param);
    return true;
  }
 
  return false;
}
 
bool SAudioManager::SetCompressorEffectParam(cAudio::sCompressorParameters param)
{
  cAudio::IAudioEffects* effects = manager->getEffects();
  if (mEffect && effects && effects->isEffectSupported(cAudio::EET_COMPRESSOR))
  {
    mEffect->setCompressorParameters(param);
    return true;
  }
 
  return false;
}
 
bool SAudioManager::SetDistortionEffectParam(cAudio::sDistortionParameters param)
{
  cAudio::IAudioEffects* effects = manager->getEffects();
  if (mEffect && effects && effects->isEffectSupported(cAudio::EET_DISTORTION))
  {
    mEffect->setDistortionParameters(param);
    return true;
  }
 
  return false;
}
 
bool SAudioManager::SetEchoEffectParam(cAudio::sEchoParameters param)
{
  cAudio::IAudioEffects* effects = manager->getEffects();
  if (mEffect && effects && effects->isEffectSupported(cAudio::EET_ECHO))
  {
    mEffect->setEchoParameters(param);
    return true;
  }
 
  return false;
}
 
bool SAudioManager::SetEqualizerEffectParam(cAudio::sEqualizerParameters param)
{
  cAudio::IAudioEffects* effects = manager->getEffects();
  if (mEffect && effects && effects->isEffectSupported(cAudio::EET_EQUALIZER))
  {
    mEffect->setEqualizerParameters(param);
    return true;
  }
 
  return false;
}
 
bool SAudioManager::SetFlangerEffectParam(cAudio::sFlangerParameters param)
{
  cAudio::IAudioEffects* effects = manager->getEffects();
  if (mEffect && effects && effects->isEffectSupported(cAudio::EET_FLANGER))
  {
    mEffect->setFlangerParameters(param);
    return true;
  }
 
  return false;
}
 
bool SAudioManager::SetFrequencyShiftEffectParam(cAudio::sFrequencyShiftParameters param)
{
  cAudio::IAudioEffects* effects = manager->getEffects();
  if (mEffect && effects && effects->isEffectSupported(cAudio::EET_FREQUENCY_SHIFTER))
  {
    mEffect->setFrequencyShiftParameters(param);
    return true;
  }
 
  return false;
}
 
bool SAudioManager::SetPitchShifterEffectParam(cAudio::sPitchShifterParameters param)
{
  cAudio::IAudioEffects* effects = manager->getEffects();
  if (mEffect && effects && effects->isEffectSupported(cAudio::EET_PITCH_SHIFTER))
  {
    mEffect->setPitchShifterParameters(param);
    return true;
  }
 
  return false;
}
 
bool SAudioManager::SetRingModulatorEffectParam(cAudio::sRingModulatorParameters param)
{
  cAudio::IAudioEffects* effects = manager->getEffects();
  if (mEffect && effects && effects->isEffectSupported(cAudio::EET_RING_MODULATOR))
  {
    mEffect->setRingModulatorParameters(param);
    return true;
  }
 
  return false;
}
 
bool SAudioManager::SetVocalMorpherEffectParam(cAudio::sVocalMorpherParameters param)
{
  cAudio::IAudioEffects* effects = manager->getEffects();
  if (mEffect && effects && effects->isEffectSupported(cAudio::EET_VOCAL_MORPHER))
  {
    mEffect->setVocalMorpherParameters(param);
    return true;
  }
 
  return false;
}
#endif // CAUDIO_EFX_ENABLED == 1
 
void SAudioManager::onInit()
{
 
}
 
void SAudioManager::onUpdate()
{
 
}
 
void SAudioManager::onRelease()
{
 
}
 
void SAudioManager::onSourceCreate()
{
 
}
 
void SAudioManager::onDecoderRegister()
{
 
}
 
void SAudioManager::onDataSourceRegister()
{
 
}
 
void SAudioManager::onDeviceChange()
{
#if CAUDIO_EFX_ENABLED == 1
  mEffect = 0;
  mFilter = 0;
 
  InitEffects();
  SetFilter(mFilterType, mFilterLowFreqVolume, mFilterHighFreqVolume);
  SetEffect(mEffectType, mEffectPreset);
 
  for (std::set<SAudioSound*>::iterator it = validSounds.begin(); it != validSounds.end(); ++it)
  {
    SAudioSound* sound = (*it);
    sound->SetEffectState(sound->mEffectState);
    sound->SetFilterState(sound->mFilterState);
  }
#endif
}
 
SAudioManager* SAudioManager::GetInstance()
{
  if (NULL == _singleton)
  {
    _singleton =  new SAudioManager;
  }
  return _singleton;
}
 
void SAudioManager::Kill()
{
  SAFE_DELETE(_singleton);
}
 
cAudio::IAudioManager* SAudioManager::GetManager()
{
  return manager;
}
 
SAudioInput* SAudioManager::CreateAudioCapture(int device, unsigned int frequency, cAudio::AudioFormats format)
{
  SAudioInput* capture = new SAudioInput(device, frequency, format);
  if (capture->IsValid())
  {
    validInput.insert(capture);
    return capture;
  }
  else
  {
    SAFE_DELETE(capture);
    return NULL;
  }
}
 
void SAudioManager::RemoveAudioCapture(SAudioInput* capture)
{
  if ((manager != 0) && (capture != 0))
  {
    if (validInput.find(capture) != validInput.end())
      validInput.erase(capture);
    SAFE_DELETE(capture);
  }
}
 
void SAudioManager::SetListenerPosition(cAudio::cVector3 pos, cAudio::cVector3 dir)
{
  if (manager != 0)
  {
    cAudio::IListener* listener = manager->getListener();
    listener->setPosition(pos);
    listener->setDirection(dir);
  }
}
 
void SAudioManager::AddValidSound(SAudioSound* sound)
{
  if (sound->IsValid())
    validSounds.insert(sound);
}
 
void SAudioManager::RemoveValidSound(SAudioSound* sound)
{
  if (validSounds.find(sound) != validSounds.end())
    validSounds.erase(sound);
}
 
bool SAudioManager::GetValidSound(SAudioSound* sound)
{
  if (validSounds.find(sound) != validSounds.end())
    return true;
  else
    return false;
}
 
void SAudioManager::RemoveSound(SAudioSound* sound)
{
  if ((manager != 0) && (GetValidSound(sound)))
  {
    RemoveValidSound(sound);
    SAFE_DELETE(sound);
  }
}
 
SAudioSound* SAudioManager::AddSound(std::string name, std::string path, bool stream)
{
  if (manager != 0)
  {
    SAudioSound* sound = new SAudioSound(name, path, stream);
    AddValidSound(sound);
    return sound;
  }
  else
  {
    return 0;
  }
}
 
SAudioSound* SAudioManager::AddSound(std::string name, unsigned int frequency, cAudio::AudioFormats format)
{
  if (manager != 0)
  {
    SAudioSound* sound = new SAudioSound(name, frequency, format);
    AddValidSound(sound);
    return sound;
  }
  else
  {
    return 0;
  }
}
 
bool SAudioManager::GetPaused()
{
  return mPaused;
}
 
void SAudioManager::Pause()
{
  mPaused = true;
  for(std::set<SAudioSound*>::iterator it = validSounds.begin(); it != validSounds.end(); ++it)
  {
    SAudioSound* sound = (*it);
    if (sound->IsPlaying())
    {
      sound->SetLoopOnResume(sound->IsLoop());
      sound->Pause();
      sound->SetPlayOnResume(true);
    }
  }
 
  for (std::set<SAudioInput*>::iterator it = validInput.begin(); it != validInput.end(); ++it)
  {
    SAudioInput* input = (*it);
    if (input->GetState())
    {
      input->SetResumeState(true);
      input->Stop();
    }
  }
}
 
void SAudioManager::Resume()
{
  mPaused = false;
  for(std::set<SAudioSound*>::iterator it = validSounds.begin(); it != validSounds.end(); ++it)
  {
    SAudioSound* sound = (*it);
    if (sound->GetPlayOnResume())
    {
      if (sound->Is3d())
        sound->Play3d(sound->Get3DAttenuation(), sound->GetLoopOnResume());
      else
        sound->Play(sound->GetLoopOnResume());
 
      sound->SetPlayOnResume(false);
    }
  }
  
  for (std::set<SAudioInput*>::iterator it = validInput.begin(); it != validInput.end(); ++it)
  {
    SAudioInput* input = (*it);
    if (input->GetResumeState())
    {
      input->SetResumeState(false);
      input->Start();
    }
  }
}
 
void SAudioManager::StopAllSounds()
{
  manager->stopAllSounds();
}
 
void SAudioManager::SetMuted(bool value)
{
  if (muted && !value)
  {
    muted = false;
    SetMasterVolume(unmutedVolume);
  }
  else if (!muted && value)
  {
    muted = true;
    unmutedVolume = GetMasterVolume();
    SetMasterVolume(0.0f);
  }
}
 
void SAudioManager::ToggleMute()
{
  if (muted)
  {
    muted = false;
    SetMasterVolume(unmutedVolume);
  }
  else if (!muted)
  {
    muted = true;
    unmutedVolume = GetMasterVolume();
    SetMasterVolume(0.0f);
  }
}
 
bool SAudioManager::IsMuted()
{
  return muted;
}
 
void SAudioManager::SetMasterVolume(float volume)
{
  manager->setMasterVolume(volume);
}
 
float SAudioManager::GetMasterVolume()
{
  return manager->getMasterVolume();
}
 
#if CAUDIO_EFX_ENABLED == 1
void SAudioManager::AttachSoundEffect(cAudio::IAudioSource* source)
{
  if (mEffect && mEffect->isValid())
  {
    source->attachEffect(0, mEffect);
  }
}
 
void SAudioManager::DettachSoundEffect(cAudio::IAudioSource* source)
{
  source->removeEffect(0);
}
 
void SAudioManager::AttachSoundFilter(cAudio::IAudioSource* source)
{
  if (mFilter && mFilter->isValid())
  {
    source->attachFilter(mFilter);
  }
}
 
void SAudioManager::DettachSoundFilter(cAudio::IAudioSource* source)
{
  source->removeFilter();
}
#endif
 
// Initialize singleton
SAudioManager* SAudioManager::_singleton = NULL;
 
#ifdef ANDROID
bool SAudioInput::checkRecordAudioPermission()
{
  JNIEnv* env = 0;
  struct android_app* mApp = (struct android_app*)SCgetExtra("this_inst");
  if (mApp->activity->vm->GetEnv((void**)&env, JNI_VERSION_1_6) != JNI_OK)
    mApp->activity->vm->AttachCurrentThread(&env, NULL);
 
  //wait for default authorization
  jobject oActivity = mApp->activity->clazz;
  jclass cActivity = env->GetObjectClass(oActivity);
 
  if (cActivity)
  {
    bool authPassed = false;
    while (!authPassed)
    {
      jfieldID reqBoolean = env->GetFieldID(cActivity, "mMinAuthPassed", "Z");
      authPassed = (bool) env->GetBooleanField(oActivity, reqBoolean);
      if (!authPassed)
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
 
    //check camera permission
    jmethodID record_audio_permission = env->GetMethodID(cActivity, "RequestRecordAudioPermission", "()V");
    if (record_audio_permission)
      env->CallVoidMethod(oActivity, record_audio_permission);
 
    if (env->ExceptionCheck())
    {
      env->ExceptionClear();
      MMechostr(MSKRUNTIME, "Android Record audio exception : Check android.permission.RECORD_AUDIO\n");
    }
 
    authPassed = false;
    while (!authPassed)
    {
      jfieldID reqBoolean = env->GetFieldID(cActivity, "mRecordAudioAuthPassed", "Z");
      authPassed = (bool) env->GetBooleanField(oActivity, reqBoolean);
      if (!authPassed)
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
    env->DeleteLocalRef(cActivity);
 
    return authPassed;
  }
  else
    return false;
}
#endif //ANDROID
 
SAudioInput::SAudioInput()
{
  mAudioCapture = 0;
  mState = false;
  mValid = false;
  mResumeState = false;
}
 
SAudioInput::SAudioInput(int device, unsigned int frequency, cAudio::AudioFormats format)
{
  mAudioCapture = 0;
  mState = false;
  mValid = false;
  mResumeState = false;
 
  bool captureReady = false;
 
#ifdef ANDROID
  if (checkRecordAudioPermission())
  {
#endif
  mAudioCapture = cAudio::createAudioCapture(false);
 
  // ! Here we enumerate different devices
  cAudio::IAudioDeviceList* pAudioDeviceList = cAudio::createAudioDeviceList(cAudio::DT_RECORDING);
 
  if (pAudioDeviceList)
  {
    captureReady = pAudioDeviceList->isSupported();
    unsigned int deviceSelection = 0;
    MMechostr(MSKRUNTIME, "Audio capturing Supported : %s ", (captureReady) ? "Yes" : "No");
    if (captureReady)
    {
      unsigned int deviceCount = pAudioDeviceList->getDeviceCount();
      cAudio::cAudioString defaultDeviceName = pAudioDeviceList->getDefaultDeviceName();
      for (unsigned int i = 0; i < deviceCount; ++i)
      {
        cAudio::cAudioString deviceName = pAudioDeviceList->getDeviceName(i);
        if (deviceName.compare(defaultDeviceName) == 0)
        {
          if ((device == -1) || (device == i))
            deviceSelection = i;
          MMechostr(MSKRUNTIME, "Audio capture device : %d - %s [DEFAULT]", i, deviceName.c_str());
        }
        else
        {
          if (device == i)
            deviceSelection = i;
          MMechostr(MSKRUNTIME, "Audio capture device : %d - %s", i, deviceName.c_str());
        }
      }
 
      captureReady = mAudioCapture->initialize(pAudioDeviceList->getDeviceName(deviceSelection).c_str(), frequency, format);
      CAUDIO_DELETE pAudioDeviceList; // Free up some memory
      pAudioDeviceList = 0;
    }
  }
 
  if (!captureReady)
  {
    cAudio::destroyAudioCapture(mAudioCapture);
    mAudioCapture = 0;
    mValid = false;
  }
  else
  {
    mValid = true;
  }
 
#ifdef ANDROID
  }
#endif
}
 
SAudioInput::~SAudioInput()
{
  if (mAudioCapture)
  {
    if (mState)
    {
      //purge
      mAudioCapture->getCapturedAudioBuffer();
      mAudioCapture->stopCapture();
      cAudio::cAudioSleep(10);
    }
 
    cAudio::destroyAudioCapture(mAudioCapture);
  }
  mAudioCapture = 0;
  mState = false;
}
 
void SAudioInput::Start()
{
  if (mAudioCapture && !mState)
  {
    mAudioCapture->beginCapture();
    mState = true;
  }
}
 
void SAudioInput::Stop()
{
  if (mAudioCapture && mState)
  {
    mAudioCapture->stopCapture();
    mState = false;
  }
}
 
bool SAudioInput::IsValid()
{
  return mValid;
}
 
bool SAudioInput::GetState()
{
  return mState;
}
 
void SAudioInput::SetResumeState(bool state)
{
  mResumeState = state;
}
 
bool SAudioInput::GetResumeState()
{
  return mResumeState;
}
 
size_t SAudioInput::GetBuffer(char* destBuffer, size_t length)
{
  if (!mAudioCapture->getCurrentCapturedAudioSize())
    return 0;
 
  return mAudioCapture->getCapturedAudio(destBuffer, length);
}
 
 
SAudioSound::SAudioSound(std::string name, std::string path, bool stream)
{
  mName = name;
  mPlayOnResume = false;
  mLoopOnResume = false;
  mLast3dState = false;
  mIsStream = false;
  mEffectState = false;
  mFilterState = false;
  mLast3dAttenuation = 1.0f;
 
  mSound = SAudioManager::GetInstance()->GetManager()->create(name.c_str(), path.c_str(), stream);
  if (mSound)
  {
    mSound->registerEventHandler(this);
    MMechostr(MSKDEBUG, "SAudioSound OK : %s ", path.c_str());
  }
  else
  {
    MMechostr(MSKDEBUG, "SAudioSound Failed : %s ", path.c_str());
  }
}
 
SAudioSound::SAudioSound(std::string name, unsigned int frequency, cAudio::AudioFormats format)
{
  mName = name;
  mPlayOnResume = false;
  mLoopOnResume = false;
  mLast3dState = false;
  mEffectState = false;
  mFilterState = false;
  mIsStream = true;
  mLast3dAttenuation = 1.0f;
 
  mSound = mSound = SAudioManager::GetInstance()->GetManager()->createFromStream(name.c_str(), frequency, format);
  if (mSound)
  {
    mSound->registerEventHandler(this);
    MMechostr(MSKDEBUG, "SAudioSound OK : %s ", name.c_str());
  }
  else
  {
    MMechostr(MSKDEBUG, "SAudioSound Failed : %s ", name.c_str());
  }
}
 
SAudioSound::~SAudioSound()
{
  if (mSound)
  {
    mSound->unRegisterEventHandler(this);
    
#if CAUDIO_EFX_ENABLED == 1
    SAudioManager::GetInstance()->DettachSoundEffect(mSound);
    SAudioManager::GetInstance()->DettachSoundFilter(mSound);
#endif
    
    SAudioManager::GetInstance()->GetManager()->release(mSound);
    mSound = 0;
  }
}
 
bool SAudioSound::IsValid()
{
  if (mSound)
    return true;
  else
    return false;
}
 
std::string SAudioSound::GetName()
{
  return mName;
}
 
bool SAudioSound::Play(bool loop)
{
  if (mSound)
  {
    mLast3dState = false;
    if (!SAudioManager::GetInstance()->GetPaused())
    {
      return mSound->play2d(loop && !mIsStream);
    }
    else
    {
      SetLoopOnResume(loop && !mIsStream);
      SetPlayOnResume(true);
      return true;
    }
  }
  else
    return false;
}
 
bool SAudioSound::Play3d(float attenuation, bool loop)
{
  if (mSound)
  {
    mLast3dState = true;
    mLast3dAttenuation = attenuation;
    if (!SAudioManager::GetInstance()->GetPaused())
    {
      return mSound->play3d(mSound->getPosition(), attenuation, loop);
    }
    else
    {
      SetLoopOnResume(loop);
      SetPlayOnResume(true);
      return true;
    }
  }
  else
    return false;
}
 
void SAudioSound::Stop()
{
  if (mSound)
  {
    mSound->stop();
    SetPlayOnResume(false);
  }
}
 
void SAudioSound::Pause()
{
  if (mSound)
  {
    mSound->pause();
  }
}
 
void SAudioSound::SetVolume(float volume)
{
  if (mSound)
    mSound->setVolume(volume);
}
 
float SAudioSound::GetVolume()
{
  if (mSound)
    return mSound->getVolume();
  else
    return 0.0f;
}
 
bool SAudioSound::IsPlaying()
{
  if (mSound)
    return mSound->isPlaying();
  else
    return false;
}
 
bool SAudioSound::Is3d()
{
  return mLast3dState;
}
 
bool SAudioSound::IsLoop()
{
  if (mSound)
    return mSound->isLooping();
  else
    return false;
}
 
bool SAudioSound::GetLoopOnResume()
{
  return mPlayOnResume;
}
 
void SAudioSound::SetLoopOnResume(bool state)
{
  mLoopOnResume = state;
}
 
bool SAudioSound::GetPlayOnResume()
{
  return mPlayOnResume;
}
 
void SAudioSound::SetPlayOnResume(bool state)
{
  mPlayOnResume = state;
}
 
float SAudioSound::Get3DAttenuation()
{
  return mLast3dAttenuation;
}
 
float SAudioSound::GetTime()
{
  if (mSound)
    return mSound->getCurrentAudioTime();
  else
    return 0.0f;
}
 
float SAudioSound::GetTotalTime()
{
  if (mSound)
    return mSound->getTotalAudioTime();
  else
    return 0.0f;
}
 
void SAudioSound::SetPitch(float pitch)
{
  if (mSound)
    mSound->setPitch(pitch);
}
 
float SAudioSound::GetPitch()
{
  if (mSound)
    return mSound->getPitch();
  else
    return 0.0f;
}
 
void SAudioSound::Seek(float pos, bool relative)
{
  if (mSound)
    mSound->seek(pos, relative);
}
 
// 3D
void SAudioSound::SetPositionAndDirection(cAudio::cVector3 pos, cAudio::cVector3 dir)
{
  if (mSound)
  {
    mSound->setPosition(pos);
    mSound->setDirection(dir);
  }
}
 
cAudio::cVector3 SAudioSound::GetPosition()
{
  if (mSound)
    return mSound->getPosition();
  else
    return cAudio::cVector3(0.0f, 0.0f, 0.0f);
}
 
cAudio::cVector3 SAudioSound::GetDirection()
{
  if (mSound)
    return mSound->getDirection();
  else
    return cAudio::cVector3(0.0f, 0.0f, 0.0f);
}
 
void SAudioSound::SetCone(float inner, float outer, float outvol)
{
  if (mSound)
  {
    mSound->setInnerConeAngle(inner);
    mSound->setOuterConeAngle(outer);
    mSound->setOuterConeVolume(outvol);
  }
}
 
float SAudioSound::GetInnerCone()
{
  if (mSound)
    return mSound->getInnerConeAngle();
  else
    return 0.0f;
}
 
float SAudioSound::GetOuterCone()
{
  if (mSound)
    return mSound->getOuterConeAngle();
  else
    return 0.0f;
}
 
float SAudioSound::GetOuterConeVolume()
{
  if (mSound)
    return mSound->getOuterConeVolume();
  else
    return 0.0f;
}
 
void SAudioSound::SetRolloffFactor(float rolloff)
{
  if (mSound)
    mSound->setRolloffFactor(rolloff);
}
 
float SAudioSound::GetRolloffFactor()
{
  if (mSound)
    return mSound->getRolloffFactor();
  else
    return 0.0f;
}
 
bool SAudioSound::FillBuffer(const char* &data, const unsigned int &size)
{
  if (mSound && size)
    return mSound->fillStreamBuffer(data, size);
  else
    return false;
}
 
#if CAUDIO_EFX_ENABLED == 1
void SAudioSound::SetEffectState(bool state)
{
  mEffectState = state;
  if (mSound)
  {
    if (mEffectState)
      SAudioManager::GetInstance()->AttachSoundEffect(mSound);
    else
      SAudioManager::GetInstance()->DettachSoundEffect(mSound);
  }
}
 
void SAudioSound::SetFilterState(bool state)
{
  mFilterState = state;
  if (mSound)
  {
    if (mFilterState)
      SAudioManager::GetInstance()->AttachSoundFilter(mSound);
    else
      SAudioManager::GetInstance()->DettachSoundFilter(mSound);
  }
}
#endif
 
// EVENTS
void SAudioSound::onUpdate()
{
}
 
void SAudioSound::onRelease()
{
}
 
void SAudioSound::onPlay()
{
}
 
void SAudioSound::onStop()
{
  SetPlayOnResume(false);
  OBJpostEvent(AUDIO_END_CB, SCOL_PTR this, 0);
}
 
void SAudioSound::onPause()
{
}