audio_mixer_user.h

Go to the documentation of this file.

/* Copyright, 2001 Nevrax Ltd.
 *
 * This file is part of NEVRAX NEL.
 * NEVRAX NEL is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.

 * NEVRAX NEL is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with NEVRAX NEL; see the file COPYING. If not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

#ifndef NL_AUDIO_MIXER_USER_H
#define NL_AUDIO_MIXER_USER_H
#include <nel/misc/types_nl.h>

#include <vector>
#include <list>
#include <numeric>

#include <nel/misc/time_nl.h>
#include <nel/misc/stream.h>
#include <nel/misc/singleton.h>
#include <nel/sound/u_audio_mixer.h>
#include <nel/georges/u_form.h>

#include "driver/source.h"
#include "listener_user.h"
//#include "background_sound_manager.h"
#include "mixing_track.h"
#include "sound.h"
#include "music_channel_fader.h"

namespace NLLIGO {
    class CLigoConfig;
}

namespace NLSOUND {
    class CSimpleSource;
    class CEnvSoundUser;
    class CEnvEffect;
    class CSoundBank;
    class CSourceCommon;
    class CClusteredSound;
    class CBackgroundSoundManager;
    class CMusicSoundManager;
    class IReverbEffect;

template <class Pointer>
struct THashPtr : public std::unary_function<const Pointer &, size_t>
{
    static const size_t bucket_size = 4;
    static const size_t min_buckets = 8;
    size_t operator () (const Pointer &ptr) const
    {
        //CHashSet<uint>::hasher    h;
        // transtype the pointer into int then hash it
        //return h.operator()(uint(uintptr_t(ptr)));
        return (size_t)(uintptr_t)ptr;
    }
    inline bool operator() (const Pointer &ptr1, const Pointer &ptr2) const
    {
        // delegate the work to someone else as well?
        return (uintptr_t)ptr1 < (uintptr_t)ptr2;
    }
};

class CAudioMixerUser : public UAudioMixer, public ISoundDriver::IStringMapperProvider, public NLMISC::CManualSingleton<CAudioMixerUser>
{
public:

    CAudioMixerUser();
    static CAudioMixerUser *instance() { return getInstance(); }
    virtual ~CAudioMixerUser();



    NLMISC::TStringId map(const std::string &str)           { return NLMISC::CStringMapper::map(str);}
    const std::string &unmap(const NLMISC::TStringId &stringId)     { return NLMISC::CStringMapper::unmap(stringId);}


    virtual void        init(uint maxTrack, bool useEax, bool useADPCM, NLMISC::IProgressCallback *progressCallBack, bool autoLoadSample, TDriver driverType, bool forceSoftwareBuffer, bool manualRolloff = true);

    virtual void        initClusteredSound(NL3D::UScene *uscene, float minGain, float maxDistance, float portalInterpolate);
    virtual void        initClusteredSound(NL3D::CScene *scene, float minGain, float maxDistance, float portalInterpolate);

    virtual void        setPriorityReserve(TSoundPriority priorityChannel, size_t reserve);
    virtual void        setLowWaterMark(size_t value);

    virtual void        changeMaxTrack(uint maxTrack);

    virtual void                reset();
    virtual void                enable( bool b );
//  virtual void                loadEnvEffects( const char *filename );

    void                        buildSampleBankList();
    bool                        useAPDCM()  {   return _UseADPCM;};
    virtual uint32              loadSampleBank(bool async, const std::string &name, std::vector<std::string> *notfoundfiles=NULL );
    virtual bool                unloadSampleBank( const std::string &name);
    virtual void                reloadSampleBanks(bool async);
    virtual uint32              getLoadedSampleSize();
    virtual void                getLoadedSampleBankInfo(std::vector<std::pair<std::string, uint> > &result);



//  virtual void                loadSoundBank( const std::string &path );


    // Load environment sounds ; treeRoot can be null if you don't want an access to the envsounds
//  virtual void                loadEnvSounds( const char *filename, UEnvSound **treeRoot=NULL );
    virtual TSoundId            getSoundId( const NLMISC::TStringId &name );


    virtual USource             *createSource( const NLMISC::TStringId &name, bool spawn=false, TSpawnEndCallback cb=NULL, void *cbUserParam = NULL, NL3D::CCluster *cluster = 0, CSoundContext *context = 0 );
    virtual USource             *createSource( TSoundId id, bool spawn=false, TSpawnEndCallback cb=NULL, void *cbUserParam = NULL, NL3D::CCluster *cluster = 0, CSoundContext *context = 0 );
    void                        addSource( CSourceCommon *source );
    virtual void                removeSource( CSourceCommon *source );

//  void                        giveTrack( CSimpleSource *source );
//  void                        releaseTrack( CSimpleSource *source );

    virtual void                setListenerPos (const NLMISC::CVector &pos);

    virtual UListener           *getListener()  { return &_Listener; }


    virtual void                selectEnvEffects( const std::string &tag );
    virtual void                update();


    virtual void                getSoundNames( std::vector<NLMISC::TStringId> &names ) const;
    virtual uint                getPolyphony() const { return _Tracks.size(); }
    virtual uint                getSourcesInstanceCount() const { return _Sources.size(); }
    virtual uint                getPlayingSourcesCount() const;
    virtual uint                getAvailableTracksCount() const;
    virtual uint                getUsedTracksCount() const;
    virtual uint                getMutedPlayingSourcesCount() const     { return _PlayingSourcesMuted; }

    virtual std::string         getSourcesStats() const;


    void                        applyListenerMove( const NLMISC::CVector& listenerpos );
//  CEnvSoundUser               *getEnvSounds()                         { return _EnvSounds; }
    const NLMISC::CVector&      getListenPosVector() const              { return _ListenPosition; }
//  void                        removeMySource( USource *source );
//  void                        addAmbiantSound( CSound *sound )        { _AmbSounds.insert( sound ); }
    // Allow to load sound files (nss) when the corresponding wave file is missing (see CSound)
    //static void                   allowMissingWave( bool b )              { CSound::allowMissingWave( b ); }

    virtual void                setSamplePath(const std::string& path);
    virtual void                setPackedSheetOption(const std::string &path, bool update);
    std::string                 &getPackedSheetPath()                       {return _PackedSheetPath; }
    bool                        getPackedSheetUpdate()                      {return _UpdatePackedSheet; }


    CBackgroundSoundManager     *getBackgroundSoundManager()                { return _BackgroundSoundManager; }
    virtual void                writeProfile(std::string& out);

    virtual void                setBackgroundFlagName(uint flagIndex, const std::string &flagName);
    virtual void                setBackgroundFlagShortName(uint flagIndex, const std::string &flagShortName);
    virtual const std::string   &getBackgroundFlagName(uint flagIndex);
    virtual const std::string   &getBackgroundFlagShortName(uint flagIndex);
//  virtual void                loadBackgroundSoundFromRegion (const NLLIGO::CPrimRegion &region);
//  virtual void                loadBackgroundEffectsFromRegion (const NLLIGO::CPrimRegion &region);
//  virtual void                loadBackgroundSamplesFromRegion (const NLLIGO::CPrimRegion &region);
    virtual void                loadBackgroundAudioFromPrimitives(const NLLIGO::IPrimitive &audioRoot);
    virtual void                loadBackgroundSound (const std::string &continent, NLLIGO::CLigoConfig &config);
    virtual void                playBackgroundSound ();
    virtual void                stopBackgroundSound ();

    CClusteredSound             *getClusteredSound()    { return _ClusteredSound; }

//  virtual void                setBackgroundSoundDayNightRatio (float ratio) { CBackgroundSoundManager::setDayNightRatio(ratio); }

    ISoundDriver*               getSoundDriver();

    void                        registerBufferAssoc(CSound *sound, IBuffer *buffer);
    void                        unregisterBufferAssoc(CSound *sound, IBuffer *buffer);

    void                        bufferUnloaded(IBuffer *buffer);

    void                        setBackgroundFlags(const TBackgroundFlags &backgroundFlags);
    void                        setBackgroundFilterFades(const TBackgroundFilterFades &backgroundFilterFades);
    const TBackgroundFlags      &getBackgroundFlags();
    const TBackgroundFilterFades &getBackgroundFilterFades();


//  bool                        setPlaying(CSimpleSource *source);
//  void                        unsetPlaying(CSimpleSource *source);

    CTrack *getFreeTrack(CSimpleSource *source);
    void freeTrack(CTrack *track);

    CTrack *getFreeTrackWithoutSource(bool steal);
    void freeTrackWithoutSource(CTrack *track);

    void                        incPlayingSource()  { ++_PlayingSources; };
    void                        decPlayingSource()  { --_PlayingSources; };
    void                        incPlayingSourceMuted() { ++_PlayingSourcesMuted; };
    void                        decPlayingSourceMuted() { --_PlayingSourcesMuted; };

    void        setUserVar(NLMISC::TStringId varName, float value);
    float       getUserVar(NLMISC::TStringId varName);

    // music
    virtual bool    playMusic(const std::string &fileName, uint xFadeTime= 0, bool async= true, bool loop=true);
    virtual void    stopMusic(uint xFadeTime= 0);
    virtual void    pauseMusic();
    virtual void    resumeMusic();
    virtual bool    isMusicEnded();
    virtual void    setMusicVolume(float gain);
    virtual float   getMusicLength();
    virtual bool    getSongTitle(const std::string &filename, std::string &result);
    virtual void    enableBackgroundMusic(bool enable);
    virtual void    enableBackgroundMusicTimeConstraint(bool enable);
    CMusicSoundManager *getBackgroundMusicManager() const {return _BackgroundMusicManager;}
    // Event music
    virtual bool    playEventMusic(const std::string &fileName, uint xFadeTime= 0, bool async= true, bool loop=true);
    virtual void    stopEventMusic(uint xFadeTime= 0);
    virtual void    setEventMusicVolume(float gain);
    virtual bool    isEventMusicEnded();
    virtual void getMusicExtensions(std::vector<std::string> &extensions);

    inline IReverbEffect *getReverbEffect() { return _ReverbEffect; }
    inline bool useEnvironmentEffects() const { return _UseEax; }

    //\name Reverb environment functions
    void addEnvironment(const std::string &name, const IReverbEffect::CEnvironment &environment);
    void setEnvironment(NLMISC::TStringId environmentName, float roomSize);
    inline void setEnvironment(const std::string &environmentName, float roomSize) { setEnvironment(NLMISC::CStringMapper::map(environmentName), roomSize); }
    const IReverbEffect::CEnvironment & getEnvironment(NLMISC::TStringId environmentName);
    inline const IReverbEffect::CEnvironment & getEnvironment(const std::string &environmentName) { return getEnvironment(NLMISC::CStringMapper::map(environmentName)); }

private:
    enum    TMusicChannel
    {
        GeneralMusicChannel= 0,
        EventMusicChannel= 1
    };
    bool    playMusicChannel(TMusicChannel chan, const std::string &fileName, uint xFadeTime, bool async, bool loop);


public:
    class IMixerUpdate : public NLMISC::CDbgRefCount<IMixerUpdate>
    {
    public:
        virtual void onUpdate() =0;
        virtual ~IMixerUpdate()
        {
            //nldebug("Destroying IMixerUpdate %p", this);
        }
    };

    void                        registerUpdate(IMixerUpdate *pmixerUpdate);
    void                        unregisterUpdate(IMixerUpdate *pmixerUpdate);

    class IMixerEvent : public NLMISC::CDbgRefCount<IMixerEvent>
    {
    public:
        virtual void onEvent() =0;
        virtual ~IMixerEvent()
        {
//          nldebug("Destroying IMixerEvent %p", this);
        }

    };

    void                        addEvent(IMixerEvent *pmixerEvent, const NLMISC::TTime &date);
    void                        removeEvents(IMixerEvent *pmixerEvent);

    void                        addSourceWaitingForPlay(CSimpleSource *source);

    void                        initUserVar();
    void                        addUserControledSource(CSourceCommon *source, NLMISC::TStringId varName);
    void                        removeUserControledSource(CSourceCommon *source, NLMISC::TStringId varName);


    virtual void startDriverBench();
    virtual void endDriverBench();
    virtual void displayDriverBench(NLMISC::CLog *log);

private:

    // utility function for automatic sample bank loading.
    bool tryToLoadSoundBank(const std::string &sampleName);


    typedef CHashSet<CSourceCommon*, THashPtr<CSourceCommon*> >                 TSourceContainer;
    typedef CHashSet<IMixerUpdate*, THashPtr<IMixerUpdate*> >                       TMixerUpdateContainer;
    typedef CHashMap<IBuffer*, std::vector<class CSound*>, THashPtr<IBuffer*> > TBufferToSourceContainer;
//  typedef std::multimap<NLMISC::TTime, IMixerEvent*>                                  TTimedEventContainer;
    typedef std::multimap<NLMISC::TTime, NLMISC::CDbgPtr<IMixerEvent> >                 TTimedEventContainer;
    typedef std::multimap<IMixerEvent*, TTimedEventContainer::iterator>                 TEventContainer;

    enum TControledParamId
    {
        gain_control,
        pitch_control,
        nb_control,
        bad_control
    };

    struct CControledSources
    {
        NLMISC::TStringId               Name;
        TControledParamId               ParamId;
        std::vector<NLMISC::TStringId>  SoundNames;
        float                           Value;
        std::set<CSourceCommon*>        Sources;

        void serial (NLMISC::IStream &s);
    };

    friend struct CControledSources;
    friend class CUserVarSerializer;

protected:
    TMixerUpdateContainer                           _UpdateList;
    std::vector<std::pair<IMixerUpdate*, bool> >    _UpdateEventList;
    TTimedEventContainer                            _EventList;
    TEventContainer                                 _Events;
    std::list<std::pair<NLMISC::TTime, IMixerEvent*> >  _EventListUpdate;
    void                        getFreeTracks( uint nb, CTrack **tracks );
    virtual void                getPlayingSoundsPos(bool virtualPos, std::vector<std::pair<bool, NLMISC::CVector> > &pos);

    typedef CHashMap<NLMISC::TStringId, CControledSources, NLMISC::CStringIdHashMapTraits>  TUserVarControlsContainer;
    TUserVarControlsContainer   _UserVarControls;

private:
    bool                        _AutoLoadSample;
    bool                        _UseADPCM;
    bool                        _UseEax;

    std::vector<CTrack*>        _FreeTracks;

    std::list<CSimpleSource*>   _SourceWaitingForPlay;

    uint32                      _PriorityReserve[NbSoundPriorities];
    uint32                      _ReserveUsage[NbSoundPriorities];
    uint32                      _LowWaterMark;

    ISoundDriver                *_SoundDriver;

    static const uint           _NbMusicChannelFaders = 2;

    CMusicChannelFader          _MusicChannelFaders[_NbMusicChannelFaders];

    CBackgroundSoundManager     *_BackgroundSoundManager;
    std::string                 _BackgroundFilterNames[TBackgroundFlags::NB_BACKGROUND_FLAGS];
    std::string                 _BackgroundFilterShortNames[TBackgroundFlags::NB_BACKGROUND_FLAGS];

    CClusteredSound             *_ClusteredSound;

    CListenerUser               _Listener;
    
    IReverbEffect               *_ReverbEffect;
    IReverbEffect::CEnvironment _DefaultEnvironment;
    float                       _DefaultRoomSize;
    typedef std::map<NLMISC::TStringId, IReverbEffect::CEnvironment> TEnvironments;
    TEnvironments               _Environments;
    
    NLMISC::CVector             _ListenPosition;

    std::string                 _SamplePath;
    std::string                 _PackedSheetPath;
    bool                        _UpdatePackedSheet;

    TBufferToSourceContainer    _BufferToSources;

    // For debug purpose only (not called)
    void        debugLogEvent(const char *reason);

    // Instance of the background music manager
    CMusicSoundManager          *_BackgroundMusicManager;

public:
    struct TSampleBankHeader
    {
        enum
        {
            // Mind to increment the version number each time the format change
            sample_bank_header_version = 7,
        };
        uint32                      Version;
        std::vector<std::string>    Name;
        std::vector<uint32>         NbSample;
        std::vector<uint32>         Freq;
        std::vector<uint32>         OffsetMono16;
        std::vector<uint32>         OffsetAdpcm;
        std::vector<uint32>         SizeMono16;
        std::vector<uint32>         SizeAdpcm;

        TSampleBankHeader()
        {
            Version = sample_bank_header_version;
        }

        void addSample(const std::string &name, uint32 frequency, uint32 nbSample, uint32 sizeMono16, uint32 sizeAdpcm)
        {
            Name.push_back(name);
            Freq.push_back(frequency);
            NbSample.push_back(nbSample);
            uint32 off16;
            uint32 offAdpcm;
            off16 = std::accumulate(SizeMono16.begin(), SizeMono16.end(), 0);
            off16 = std::accumulate(SizeAdpcm.begin(), SizeAdpcm.end(), off16);
            OffsetMono16.push_back(off16);
            SizeMono16.push_back(sizeMono16);
            offAdpcm = std::accumulate(SizeMono16.begin(), SizeMono16.end(), 0);
            offAdpcm = std::accumulate(SizeAdpcm.begin(), SizeAdpcm.end(), offAdpcm);
            OffsetAdpcm.push_back(offAdpcm);
            SizeAdpcm.push_back(sizeAdpcm);
        }

        void serial(NLMISC::IStream &s)
        {
            s.serialCheck(Version);
            s.serialCont(Name);
            s.serialCont(Freq);
            s.serialCont(NbSample);
            s.serialCont(OffsetMono16);
            s.serialCont(OffsetAdpcm);
            s.serialCont(SizeMono16);
            s.serialCont(SizeAdpcm);
        }
    };

//  static const std::string    SampleBankListExt;

    TSourceContainer        _Sources;

    uint32                  _PlayingSources;
    uint32                  _PlayingSourcesMuted;

public: // Temp (EDIT)
    std::vector<CTrack *>       _Tracks;
    bool                        _Leaving;

    NLMISC::TTicks              _StartTime;

    uint32                      curTime() { return (uint32) (NLMISC::CTime::getLocalTime() - _StartTime); }


#define NL_PROFILE_MIXER 1
#if NL_PROFILE_MIXER
public:

    double _UpdateTime;
    double _CreateTime;
    uint32 _UpdateCount;
    uint32 _CreateCount;
#endif

    friend struct displaySoundInfoClass;

};


const char *getPriorityStr( TSoundPriority p );


} // NLSOUND


#endif // NL_AUDIO_MIXER_USER_H

/* End of audio_mixer_user.h */