source_dsound.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_SOURCE_DSOUND_H
#define NL_SOURCE_DSOUND_H

#include "../source.h"
#include "../sound_driver.h"
#include "../buffer.h"

#include <dsound.h>

namespace NLSOUND {

class CBufferDSound;

/*enum TSourceDSoundBufferState
{
    NL_DSOUND_FILLING,
    NL_DSOUND_SILENCING,
    NL_DSOUND_SILENCED
} ;
/*

/*
enum TSourceDSoundUserState
{
    NL_DSOUND_PLAYING,
    NL_DSOUND_PAUSED,
    NL_DSOUND_STOPPED
};
*/

/*
enum TSourceDSoundEndState
{
    NL_DSOUND_TAIL1,
    NL_DSOUND_TAIL2,
    NL_DSOUND_ENDED
};
*/

class CSourceDSound : public ISource
{
    friend class CSoundDriverDSound;
    
public:
    CSourceDSound(uint sourcename = 0);
    virtual ~CSourceDSound();
    
    void init(LPDIRECTSOUND directSound, bool useEax);
    


    virtual void setStreaming(bool streaming);
    virtual void setStaticBuffer(IBuffer *buffer);
    virtual IBuffer *getStaticBuffer();
    virtual void submitStreamingBuffer(IBuffer *buffer);
    virtual uint countStreamingBuffers() const;
    


    virtual void setLooping(bool l);
    virtual bool getLooping() const;
    
    virtual bool play();
    virtual void stop();
    virtual void pause();
    virtual bool isPlaying() const;
    virtual bool isStopped() const;
    virtual bool isPaused() const;
    virtual uint32 getTime();
    


    virtual void setPos(const NLMISC::CVector& pos, bool deffered = true);
    virtual const NLMISC::CVector &getPos() const;
    virtual void setVelocity(const NLMISC::CVector& vel, bool deferred = true);
    virtual void getVelocity(NLMISC::CVector& vel) const;
    virtual void setDirection(const NLMISC::CVector& dir);
    virtual void getDirection(NLMISC::CVector& dir) const;
    virtual void setGain(float gain);
    virtual float getGain() const;
    virtual void setPitch(float pitch);
    virtual float getPitch() const;
    virtual void setSourceRelativeMode(bool mode);
    virtual bool getSourceRelativeMode() const;
    virtual void setMinMaxDistances(float mindist, float maxdist, bool deferred = true);
    virtual void getMinMaxDistances(float& mindist, float& maxdist) const;
    virtual void setCone(float innerAngle, float outerAngle, float outerGain);
    virtual void getCone(float& innerAngle, float& outerAngle, float& outerGain) const;
    virtual void setAlpha(double a);
    


    virtual void setDirect(bool enable = true);
    virtual bool getDirect() const;
    virtual void setDirectGain(float gain);
    virtual float getDirectGain() const;
    
    virtual void enableDirectFilter(bool enable = true);
    virtual bool isDirectFilterEnabled() const;
    virtual void setDirectFilter(TFilter filter, float lowFrequency, float highFrequency, float passGain);
    virtual void getDirectFilter(TFilter &filterType, float &lowFrequency, float &highFrequency, float &passGain) const;
    virtual void setDirectFilterPassGain(float passGain);
    virtual float getDirectFilterPassGain() const;
    


    virtual void setEffect(IReverbEffect *reverbEffect);
    virtual IEffect *getEffect() const;
    virtual void setEffectGain(float gain);
    virtual float getEffectGain() const;
    
    virtual void enableEffectFilter(bool enable = true);
    virtual bool isEffectFilterEnabled() const;
    virtual void setEffectFilter(TFilter filter, float lowFrequency, float highFrequency, float passGain);
    virtual void getEffectFilter(TFilter &filterType, float &lowFrequency, float &highFrequency, float &passGain) const;
    virtual void setEffectFilterPassGain(float passGain);
    virtual float getEffectFilterPassGain() const;
    
    uint sourceName() { return _SourceName; }
    
    IBuffer *getBuffer();
    
    void reset();

    bool update();
    
    void updateVolume(const NLMISC::CVector& listener);
    
private:
    
    void copySampleTo16BitsTrack(void *dst, void *src, uint nbSample, TSampleFormat sourceFormat);
    
    enum TSourceState
    {
        source_stoped,
        source_playing,
        source_silencing,
        source_swap_pending
    };
    
    
    void                    release();
    
    // The minimum size of available space in the DS buffer for update
    static const uint32         _UpdateCopySize;
    // The size of the samples that are copied when buffers are swapped
    static const uint32         _SwapCopySize;
    // The number of channels
    static const uint           _DefaultChannels;
    // The default sample rate
    static const uint           _DefaultSampleRate;
    // The default sample size
    static const uint           _DefaultSampleSize;
    // The length of the crossfade, in samples
    static const uint32         _XFadeSize;
    
    struct TCursors
    {
        uint32      PlayCursor;
        uint32      WriteCursor;
        uint32      WriteSize;
    };
    
    struct TLockedBufferInfo
    {
        // First locked part.
        sint16      *Ptr1;
        uint32      Size1;

        // second locked part (or 0 if none)
        sint16      *Ptr2;
        uint32      Size2;
    };
    
    // Utility function that locks the DirectSound buffer and restores it if it was lost.
//  bool                    lock(uint32 writePos, uint32 size, uint8* &ptr1, DWORD &bytes1, uint8* &ptr2, DWORD &bytes2);
    bool                    lock(uint32 writePos, uint32 size, TLockedBufferInfo &lockedInfo);
    
    // Utility function that unlocks the DirectSound buffer
//  bool                    unlock(uint8* ptr1, DWORD bytes1, uint8* ptr2, DWORD bytes2);
    bool                    unlock(const TLockedBufferInfo &lockedInfo);
    
    void                    getCursors(TCursors &cursors);
    uint32                  checkFillCursor();
    
    
    void                    fillData(const TLockedBufferInfo &lbi, int nbSample);
    void                    fillData(sint16 *dst, uint nbSample);
    void                    fillSilence(const TLockedBufferInfo &lbi, int nbSample);
    
    void                    xfade(const TLockedBufferInfo &lbi, sint16 *src);
    void                    fadeOut(const TLockedBufferInfo &lbi);
    void                    fadeIn(const TLockedBufferInfo &lbi);
    
    void                    advanceFill(TLockedBufferInfo &lbi, uint nbSample);
    
    
    
    // Replace the current buffer with the swap buffer
    void                    swap();
    // getFadeOutSize() calculates how many samples have been written after the
    // write cursor in the DirectSound buffer. This value is returned in the
    // writtenTooMuch variable. The xfadeSize contains the number of samples over
    // which to do a xfade or fade out, and in1 points to the sample in the sample
    // buffer where to start the fade.
//  void                    getFadeOutSize(uint32 writePos, uint32& xfadeSize, sint16* &in1, uint32 &writtenTooMuch);
    
    // Fill the buffer with fresh samples. Should be called inside the critical zone.
    bool                    fill();
    // Fill the buffer with sparkling silence. Should be called inside the critical zone.
    bool                    silence();
    // Do a cross fade between the current buffer and the buffer stored in the _SwapBuffer
    // variable. Call inside the critical zone.
    void                    crossFade();
    // Fade out the current buffer. Call inside the critical zone.
    void                    fadeOut();
    // Fade in the current buffer. Call inside the critical zone.
    void                    fadeIn();
    bool                    needsUpdate();
    
    
    // Source name
    uint                    _SourceName;
    
    
    TSourceState            _State;
//  uint32                  _FillCursor;
    
    // The size of the sound buffer, in bytes
//    uint32                    _BufferSize;
    
    IBuffer                 *_Sample;
    // Size of the buffer in sample
    uint                    _SampleSize;
    // Position in the buffer in sample.
    uint                    _SampleOffset;
    // The number of sample realy played (depend on play cursor).
    uint32                  _PlayOffset;
    TSampleFormat           _Format;
    uint                    _SampleFreq;
    
    
    // The frequency of the source [0,10], i.e. slowed down or accelerated
    float                   _Freq;
    // The sample rate of the source (= _Freq * _Buffer sample rate)
    uint32                  _SampleRate;
    
    
    IBuffer                 *_NextSample;
    
    uint32                  _LastPlayPos;
    uint32                  _FillOffset;
    uint32                  _SilenceWriten;
    
    // The next sound buffer
//    IBuffer                   *_SwapBuffer;
    
    // To loop or not to loop
    bool                    _Loop;
    
    // The state of the source (playing, paused, stopped)
//  TSourceDSoundUserState  _UserState;
    
    // DirectSound secondary buffer
    LPDIRECTSOUNDBUFFER     _SecondaryBuffer;
    // The byte size of the DirectSound secondary buffers
    static const uint32         _SecondaryBufferSize;
    // The mask for the buffer size
    static const uint32         _SizeMask;
    // 3D interface of the secondary buffer.
    LPDIRECTSOUND3DBUFFER   _3DBuffer;
    // The critial section object to protect the swap and update functions
    CRITICAL_SECTION        _CriticalSection;
    
    // The state for ADPCM decompression.
    IBuffer::TADPCMState    _ADPCMState;
    
    
    // The state of the DirectSound buffer (filling, silencing, silenced)
//  TSourceDSoundBufferState _SecondaryBufferState;
    
    
    
    // The next position in the DirectSound buffer where we should write next
//    uint32                    _NextWritePos;
    
    // The total number of bytes written from the current sound buffer
//    uint32                    _BytesWritten;
    
    // The amount of silence written (in bytes) after the end of the current sound buffer
//    uint32                    _SilenceWritten;
    
    // The position of the last audio sample written.
//    uint32                    _EndPosition;
    
    
    // The state of the buffer to reach the end of the audio samples. To flag the buffer as
    // STOPPED, we have to make sure all the samples in the buffer are played. The play
    // cursor in the DirectSound buffer is inspected and when it crosses the position of
    // the last sample written (_EndPosition) the buffer is flagged as stopped. The _EndState
    // field is used to keep a trace of the whereabouts of the play cursor.
//  TSourceDSoundEndState   _EndState;
    
    
    // Has this source been handed out.
/*  bool                    _IsUsed;
    
    // Set the 'used' state of the source. Managed by the driver.
    void                    setUsed(bool v) { _IsUsed = v; }
    
    // Return the 'used' state of the source
    bool                    isUsed() { return _IsUsed; }
*/
    sint32                  _Volume;
    float                   _Gain;
    double                  _Alpha;
    NLMISC::CVector         _Pos;
    bool                    _PosRelative;

#if EAX_AVAILABLE == 1
    LPKSPROPERTYSET         _EAXSource;
#endif
    
    
#if NLSOUND_PROFILE
    
public:
    
    static double _LastSwapTime;
    static double _TotalSwapTime;
    static double _MaxSwapTime;
    static double _MinSwapTime;
    static uint32 _SwapCount;
    
    static double _TotalUpdateTime;
    static double _MaxUpdateTime;
    static double _MinUpdateTime;
    static uint32 _UpdateCount;
    static uint32 _TotalUpdateSize;
    
    static double _PosTime;
    static double _LockTime;
    static double _CopyTime;
    static double _UnlockTime;
    static uint32 _CopyCount;
    
public:
    
    static double getTestLast()    { return 1000.0f * _LastSwapTime; };
    static double getTestMax()     { return 1000.0f * _MaxSwapTime; };
    static double getTestMin()     { return 1000.0f * _MinSwapTime; };
    static double getTestAverage() { return (_SwapCount > 0) ? 1000.0f * _TotalSwapTime / _SwapCount : 0.0; };
    
    static double getAveragePosTime()    { return (_CopyCount > 0) ? 1000.0f * _PosTime / _CopyCount : 0.0; };
    static double getAverageLockTime()   { return (_CopyCount > 0) ? 1000.0f * _LockTime / _CopyCount : 0.0; };
    static double getAverageCopyTime()   { return (_CopyCount > 0) ? 1000.0f * _CopyTime / _CopyCount : 0.0; };
    static double getAverageUnlockTime() { return (_CopyCount > 0) ? 1000.0f * _UnlockTime / _CopyCount : 0.0; };
    static double getAverageCumulTime()  { return (_CopyCount > 0) ? 1000.0f * (_PosTime + _LockTime + _CopyTime +  _UnlockTime) / _CopyCount : 0.0; };
    static uint   getAverageUpdateSize() { return (_CopyCount > 0) ? (uint) (_TotalUpdateSize / _CopyCount) : 0; };
    
    static double getMaxUpdateTime() { return 1000.0f * _MaxUpdateTime; };
    static double getMinUpdateTime() { return 1000.0f * _MinUpdateTime; };
    static double getAverageUpdateTime() { return (_UpdateCount > 0) ? 1000.0f * _TotalUpdateTime / _UpdateCount : 0.0; };
    
    static double getTotalUpdateTime() { return 1000.0f * _TotalUpdateTime; };
    static double getUpdateBytesPerMsec() { return (_UpdateCount > 0) ? _TotalUpdateSize / _TotalUpdateTime / 1000.0 : 0.0; }
    
#endif
    
};


} // NLSOUND


#endif // NL_SOURCE_DSOUND_H

/* End of source_al.h */