Sound.h

Go to the documentation of this file.

 
#pragma once
 
namespace XPMP2 {
 
//
// MARK: FMOD Error Handling
//
 
class FmodError : public std::runtime_error
{
public:
    FMOD_RESULT fmodRes;        
    std::string sFile;          
    int ln;                     
    std::string sFunc;          
public:
    FmodError (const std::string& _what, FMOD_RESULT _r,
               const std::string& _file,
               int _ln, const std::string& _sFunc) :
    std::runtime_error(leftOf(_what,"( ")),     // takes over the name of the function called, but not all the parameter string
    fmodRes(_r), sFile(_file), ln(_ln), sFunc(_sFunc)
    {}
    
    void LogErr () const {
        LogMsg(sFile.c_str(), ln, sFunc.c_str(), logERR,
#if INCLUDE_FMOD_SOUND + 0 >= 1
               "FMOD Error %d - '%s' in %s", fmodRes,
               FMOD_ErrorString(fmodRes),
#else
               "FMOD Error %d in %s", fmodRes,
#endif
               what());
    }
};
 
extern FMOD_RESULT gFmodRes;
 
#define FMOD_TEST(fmodCall)  {                                              \
    if ((gFmodRes = (fmodCall)) != FMOD_OK)                                 \
        throw FmodError(#fmodCall, gFmodRes, __FILE__, __LINE__, __func__); \
}
 
#define FMOD_CATCH catch (const FmodError& e) { e.LogErr(); }
 
#define FMOD_LOG(fmodCall)  {                                                                \
    if ((XPMP2::gFmodRes = (fmodCall)) != FMOD_OK)                                           \
        XPMP2::FmodError(#fmodCall, XPMP2::gFmodRes, __FILE__, __LINE__, __func__).LogErr(); \
}
 
//
// MARK: Sound Files
//
 
class SoundSystem;
 
FMOD_VECTOR FmodHeadPitch2Vec (const float head, const float pitch);
 
void FmodHeadPitchRoll2Normal(const float head, const float pitch, const float roll,
                              FMOD_VECTOR& vecDir, FMOD_VECTOR& vecNorm);
 
void FmodNormalizeHeadingPitch(float& head, float& pitch);
 
class SoundFile {
public:
    SoundSystem* pSndSys = nullptr; 
    std::string filePath;           
    bool bLoop = true;              
    
    // 3D Cone information, to be applied to the channel later when playing the sound
    float coneDir = NAN;            
    float conePitch = NAN;          
    float coneInAngle = NAN;        
    float coneOutAngle = NAN;       
    float coneOutVol = NAN;         
    
public:
    SoundFile (SoundSystem* _pSndSys,
               const std::string& _filePath, bool _bLoop,
               float _coneDir, float _conePitch,
               float _coneInAngle, float _coneOutAngle, float _coneOutVol);
    
    virtual ~SoundFile () {}
    
    SoundFile (const SoundFile& o) = delete;
    
    bool hasConeInfo () const
    {
        return
            !std::isnan(coneDir) &&
            !std::isnan(conePitch) &&
            !std::isnan(coneInAngle) &&
            !std::isnan(coneOutAngle) &&
            !std::isnan(coneOutVol);
    }
    
    virtual bool isReady () = 0;
};
 
typedef std::unique_ptr<SoundFile> SoundFilePtr;
typedef std::map<std::string,SoundFilePtr> mapSoundPtrTy;
 
class SoundWAV : public SoundFile {
public:
    int16_t*    pBuf = nullptr;             
    uint32_t    bufferSize = 0;             
    int         freqHz = 0;                 
    int         numChannels = 0;            
    
public:
    SoundWAV (SoundSystem* _pSndSys,
              const std::string& _filePath, bool _bLoop,
              float _coneDir, float _conePitch,
              float _coneInAngle, float _coneOutAngle, float _coneOutVol);
    
    ~SoundWAV() override;
    
    bool isReady () override { return true; }
    
protected:
    void WavRead ();
};
 
//
// MARK: Sound System
//
 
class SoundChannel {
public:
    FMOD_CHANNEL*   pChn    = nullptr;      
    SoundFile*      pSnd    = nullptr;      
    float           vol     = 1.0f;         
    bool            bMuted  = false;        
    int             nPauseCountdown = 2;    
public:
    SoundChannel () {}
    SoundChannel (FMOD_CHANNEL* c, SoundFile* s, float v) : pChn(c), pSnd(s), vol(v) {}
    operator bool () const { return pChn && pSnd; }
    bool ShallUnpause () { return nPauseCountdown > 0 ? (--nPauseCountdown == 0) : false;  }
};
 
class SoundSystem {
protected:
    mapSoundPtrTy mapSounds;
    std::map<uint64_t,SoundChannel> mapChn;
private:
    uint64_t uNxtId = 0;
    uint64_t cacheSndId = 0;
    SoundChannel* pCacheChn = nullptr;
    
public:
    SoundSystem() {}
    virtual ~SoundSystem() {}
    
    virtual bool LoadSoundFile (const std::string& _sndName,
                                const std::string& _filePath, bool _bLoop,
                                float _coneDir, float _conePitch,
                                float _coneInAngle, float _coneOutAngle, float _coneOutVol) = 0;
    const char* EnumerateSounds (const char* prevName, const char** ppFilePath);
 
    virtual uint64_t Play (const std::string& sndName, float vol, const Aircraft& ac) = 0;
    virtual void Unpause (uint64_t sndId) = 0;
    virtual void Stop (uint64_t sndId) = 0;
    virtual void SetPosOrientation (uint64_t sndId, const Aircraft& ac, bool bDoOrientation) = 0;
    virtual void SetVolume (uint64_t sndId, float vol) = 0;
    virtual void SetMute (uint64_t sndId, bool bMute) = 0;
    
    virtual void Update () = 0;
 
    virtual void SetMasterVolume (float volMaster) = 0;
    virtual void SetAllMute (bool bMute) = 0;
    
    virtual bool IsValid (uint64_t sndId);
 
protected:
    std::pair<uint64_t,SoundChannel*> AddChn (SoundFile* pSnd, float vol, FMOD_CHANNEL* pChn = nullptr);
    SoundChannel* GetChn (uint64_t sndId);
    void RemoveChn (uint64_t sndId);
};
 
extern SoundSystem* gpSndSys;
 
 
class SoundSystemXP : public SoundSystem {
protected:
    float   volMaster = 1.0f;       
    bool    bAllMuted = false;      
public:
    SoundSystemXP();
    ~SoundSystemXP() override {}
    
    bool LoadSoundFile (const std::string& _sndName,
                        const std::string& _filePath, bool _bLoop,
                        float _coneDir, float _conePitch,
                        float _coneInAngle, float _coneOutAngle, float _coneOutVol) override;
 
    uint64_t Play (const std::string& sndName, float vol, const Aircraft& ac) override;
    void Unpause (uint64_t sndId) override;
    void Stop (uint64_t sndId) override;
    void SetPosOrientation (uint64_t sndId, const Aircraft& ac, bool bDoOrientation) override;
    void SetVolume (uint64_t sndId, float vol) override;
    void SetMute (uint64_t sndId, bool bMute) override;
    
    void Update () override {}
    
    void SetMasterVolume (float volMaster) override;
    void SetAllMute (bool bMute) override;
 
protected:
    static void PlayCallback (void*         inRefcon,
                              FMOD_RESULT   status);
    void ChnSetVol (const SoundChannel& chn);
    void AllChnSetVol ();
};
 
//
// MARK: Global Functions
//
 
void SoundInit ();
 
void SoundUpdatesBegin();
 
void SoundUpdatesDone ();
 
void SoundCleanup ();
 
}