audio.h

 
 
#ifndef SCOLAUDIO_H
#define SCOLAUDIO_H
 
#include <string>
#include <set>
 
//Data source
#include "IDataSource.h"
#include "cAudioDefines.h"
#include "cMemoryOverride.h"
#include "cMemorySource.h"
#include "cMutex.h"
 
#include "plugin.h"
 
class cScolFileSource : public cAudio::IDataSource, public cAudio::cMemoryOverride
{
public:
  cScolFileSource(const char* filename);
  ~cScolFileSource();
 
  virtual bool isValid();
  virtual int getCurrentPos();
  virtual int getSize();
  virtual int read(void* output, int size);
  virtual bool seek(int amount, bool relative);
 
protected:
  bool Valid;
  int Filesize;
  FILE* pFile;
private:
};
 
class cScolFileSourceFactory : public cAudio::IDataSourceFactory
{
public:
  cScolFileSourceFactory() { }
  virtual ~cScolFileSourceFactory() { }
 
  virtual cAudio::IDataSource* CreateDataSource(const char* filename, bool streamingRequested)
  {
    cAudio::IDataSource* source = CAUDIO_NEW cScolFileSource(filename);
 
    if (!streamingRequested && source && source->isValid())
    {
      //A bit hackish, but if the user doesn't want streaming, make this a memory source
      int length = source->getSize();
      char* tempbuf = (char*)CAUDIO_MALLOC(length);
      if (tempbuf)
      {
        source->read(tempbuf, length);
        cAudio::IDataSource* memSource = CAUDIO_NEW cAudio::cMemorySource(tempbuf, length, true);
        CAUDIO_FREE(tempbuf);
 
        if (memSource && memSource->isValid())
        {
          source->drop();
          return memSource;
        }
 
        if (memSource)
          memSource->drop();
      }
    }
    return source;
  }
};
 
class SAudioSound;
class SAudioInput;
class SAudioManager : public cAudio::IManagerEventHandler
{
private:
  SAudioManager();
  ~SAudioManager();
protected:
public:
 
private:
  cAudio::IAudioManager* manager;
  cScolFileSourceFactory* scolDataFactory;
  static SAudioManager* _singleton;
  std::set<SAudioSound*> validSounds;
  std::set<SAudioInput*> validInput;
  bool mPaused;
  bool muted;
  float unmutedVolume;
 
#if CAUDIO_EFX_ENABLED == 1
  cAudio::IEffect* mEffect;
  cAudio::IFilter* mFilter;
 
  cAudio::FilterTypes mFilterType;
  float  mFilterLowFreqVolume;
  float  mFilterHighFreqVolume;
  cAudio::EffectTypes  mEffectType;
  std::string mEffectPreset;
#endif
  
protected:
 
public:
  static SAudioManager* GetInstance();
  static void Kill();
  
  cAudio::IAudioManager* GetManager();
  void SetListenerPosition(cAudio::cVector3 pos, cAudio::cVector3 dir);
  bool GetValidSound(SAudioSound* sound);
  void RemoveSound(SAudioSound* sound);
  SAudioSound* AddSound(std::string name, std::string path, bool stream);
  SAudioSound* AddSound(std::string name, unsigned int frequency, cAudio::AudioFormats format);
  void Pause();
  void Resume();
  void StopAllSounds();
  bool GetPaused();
  void SetMuted(bool value);
  void ToggleMute();
  bool IsMuted();
  void SetMasterVolume(float volume);
  float GetMasterVolume();
 
  SAudioInput* CreateAudioCapture(int device = -1, unsigned int frequency = 22050, cAudio::AudioFormats format = cAudio::EAF_8BIT_MONO);
  void RemoveAudioCapture(SAudioInput* capture);
 
#if CAUDIO_EFX_ENABLED == 1
  bool SetFilter(cAudio::FilterTypes type, float lowFreqVolume, float highFreqVolume);
  bool SetEffect(cAudio::EffectTypes type, std::string preset);
  bool SetReverbEffectParam(cAudio::sReverbParameters param);
  bool SetAutowahEffectParam(cAudio::sAutowahParameters param);
  bool SetChorusEffectParam(cAudio::sChorusParameters param);
  bool SetCompressorEffectParam(cAudio::sCompressorParameters param);
  bool SetDistortionEffectParam(cAudio::sDistortionParameters param);
  bool SetEchoEffectParam(cAudio::sEchoParameters param);
  bool SetEqualizerEffectParam(cAudio::sEqualizerParameters param);
  bool SetFlangerEffectParam(cAudio::sFlangerParameters param);
  bool SetFrequencyShiftEffectParam(cAudio::sFrequencyShiftParameters param);
  bool SetPitchShifterEffectParam(cAudio::sPitchShifterParameters param);
  bool SetRingModulatorEffectParam(cAudio::sRingModulatorParameters param);
  bool SetVocalMorpherEffectParam(cAudio::sVocalMorpherParameters param);
  
  void AttachSoundEffect(cAudio::IAudioSource* source);
  void DettachSoundEffect(cAudio::IAudioSource* source);
  void AttachSoundFilter(cAudio::IAudioSource* source);
  void DettachSoundFilter(cAudio::IAudioSource* source);
#endif
 
  virtual void onInit();
 
  virtual void onUpdate();
 
  virtual void onRelease();
 
  virtual void onSourceCreate();
 
  virtual void onDecoderRegister();
 
  virtual void onDataSourceRegister();
 
  virtual void onDeviceChange();
 
private:
  void AddValidSound(SAudioSound* sound);
  void RemoveValidSound(SAudioSound* sound);
  
#if CAUDIO_EFX_ENABLED == 1
  void InitEffects();
#endif
  
protected:
};
 
class SAudioInput
{
public:
  SAudioInput();
  SAudioInput(int device = -1, unsigned int frequency = 22050, cAudio::AudioFormats format = cAudio::EAF_8BIT_MONO);
  ~SAudioInput();
 
#ifdef ANDROID
  bool checkRecordAudioPermission();
#endif
 
  bool IsValid();
  bool GetState();
  void Start();
  void Stop();
  size_t GetBuffer(char* destBuffer, size_t length);
  
  void SetResumeState(bool state);
  bool GetResumeState();
 
private:
  cAudio::IAudioCapture* mAudioCapture;
  bool mState;
  bool mValid;
  bool mResumeState;
};
 
class SAudioSound : public cAudio::ISourceEventHandler
{
        public:
                SAudioSound(std::string name, std::string path, bool stream);
    SAudioSound(std::string name, unsigned int frequency, cAudio::AudioFormats format);
                ~SAudioSound();
  
    bool mEffectState;
    bool mFilterState;
 
        private:
    std::string mName;
    cAudio::IAudioSource* mSound;
    bool mPlayOnResume;
    bool mLoopOnResume;
    bool mLast3dState;
    bool mIsStream;
    float mLast3dAttenuation;
    
  public:
    bool IsValid();
    std::string GetName();
 
    bool Play(bool loop);
    bool Play3d(float attenuation, bool loop);
    void Stop();
    void Pause();
    void SetVolume(float volume);
    float GetVolume();
    bool IsPlaying();
    bool Is3d();
    bool IsLoop();
    bool FillBuffer(const char* &data, const unsigned int &size);
 
    bool GetLoopOnResume();
    void SetLoopOnResume(bool state);
    bool GetPlayOnResume();
    void SetPlayOnResume(bool playOnResume);
 
    float Get3DAttenuation();
    float GetTime();
    float GetTotalTime();
    void SetPitch(float pitch);
    float GetPitch();
    void Seek(float pos, bool relative);
 
    // 3D
    void SetPositionAndDirection(cAudio::cVector3 pos, cAudio::cVector3 dir);
    cAudio::cVector3 GetPosition();
    cAudio::cVector3 GetDirection();
 
    void SetCone(float inner, float outer, float outvol);
    float GetInnerCone();
    float GetOuterCone();
    float GetOuterConeVolume();
 
    void SetRolloffFactor(float rolloff);
    float GetRolloffFactor();
 
#if CAUDIO_EFX_ENABLED == 1
    void SetEffectState(bool state);
    void SetFilterState(bool state);
#endif
  
          virtual void onUpdate();
 
          virtual void onRelease();
 
          virtual void onPlay();
 
          virtual void onStop();
 
          virtual void onPause();
 
  private:
};
 
#endif