From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a03430.html | 4797 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 4797 insertions(+) create mode 100644 docs/doxygen/nel/a03430.html (limited to 'docs/doxygen/nel/a03430.html') diff --git a/docs/doxygen/nel/a03430.html b/docs/doxygen/nel/a03430.html new file mode 100644 index 00000000..05287924 --- /dev/null +++ b/docs/doxygen/nel/a03430.html @@ -0,0 +1,4797 @@ + + +NeL: NLSOUND::CSourceDSound class Reference + + + +
+

NLSOUND::CSourceDSound Class Reference

#include <source_dsound.h> +

+

Inheritance diagram for NLSOUND::CSourceDSound: +

+ +NLSOUND::ISource + +

Detailed Description

+DirectSound sound source

+For arguments as 3D vectors, use the NeL vector coordinate system

+

Author:
Peter Hanappe

+Nevrax France

+
Date:
2002
+ +

+ +

+Definition at line 99 of file source_dsound.h. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

 CSourceDSound (uint sourcename=0)
 Constructor.

IBuffergetBuffer ()
 Returns the buffer associated with this source.

void init (LPDIRECTSOUND8 directSound, bool useEax)
 Initialize the DirectSound buffers. Called by the sound driver only.

void reset ()
virtual void setAlpha (double a)
uint sourceName ()
 Return the OpenAL source name.

void updateVolume (const NLMISC::CVector &listener)
virtual ~CSourceDSound ()
 Destructor.

Initialization
virtual void setStreamLoader (ILoader *loader)
Source properties
virtual void getCone (float &innerAngle, float &outerAngle, float &outerGain) const
 Get the cone angles (in radian).

virtual void getDirection (NLMISC::CVector &dir) const
 Get the direction vector.

virtual float getGain () const
 Get the gain.

virtual void getMinMaxDistances (float &mindist, float &maxdist) const
 Get the min and max distances.

virtual float getPitch () const
 Get the pitch.

const NLMISC::CVectorgetPos () const
virtual bool getSourceRelativeMode () const
 Get the source relative mode.

virtual void getVelocity (NLMISC::CVector &vel) const
 Get the velocity vector.

virtual void setCone (float innerAngle, float outerAngle, float outerGain)
 Set the cone angles (in radian) and gain (in [0 , 1]) (default: 2PI, 2PI, 0) (3D mode only).

virtual void setDirection (const NLMISC::CVector &dir)
 Set the direction vector (3D mode only) (default: (0,0,0) as non-directional).

virtual void setEAXProperty (uint prop, void *value, uint valuesize)
 Set any EAX source property if EAX available.

virtual void setGain (float gain)
virtual void setMinMaxDistances (float mindist, float maxdist, bool deferred)
 Set the min and max distances (default: 1, MAX_FLOAT) (3D mode only).

virtual void setPitch (float pitch)
virtual void setPos (const NLMISC::CVector &pos, bool deferred)
virtual void setSourceRelativeMode (bool mode)
 Set the source relative mode. If true, positions are interpreted relative to the listener position (default: false).

virtual void setVelocity (const NLMISC::CVector &vel, bool deferred)
 Set the velocity vector (3D mode only) (default: (0,0,0)).

Playback control
virtual bool getLooping () const
 Return the looping state.

virtual uint32 getTime ()
 Returns the number of milliseconds the source has been playing.

virtual bool isPaused () const
 Return the paused state.

virtual bool isPlaying () const
 Return the playing state.

virtual bool isStopped () const
 Return true if playing is finished or stop() has been called.

virtual void pause ()
 Pause. Call play() to resume.

virtual bool play ()
 Play the static buffer (or stream in and play).

virtual void setLooping (bool l)
 Set looping on/off for future playbacks (default: off).

virtual void stop ()
 Stop playing.

virtual bool update ()
 Update the source (e.g. continue to stream the data in).

Initialization
virtual IBuffergetStaticBuffer ()
 Return the buffer, or NULL if streaming is used.

virtual void setStaticBuffer (IBuffer *buffer)
Initialization
virtual void setStreamLoader (ILoader *loader)

Protected Attributes

ILoader_Loader

Private Types

enum  TSourceState { source_stoped, +source_playing, +source_silencing, +source_swap_pending + }

Private Member Functions

void advanceFill (TLockedBufferInfo &lbi, uint nbSample)
uint32 checkFillCursor ()
void copySampleTo16BitsTrack (void *dst, void *src, uint nbSample, TSampleFormat sourceFormat)
void crossFade ()
void fadeIn ()
void fadeIn (const TLockedBufferInfo &lbi)
void fadeOut ()
void fadeOut (const TLockedBufferInfo &lbi)
bool fill ()
void fillData (sint16 *dst, uint nbSample)
void fillData (const TLockedBufferInfo &lbi, int nbSample)
void fillSilence (const TLockedBufferInfo &lbi, int nbSample)
void getCursors (TCursors &cursors)
bool lock (uint32 writePos, uint32 size, TLockedBufferInfo &lockedInfo)
bool needsUpdate ()
 Check whether the play position has advanced enough to require an update.

void release ()
 Release all DirectSound resources.

bool silence ()
void swap ()
bool unlock (const TLockedBufferInfo &lockedInfo)
void xfade (const TLockedBufferInfo &lbi, sint16 *src)

Private Attributes

LPDIRECTSOUND3DBUFFER _3DBuffer
IBuffer::TADPCMState _ADPCMState
double _Alpha
CRITICAL_SECTION _CriticalSection
uint32 _FillOffset
TSampleFormat _Format
float _Freq
float _Gain
uint32 _LastPlayPos
bool _Loop
IBuffer_NextSample
uint32 _PlayOffset
NLMISC::CVector _Pos
IBuffer_Sample
uint _SampleFreq
uint _SampleOffset
uint32 _SampleRate
uint _SampleSize
LPDIRECTSOUNDBUFFER _SecondaryBuffer
uint32 _SilenceWriten
uint _SourceName
TSourceState _State
sint32 _Volume

Static Private Attributes

const uint _DefaultChannels = 1
const uint _DefaultSampleRate = 22050
const uint _DefaultSampleSize = 16
const uint32 _SecondaryBufferSize = 0x10000
const uint32 _SizeMask = 0xffff
const uint32 _SwapCopySize = 0x8000
const uint32 _UpdateCopySize = 0x4000
const uint32 _XFadeSize = 64

Friends

class CSoundDriverDSound
+


Member Enumeration Documentation

+

+ + + + +
+ + +
enum NLSOUND::CSourceDSound::TSourceState [private] +
+
+ + + + + +
+   + + +

+

Enumeration values:
+ + + + + +
source_stoped  +
source_playing  +
source_silencing  +
source_swap_pending  +
+
+ +

+Definition at line 271 of file source_dsound.h. +

+

00272         {
+00273                 source_stoped,
+00274                 source_playing,
+00275                 source_silencing,
+00276                 source_swap_pending
+00277         };
+
+


Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + + + +
NLSOUND::CSourceDSound::CSourceDSound uint  sourcename = 0  ) 
+
+ + + + + +
+   + + +

+Constructor. +

+ +

+Definition at line 111 of file source_dsound.cpp. +

+References _3DBuffer, _Alpha, _CriticalSection, _DefaultSampleRate, _FillOffset, _LastPlayPos, _Loop, _PlayOffset, _Sample, _SampleFreq, _SampleOffset, _SampleRate, _SampleSize, _SecondaryBuffer, _State, NLSOUND::Mono8, source_stoped, and uint. +

+

00112 :       ISource(), 
+00113         _SourceName(sourcename)
+00114 {
+00115 #if EAX_AVAILABLE == 1
+00116         _EAXSource = 0;
+00117 #endif
+00118         _Sample = 0;
+00119         _SampleSize = 0;
+00120         _SampleOffset = 0;
+00121         _Format = Mono8;
+00122         _SampleFreq = _DefaultSampleRate;
+00123         _FillOffset = 0;
+00124         _State = source_stoped;
+00125         _PlayOffset = 0;
+00126         _LastPlayPos = 0;
+00127 
+00128 //      _BufferSize = 0;
+00129 //      _SwapBuffer = 0;
+00130         _SecondaryBuffer = 0;
+00131 //      _SecondaryBufferState = NL_DSOUND_SILENCED;
+00132         _3DBuffer = 0;
+00133 //      _NextWritePos = 0;
+00134 //      _BytesWritten = 0;
+00135 //      _SilenceWritten = 0;
+00136         _Loop = false;
+00137 //      _EndPosition = 0;
+00138 //      _EndState = NL_DSOUND_TAIL1;
+00139 //      _UserState = NL_DSOUND_STOPPED;
+00140         _Freq = 1.0f;
+00141         _SampleRate = _DefaultSampleRate;
+00142 //      _IsUsed = false;
+00143         _Gain = 1.0f;
+00144         _Volume = 0;
+00145         _Alpha = 0.0;
+00146         InitializeCriticalSection(&_CriticalSection);
+00147 }
+
+

+ + + + +
+ + + + + + + + + +
NLSOUND::CSourceDSound::~CSourceDSound  )  [virtual]
+
+ + + + + +
+   + + +

+Destructor. +

+ +

+Definition at line 152 of file source_dsound.cpp. +

+References _CriticalSection, nldebug, and release(). +

+

00153 {
+00154         nldebug("Destroying DirectSound source");
+00155 
+00156         CSoundDriverDSound::instance()->removeSource(this);
+00157 
+00158         EnterCriticalSection(&_CriticalSection); 
+00159 
+00160         // Release the DirectSound buffer within the critical zone
+00161         // to avoid a call to update during deconstruction
+00162         release();
+00163 
+00164         LeaveCriticalSection(&_CriticalSection); 
+00165         DeleteCriticalSection(&_CriticalSection);
+00166 }
+
+


Member Function Documentation

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLSOUND::CSourceDSound::advanceFill TLockedBufferInfo lbi,
uint  nbSample
[private]
+
+ + + + + +
+   + + +

+ +

+Definition at line 662 of file source_dsound.cpp. +

+References _FillOffset, _SecondaryBufferSize, _SizeMask, nlassert, NLSOUND::CSourceDSound::TLockedBufferInfo::Ptr1, NLSOUND::CSourceDSound::TLockedBufferInfo::Ptr2, size, NLSOUND::CSourceDSound::TLockedBufferInfo::Size1, NLSOUND::CSourceDSound::TLockedBufferInfo::Size2, uint, and uint32. +

+Referenced by play(), stop(), and update(). +

+

00663 {
+00664         uint32 size = nbSample * 2;
+00665         if (lbi.Size1 < size)
+00666         {
+00667                 size -= lbi.Size1;
+00668                 lbi.Size1 = lbi.Size2;
+00669                 lbi.Size2 = 0;
+00670                 lbi.Ptr1 = lbi.Ptr2;
+00671                 lbi.Ptr2 = 0;
+00672         }
+00673 
+00674         nlassert(lbi.Size1 >= size);
+00675         lbi.Size1 -= size;
+00676         lbi.Ptr1 += size/2;
+00677 
+00678         _FillOffset += nbSample*2;
+00679         nlassert(_FillOffset == (_FillOffset & 0xfffffffC));
+00680         _FillOffset &= _SizeMask;
+00681 //      if (_FillOffset >= _SecondaryBufferSize)
+00682 //              _FillOffset -= _SecondaryBufferSize;
+00683         nlassert(_FillOffset < _SecondaryBufferSize);
+00684 }
+
+

+ + + + +
+ + + + + + + + + +
uint32 NLSOUND::CSourceDSound::checkFillCursor  )  [private]
+
+ + + + + +
+   + + +

+

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void NLSOUND::CSourceDSound::copySampleTo16BitsTrack void *  dst,
void *  src,
uint  nbSample,
TSampleFormat  sourceFormat
[private]
+
+ + + + + +
+   + + +

+

+

+ + + + +
+ + + + + + + + + +
void NLSOUND::CSourceDSound::crossFade  )  [private]
+
+ + + + + +
+   + + +

+

+

+ + + + +
+ + + + + + + + + +
void NLSOUND::CSourceDSound::fadeIn  )  [private]
+
+ + + + + +
+   + + +

+ +

+Referenced by play().

+

+ + + + +
+ + + + + + + + + + +
void NLSOUND::CSourceDSound::fadeIn const TLockedBufferInfo lbi  )  [private]
+
+ + + + + +
+   + + +

+ +

+Definition at line 627 of file source_dsound.cpp. +

+References _XFadeSize, alpha, count, nlassert, NLSOUND::CSourceDSound::TLockedBufferInfo::Ptr1, NLSOUND::CSourceDSound::TLockedBufferInfo::Ptr2, sint, sint16, NLSOUND::CSourceDSound::TLockedBufferInfo::Size1, NLSOUND::CSourceDSound::TLockedBufferInfo::Size2, and uint. +

+

00628 {
+00629         // do the XFade in integer fixed point arithmetic
+00630 
+00631         nlassert((_XFadeSize & 0x1) == 0);
+00632         uint    fade = _XFadeSize;
+00633         sint16  *ptr = lbi.Ptr1;
+00634         uint    count = lbi.Size1 /2;
+00635         sint    alpha, invAlpha;
+00636 
+00637         while (fade && count)
+00638         {
+00639                 alpha = (fade<<16) / _XFadeSize;
+00640                 invAlpha = 0x10000 - alpha;
+00641                 *ptr = (*ptr*invAlpha) >> 16;
+00642                 ++ptr;
+00643                 --count;
+00644                 --fade;
+00645         }
+00646 
+00647         ptr = lbi.Ptr2;
+00648         count = lbi.Size2 /2;
+00649 
+00650         while (fade && count)
+00651         {
+00652                 alpha = (fade<<16) / _XFadeSize;
+00653                 invAlpha = 0x10000 - alpha;
+00654                 *ptr = (*ptr*invAlpha) >> 16;
+00655                 ++ptr;
+00656                 --count;
+00657                 --fade;
+00658         }
+00659 }
+
+

+ + + + +
+ + + + + + + + + +
void NLSOUND::CSourceDSound::fadeOut  )  [private]
+
+ + + + + +
+   + + +

+ +

+Referenced by stop(), and update().

+

+ + + + +
+ + + + + + + + + + +
void NLSOUND::CSourceDSound::fadeOut const TLockedBufferInfo lbi  )  [private]
+
+ + + + + +
+   + + +

+ +

+Definition at line 598 of file source_dsound.cpp. +

+References _XFadeSize, alpha, count, nlassert, NLSOUND::CSourceDSound::TLockedBufferInfo::Ptr1, NLSOUND::CSourceDSound::TLockedBufferInfo::Ptr2, sint, sint16, NLSOUND::CSourceDSound::TLockedBufferInfo::Size1, NLSOUND::CSourceDSound::TLockedBufferInfo::Size2, and uint. +

+

00599 {
+00600         nlassert((_XFadeSize & 0x1) == 0);
+00601         uint    fade = _XFadeSize;
+00602         sint16  *ptr = lbi.Ptr1;
+00603         uint    count = lbi.Size1/2;
+00604         sint    alpha;
+00605 
+00606         while (fade && count)
+00607         {
+00608                 alpha = (fade<<16) / _XFadeSize;
+00609                 *ptr = (*ptr*alpha) >> 16;
+00610                 ++ptr;
+00611                 --count;
+00612                 --fade;
+00613         }
+00614 
+00615         ptr = lbi.Ptr2;
+00616         count = lbi.Size2/2;
+00617 
+00618         while (fade && count)
+00619         {
+00620                 alpha = (fade<<16) / _XFadeSize;
+00621                 *ptr = (*ptr*alpha) >> 16;
+00622                 ++ptr;
+00623                 --count;
+00624                 --fade;
+00625         }
+00626 }
+
+

+ + + + +
+ + + + + + + + + +
bool NLSOUND::CSourceDSound::fill  )  [private]
+
+ + + + + +
+   + + +

+

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLSOUND::CSourceDSound::fillData sint16 dst,
uint  nbSample
[private]
+
+ + + + + +
+   + + +

+ +

+Definition at line 432 of file source_dsound.cpp. +

+References _ADPCMState, _Sample, _SampleOffset, _SampleSize, data, NLSOUND::Mono16, NLSOUND::Mono16ADPCM, NLSOUND::Mono8, nlassert, nldebug, sint16, sint8, NLSOUND::Stereo16, NLSOUND::Stereo8, uint, and uint8. +

+

00433 {
+00434         nlassert((nbSample & 0xfffffffe) == nbSample);
+00435         if (_Sample != 0)
+00436         {
+00437                 void    *data = ((CBufferDSound*) _Sample)->getData();
+00438                 sint8   *data8;
+00439                 uint8   *dataAdpcm;
+00440                 sint16  *data16;
+00441                 uint    i;
+00442 
+00443 //nldebug("Filling from %p to %p (%p sample, %p bytes)", dst, dst+nbSample, nbSample, nbSample*2);
+00444 
+00445                 
+00446                 switch(_Format)
+00447                 {
+00448                 case Mono8:
+00449                         data8 = (sint8*) data;
+00450                         data8 += _SampleOffset;
+00451 //      nldebug(" with data (Mono8) from %p to %p (sample : base = %p, size = %p)", data8, data8+nbSample, data, _SampleSize);
+00452                         for (i=0; i<nbSample; ++i)
+00453                         {
+00454                                 dst[i] = sint16(data8[i])*256;
+00455                         }
+00456                         _SampleOffset += nbSample;
+00457                         break;
+00458                 case Mono16ADPCM:
+00459                         dataAdpcm = (uint8*) data;
+00460                         dataAdpcm += _SampleOffset/2;
+00461 //nldebug("Filling ADPCM : %p => %p with %p to %p", dst, dst+nbSample, dataAdpcm - (uint8*)data, dataAdpcm + (nbSample/2)-(uint8*)data);
+00462 //nldebug(" with data (Mono16ADPCM) from %p to %p (sample : base = %p, size = %p)", dataAdpcm, dataAdpcm+(nbSample/2), data, _SampleSize*2);
+00463                         IBuffer::decodeADPCM(dataAdpcm, dst, nbSample, _ADPCMState);
+00464                         _SampleOffset += nbSample;
+00465                         break;
+00466                 case Mono16:
+00467                         data16 = (sint16*)data;
+00468                         data16 += _SampleOffset;
+00469 //nldebug("Filling Mono16 : %p => %p with %p to %p", dst, dst+nbSample, data16 - (sint16*)data, data16 + (nbSample)-(sint16*)data);
+00470 //      nldebug(" with data (Mono16) from %p to %p (sample : base = %p, size = %p)", data16, data16+nbSample, data, _SampleSize/2);
+00471                         CFastMem::memcpy(dst, data16, nbSample*2);
+00472                         _SampleOffset += nbSample;
+00473                         break;
+00474                 case Stereo8:
+00475                         data8 = (sint8*) data;
+00476                         data8 += _SampleOffset*2;
+00477                         for (i=0; i<nbSample; ++i)
+00478                         {
+00479                                 dst[i] = (sint16(data8[i*2])*128) + (sint16(data8[i*2+1])*128);
+00480                         }
+00481                         _SampleOffset += nbSample*2;
+00482                         break;
+00483                 case Stereo16:
+00484                         data16 = (sint16*) data;
+00485                         data16 += _SampleOffset*2;
+00486                         for (i=0; i<nbSample; ++i)
+00487                         {
+00488                                 dst[i] = (data16[i*2]>>1) + (data16[i*2+1]>>1);
+00489                         }
+00490                         _SampleOffset += nbSample*2;
+00491                         break;
+00492                 }
+00493 
+00494 /*              if (_SampleOffset == _SampleSize)
+00495                 {
+00496                         _SampleOffset = 0;
+00497                         _ADPCMState.PreviousSample = 0;
+00498                         _ADPCMState.StepIndex = 0;
+00499                 }
+00500 */
+00501 
+00502                 nlassert(_SampleOffset <= _SampleSize);
+00503         }
+00504         else
+00505         {
+00506         nldebug("Filling : NO DATA from %p to %p (%p sample, %p bytes)", dst, dst+nbSample, nbSample, nbSample*2);
+00507 
+00508                 // write silence in the dst.
+00509                 while (nbSample)
+00510                 {
+00511                         *dst++ = 0;
+00512                         --nbSample;
+00513                 }
+00514         }
+00515 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLSOUND::CSourceDSound::fillData const TLockedBufferInfo lbi,
int  nbSample
[private]
+
+ + + + + +
+   + + +

+ +

+Definition at line 517 of file source_dsound.cpp. +

+References min, nlassert, NLSOUND::CSourceDSound::TLockedBufferInfo::Ptr1, NLSOUND::CSourceDSound::TLockedBufferInfo::Ptr2, size, NLSOUND::CSourceDSound::TLockedBufferInfo::Size1, NLSOUND::CSourceDSound::TLockedBufferInfo::Size2, uint, and uint32. +

+Referenced by play(), and update(). +

+

00518 {
+00519         nlassert((nbSample & 0x1) == 0);
+00520 /*      nlassert(lbi.Size1 != 0);
+00521         nlassert(lbi.Ptr1 != NULL);
+00522 */      uint size = std::min(uint32(nbSample), lbi.Size1>>1);
+00523         fillData(lbi.Ptr1, size);
+00524         nbSample -= size;
+00525 
+00526         if (nbSample)
+00527         {
+00528 /*              nlassert(lbi.Size2 != 0);
+00529                 nlassert(lbi.Ptr2 != NULL);
+00530 */              size = min(uint32(nbSample), lbi.Size2>>1);
+00531                 fillData(lbi.Ptr2, size);
+00532                 nbSample -= size;
+00533         }
+00534         nlassert(nbSample == 0);
+00535 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLSOUND::CSourceDSound::fillSilence const TLockedBufferInfo lbi,
int  nbSample
[private]
+
+ + + + + +
+   + + +

+ +

+Definition at line 537 of file source_dsound.cpp. +

+References min, nlassert, NLSOUND::CSourceDSound::TLockedBufferInfo::Ptr1, NLSOUND::CSourceDSound::TLockedBufferInfo::Ptr2, sint16, size, NLSOUND::CSourceDSound::TLockedBufferInfo::Size1, NLSOUND::CSourceDSound::TLockedBufferInfo::Size2, uint, and uint32. +

+Referenced by play(), stop(), and update(). +

+

00538 {
+00539         uint size = min(uint32(nbSample), lbi.Size1>>1);
+00540         uint tmp = size;
+00541         sint16  *ptr = lbi.Ptr1;
+00542 //      nldebug("Silencing from %p to %p (%p sample, %p bytes)", ptr, ptr+size, size, size*2);
+00543 
+00544         for (; size != 0; --size)
+00545                 *ptr++ = 0;
+00546         nbSample -= tmp;
+00547 
+00548         if (nbSample)
+00549         {
+00550                 size = std::min(uint32(nbSample), lbi.Size2>>1);
+00551                 tmp = size;
+00552                 ptr = lbi.Ptr2;
+00553 //      nldebug("Silencing from %p to %p (%p sample, %p bytes)", ptr, ptr+size, size, size*2);
+00554                 for (; size != 0; --size)
+00555                         *ptr++ = 0;
+00556                 nbSample -= tmp;
+00557         }
+00558         nlassert(nbSample == 0);
+00559 
+00560 }
+
+

+ + + + +
+ + + + + + + + + +
IBuffer * NLSOUND::CSourceDSound::getBuffer  ) 
+
+ + + + + +
+   + + +

+Returns the buffer associated with this source. +

+ +

+Definition at line 1803 of file source_dsound.cpp. +

+References _Sample. +

+

01804 {       
+01805         return _Sample;
+01806 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NLSOUND::CSourceDSound::getCone float &  innerAngle,
float &  outerAngle,
float &  outerGain
const [virtual]
+
+ + + + + +
+   + + +

+Get the cone angles (in radian). +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 1745 of file source_dsound.cpp. +

+References _3DBuffer, nlwarning, and NLMISC::Pi. +

+

01746 {
+01747         if (_3DBuffer != 0)
+01748         {
+01749                 DWORD inner, outer;
+01750                 LONG volume;
+01751 
+01752                 if (_3DBuffer->GetConeAngles(&inner, &outer) != DS_OK)
+01753                 {
+01754                         nlwarning("GetConeAngles failed");                      
+01755                         innerAngle = outerAngle = (float)(2.0 * Pi);
+01756                 }
+01757                 else
+01758                 {
+01759                         innerAngle = (float)(Pi * inner / 180.0);
+01760                         outerAngle = (float)(Pi * outer / 180.0);
+01761                 }
+01762 
+01763                 if (_3DBuffer->GetConeOutsideVolume(&volume) != DS_OK)
+01764                 {
+01765                         nlwarning("GetConeOutsideVolume failed");               
+01766                         outerGain = 0.0f;
+01767                 }
+01768                 else
+01769                 {
+01770                         outerGain = (float) pow(10, (double) volume / 20.0 / 100.0);
+01771                 }
+01772         }
+01773         else
+01774         {
+01775                 nlwarning("Requested getCone on a non-3D source");
+01776         }
+01777 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLSOUND::CSourceDSound::getCursors TCursors cursors  )  [private]
+
+ + + + + +
+   + + +

+ +

+Definition at line 419 of file source_dsound.cpp. +

+References _SecondaryBuffer, _SizeMask, _UpdateCopySize, min, NLSOUND::CSourceDSound::TCursors::PlayCursor, NLSOUND::CSourceDSound::TCursors::WriteCursor, and NLSOUND::CSourceDSound::TCursors::WriteSize. +

+Referenced by play(), stop(), and update(). +

+

00420 {
+00421         _SecondaryBuffer->GetCurrentPosition((DWORD*)&cursors.PlayCursor, (DWORD*)&cursors.WriteCursor);
+00422         // add a security margin to the write cursor
+00423 /*      cursors.WriteCursor += _UpdateCopySize;
+00424         if (cursors.WriteCursor > _SecondaryBufferSize)
+00425                 cursors.WriteCursor -= _SecondaryBufferSize;
+00426 */
+00427         // compute the available write size
+00428 //      cursors.WriteSize = std::min(_UpdateCopySize, cursors.PlayCursor + _SecondaryBufferSize - cursors.WriteCursor);
+00429         cursors.WriteSize = std::min(_UpdateCopySize, (cursors.PlayCursor - cursors.WriteCursor) & _SizeMask);
+00430 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLSOUND::CSourceDSound::getDirection NLMISC::CVector dir  )  const [virtual]
+
+ + + + + +
+   + + +

+Get the direction vector. +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 1398 of file source_dsound.cpp. +

+References _3DBuffer, nlwarning, NLMISC::CVector::set(), and v. +

+

01399 {
+01400         if (_3DBuffer != NULL)
+01401         {
+01402                 D3DVECTOR v;
+01403 
+01404                 if (_3DBuffer->GetConeOrientation(&v) != DS_OK)
+01405                 {
+01406                         nlwarning("GetConeOrientation failed");
+01407                         dir.set(0, 0, 1);       
+01408                 }
+01409                 else
+01410                 {
+01411                         dir.set(v.x, v.z, v.y);
+01412                 }
+01413         }
+01414         else
+01415         {
+01416                 dir.set(0, 0, 1);       
+01417         }
+01418 }
+
+

+ + + + +
+ + + + + + + + + +
float NLSOUND::CSourceDSound::getGain  )  const [virtual]
+
+ + + + + +
+   + + +

+Get the gain. +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 1446 of file source_dsound.cpp. +

+

01447 {
+01448         return _Gain;
+01449 }
+
+

+ + + + +
+ + + + + + + + + +
bool NLSOUND::CSourceDSound::getLooping  )  const [virtual]
+
+ + + + + +
+   + + +

+Return the looping state. +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 874 of file source_dsound.cpp. +

+References _Loop. +

+

00875 {
+00876         return _Loop;
+00877 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLSOUND::CSourceDSound::getMinMaxDistances float &  mindist,
float &  maxdist
const [virtual]
+
+ + + + + +
+   + + +

+Get the min and max distances. +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 1580 of file source_dsound.cpp. +

+References _3DBuffer, min, and nlwarning. +

+Referenced by updateVolume(). +

+

01581 {
+01582         if (_3DBuffer != 0)
+01583         {
+01584                 D3DVALUE min, max;
+01585 
+01586                 if ((_3DBuffer->GetMinDistance(&min) != DS_OK)
+01587                         || (_3DBuffer->GetMaxDistance(&max) != DS_OK))
+01588                 {
+01589                         mindist = 0.0f;
+01590                         maxdist = 0.0f;
+01591                         nlwarning("GetMinDistance or GetMaxDistance failed");
+01592                 }
+01593                 else
+01594                 {
+01595                         mindist = min;
+01596                         maxdist = max;
+01597                 }
+01598         }
+01599         else
+01600         {
+01601                 mindist = 0.0f;
+01602                 maxdist = 0.0f;
+01603                 nlwarning("Requested getMinMaxDistances on a non-3D source");
+01604         }
+01605 }
+
+

+ + + + +
+ + + + + + + + + +
float NLSOUND::CSourceDSound::getPitch  )  const [virtual]
+
+ + + + + +
+   + + +

+Get the pitch. +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 1480 of file source_dsound.cpp. +

+References _Sample, _SecondaryBuffer, format, NLSOUND::IBuffer::getFormat(), nlwarning, NLSOUND::TSampleFormat, and uint. +

+

01481 {
+01482         if ((_Sample != 0) && (_SecondaryBuffer != 0))
+01483         {
+01484                 TSampleFormat format;
+01485                 uint freq0;
+01486                 DWORD freq;
+01487 
+01488                 _Sample->getFormat(format, freq0);
+01489 
+01490                 if (_SecondaryBuffer->GetFrequency(&freq) != DS_OK)
+01491                 {
+01492                         nlwarning("GetFrequency failed");
+01493                         return 1.0;
+01494                 }
+01495 
+01496                 return ((float) freq / (float) freq0);
+01497         }
+01498 
+01499         return 1.0;
+01500 }
+
+

+ + + + +
+ + + + + + + + + +
const NLMISC::CVector & NLSOUND::CSourceDSound::getPos  )  const [virtual]
+
+ + + + + +
+   + + +

+Get the position vector. See setPos() for details. +

+Implements NLSOUND::ISource. +

+Definition at line 1333 of file source_dsound.cpp. +

+Referenced by updateVolume(). +

+

01334 {
+01335         return _Pos;
+01336 }
+
+

+ + + + +
+ + + + + + + + + +
bool NLSOUND::CSourceDSound::getSourceRelativeMode  )  const [virtual]
+
+ + + + + +
+   + + +

+Get the source relative mode. +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 1534 of file source_dsound.cpp. +

+References _3DBuffer, and nlwarning. +

+

01535 {
+01536         if (_3DBuffer != 0)
+01537         {
+01538                 DWORD mode;
+01539 
+01540                 if (_3DBuffer->GetMode(&mode) != DS_OK)
+01541                 {
+01542                         nlwarning("GetMode failed");
+01543                         return false;
+01544                 }
+01545 
+01546                 return (mode == DS3DMODE_HEADRELATIVE);
+01547         }
+01548         else
+01549         {
+01550                 nlwarning("Requested setSourceRelativeMode on a non-3D source");
+01551                 return false;
+01552         }
+01553 }
+
+

+ + + + +
+ + + + + + + + + +
IBuffer * NLSOUND::CSourceDSound::getStaticBuffer  )  [virtual]
+
+ + + + + +
+   + + +

+Return the buffer, or NULL if streaming is used. +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 409 of file source_dsound.cpp. +

+References _NextSample, _Sample, _State, and source_swap_pending. +

+

00410 {
+00411         if (_State == source_swap_pending)
+00412                 return _NextSample;
+00413         else
+00414                 return _Sample;
+00415 
+00416 }
+
+

+ + + + +
+ + + + + + + + + +
uint32 NLSOUND::CSourceDSound::getTime  )  [virtual]
+
+ + + + + +
+   + + +

+Returns the number of milliseconds the source has been playing. +

+Update the source (e.g. continue to stream the data in) Returns an indication whether the source actually streamed data or not. +

+Reimplemented from NLSOUND::ISource. +

+Definition at line 203 of file source_dsound.cpp. +

+References _PlayOffset, _Sample, format, NLSOUND::IBuffer::getFormat(), NLSOUND::TSampleFormat, uint, and uint32. +

+

00204 { 
+00205         if (_Sample == 0)
+00206                 return 0;
+00207 
+00208         TSampleFormat format;
+00209         uint freq;
+00210 
+00211         _Sample->getFormat(format, freq);
+00212 
+00213         return uint32(1000.0f * (_PlayOffset+1) / (float)freq);
+00214 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLSOUND::CSourceDSound::getVelocity NLMISC::CVector vel  )  const [virtual]
+
+ + + + + +
+   + + +

+Get the velocity vector. +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 1355 of file source_dsound.cpp. +

+References _3DBuffer, nlwarning, NLMISC::CVector::set(), and v. +

+

01356 {
+01357         if (_3DBuffer != NULL)
+01358         {
+01359                 D3DVECTOR v;
+01360 
+01361                 if (_3DBuffer->GetVelocity(&v) != DS_OK)
+01362                 {
+01363                         nlwarning ("GetVelocity failed");
+01364                         vel.set(0, 0, 0);       
+01365                 }
+01366                 else
+01367                 {
+01368                         vel.set(v.x, v.z, v.y);
+01369                 }
+01370         }
+01371         else
+01372         {
+01373                 vel.set(0, 0, 0);       
+01374         }
+01375 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLSOUND::CSourceDSound::init LPDIRECTSOUND8  directSound,
bool  useEax
+
+ + + + + +
+   + + +

+Initialize the DirectSound buffers. Called by the sound driver only. +

+ +

+Definition at line 218 of file source_dsound.cpp. +

+References _3DBuffer, _DefaultChannels, _DefaultSampleRate, _DefaultSampleSize, _SecondaryBuffer, _SecondaryBufferSize, NLSOUND::CSoundDriverDSound::countHw2DBuffers(), NLSOUND::CSoundDriverDSound::countHw3DBuffers(), format, nldebug, and nlwarning. +

+

00219 {
+00220 
+00221         // Initialize the buffer format
+00222         WAVEFORMATEX format;
+00223 
+00224         format.cbSize = sizeof(WAVEFORMATEX);
+00225         format.nChannels = _DefaultChannels;
+00226         format.wBitsPerSample = _DefaultSampleSize;
+00227         format.nSamplesPerSec = _DefaultSampleRate;
+00228         format.nBlockAlign = format.nChannels * format.wBitsPerSample / 8;
+00229         format.nAvgBytesPerSec = format.nSamplesPerSec * format.nBlockAlign;
+00230         format.wFormatTag = WAVE_FORMAT_PCM;
+00231 
+00232 
+00233         // Initialize the buffer description 
+00234 
+00235         DSBUFFERDESC desc;
+00236 
+00237         CSoundDriverDSound* driver = CSoundDriverDSound::instance();
+00238 
+00239 
+00240         ZeroMemory(&desc, sizeof(DSBUFFERDESC));
+00241         desc.dwSize = sizeof(DSBUFFERDESC);
+00242         desc.lpwfxFormat = &format;
+00243         desc.dwBufferBytes = _SecondaryBufferSize;      
+00244         desc.dwReserved = 0; 
+00245 
+00246         if (driver->countHw3DBuffers() > 0)
+00247         {
+00248                 //nldebug("Source: Allocating 3D buffer in hardware");
+00249                 desc.dwFlags = DSBCAPS_GLOBALFOCUS | DSBCAPS_LOCHARDWARE | DSBCAPS_GETCURRENTPOSITION2 
+00250                                                 | DSBCAPS_CTRL3D | DSBCAPS_CTRLVOLUME | DSBCAPS_CTRLFREQUENCY | DSBCAPS_MUTE3DATMAXDISTANCE;
+00251         } 
+00252         else
+00253         {
+00254                 if (useEax)
+00255                 {
+00256                         throw ESoundDriver("No 3d hardware sound buffer, but EAX support requested");
+00257                 }
+00258                 //nldebug("Source: Allocating 3D buffer in software");
+00259                 desc.dwFlags = DSBCAPS_GLOBALFOCUS | DSBCAPS_LOCSOFTWARE | DSBCAPS_GETCURRENTPOSITION2 
+00260                                                 | DSBCAPS_CTRL3D | DSBCAPS_CTRLVOLUME | DSBCAPS_CTRLFREQUENCY | DSBCAPS_MUTE3DATMAXDISTANCE;
+00261                 desc.guid3DAlgorithm = DS3DALG_NO_VIRTUALIZATION;
+00262                 //desc.guid3DAlgorithm = DS3DALG_HRTF_FULL;
+00263         }
+00264 
+00265 
+00266         // Allocate the secondary buffer
+00267  
+00268         if (FAILED(directSound->CreateSoundBuffer(&desc, &_SecondaryBuffer, NULL))) 
+00269         {
+00270                 if (useEax)
+00271                 {
+00272                         throw ESoundDriver("Failed to create a 3d hardware sound buffer, but EAX support requested");
+00273                 }
+00274                 nlwarning("Source: Failed to create a buffer with 3D capabilities.");
+00275 
+00276                 ZeroMemory(&desc, sizeof(DSBUFFERDESC));
+00277                 desc.dwSize = sizeof(DSBUFFERDESC);
+00278                 desc.lpwfxFormat = &format;
+00279                 desc.dwBufferBytes = _SecondaryBufferSize;      
+00280                 desc.dwReserved = 0; 
+00281 
+00282                 if (driver->countHw2DBuffers() > 0)
+00283                 {
+00284                         //nldebug("Source: Allocating 2D buffer in hardware");
+00285                         desc.dwFlags = DSBCAPS_GLOBALFOCUS | DSBCAPS_LOCHARDWARE | DSBCAPS_GETCURRENTPOSITION2 | DSBCAPS_CTRLVOLUME | DSBCAPS_CTRLFREQUENCY;
+00286                 } 
+00287                 else
+00288                 {
+00289                         //nldebug("Source: Allocating 2D buffer in software");
+00290                         desc.dwFlags = DSBCAPS_GLOBALFOCUS | DSBCAPS_LOCSOFTWARE | DSBCAPS_GETCURRENTPOSITION2 | DSBCAPS_CTRLVOLUME | DSBCAPS_CTRLFREQUENCY;
+00291                 }
+00292 
+00293                 if (FAILED(directSound->CreateSoundBuffer(&desc, &_SecondaryBuffer, NULL))) 
+00294                 {
+00295                         throw ESoundDriver("Failed to allocate the DirectSound secondary buffer");
+00296                 }
+00297         }
+00298 
+00299 
+00300         nldebug("Created DirectX secondary buffer @ %p", _SecondaryBuffer);
+00301 
+00302         // Fill the buffer with silence
+00303         LPVOID ptr;
+00304         DWORD bytes;
+00305 
+00306         if (FAILED(_SecondaryBuffer->Lock(0, 0, &ptr, &bytes, NULL, NULL, DSBLOCK_ENTIREBUFFER)))
+00307         {
+00308                 throw ESoundDriver("Failed to lock the DirectSound secondary buffer");
+00309         }
+00310 
+00311         memset(ptr, 0, bytes);
+00312         
+00313         _SecondaryBuffer->Unlock(ptr, bytes, 0, 0);
+00314 
+00315         // Allocate the 3D interface, if necessary
+00316 
+00317         if (FAILED(_SecondaryBuffer->QueryInterface(IID_IDirectSound3DBuffer, (LPVOID *) &_3DBuffer)))
+00318         {
+00319            throw ESoundDriver("Failed to allocate the DirectSound 3D buffer");
+00320         }
+00321 
+00322 
+00323         if (FAILED(_SecondaryBuffer->Play(0, 0, DSBPLAY_LOOPING)))
+00324         {
+00325                 throw ESoundDriver("Play failed");
+00326         }
+00327 
+00328 }
+
+

+ + + + +
+ + + + + + + + + +
bool NLSOUND::CSourceDSound::isPaused  )  const [virtual]
+
+ + + + + +
+   + + +

+Return the paused state. +

+ +

+Definition at line 1030 of file source_dsound.cpp. +

+References nlassert. +

+

01031 {
+01032         // TODO
+01033         nlassert(false);
+01034         return false;
+01035 //      return (_UserState == NL_DSOUND_PAUSED);
+01036 }
+
+

+ + + + +
+ + + + + + + + + +
bool NLSOUND::CSourceDSound::isPlaying  )  const [virtual]
+
+ + + + + +
+   + + +

+Return the playing state. +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 1021 of file source_dsound.cpp. +

+References _State, source_playing, and source_swap_pending. +

+

01022 {
+01023 //      return (_UserState == NL_DSOUND_PLAYING);
+01024         return _State == source_playing || _State == source_swap_pending;
+01025 }
+
+

+ + + + +
+ + + + + + + + + +
bool NLSOUND::CSourceDSound::isStopped  )  const [virtual]
+
+ + + + + +
+   + + +

+Return true if playing is finished or stop() has been called. +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 1041 of file source_dsound.cpp. +

+References _State, source_silencing, and source_stoped. +

+

01042 {
+01043         return _State == source_silencing || _State == source_stoped;
+01044 //      return (_UserState == NL_DSOUND_STOPPED);
+01045 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLSOUND::CSourceDSound::lock uint32  writePos,
uint32  size,
TLockedBufferInfo lockedInfo
[private]
+
+ + + + + +
+   + + +

+ +

+Definition at line 1811 of file source_dsound.cpp. +

+References _SecondaryBuffer, nlwarning, offset, NLSOUND::CSourceDSound::TLockedBufferInfo::Ptr1, NLSOUND::CSourceDSound::TLockedBufferInfo::Ptr2, size, NLSOUND::CSourceDSound::TLockedBufferInfo::Size1, NLSOUND::CSourceDSound::TLockedBufferInfo::Size2, and uint32. +

+Referenced by play(), stop(), and update(). +

+

01812 {
+01813         HRESULT hr = _SecondaryBuffer->Lock(offset, size, (LPVOID*) &lbi.Ptr1, (DWORD*) &lbi.Size1, (LPVOID*) &lbi.Ptr2, (DWORD*) &lbi.Size2, 0);
+01814 
+01815         if (hr == DSERR_BUFFERLOST)
+01816         {
+01817                 // If the buffer got lost somehow, try to restore it.
+01818                 if (FAILED(_SecondaryBuffer->Restore()))
+01819                 {
+01820                         nlwarning("Lock failed (1)");
+01821                         return false;
+01822                 }
+01823                 if (FAILED(_SecondaryBuffer->Lock(offset, size, (LPVOID*) &lbi.Ptr1, (DWORD*)&lbi.Size1, (LPVOID*) &lbi.Ptr2, (DWORD*)&lbi.Size2, 0)))
+01824                 {
+01825                         nlwarning("Lock failed (2)");
+01826                         return false;
+01827                 }
+01828         } 
+01829         else if (hr != DS_OK)
+01830         {
+01831                 nlwarning("Lock failed (3)");
+01832                 return false;
+01833         }
+01834 
+01835         return true;
+01836 }
+
+

+ + + + +
+ + + + + + + + + +
bool NLSOUND::CSourceDSound::needsUpdate  )  [private]
+
+ + + + + +
+   + + +

+Check whether the play position has advanced enough to require an update. +

+ +

+Definition at line 1050 of file source_dsound.cpp. +

+References _State, source_playing, source_silencing, and source_swap_pending. +

+

01051 {
+01052         return _State == source_silencing || _State == source_playing || _State == source_swap_pending;
+01053 }
+
+

+ + + + +
+ + + + + + + + + +
void NLSOUND::CSourceDSound::pause  )  [virtual]
+
+ + + + + +
+   + + +

+Pause. Call play() to resume. +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 997 of file source_dsound.cpp. +

+References nlassert. +

+

00998 {
+00999         // TODO : recode this !
+01000         nlassert(false);
+01001 /*      EnterCriticalSection(&_CriticalSection); 
+01002 
+01003         TSourceDSoundUserState old = _UserState;
+01004 
+01005         _UserState = NL_DSOUND_PAUSED;
+01006         DBGPOS(("[%p] PAUZ: PAUSED", this));
+01007 
+01008         //nldebug ("NLOUND: pause %p", this);
+01009 
+01010         if (old == NL_DSOUND_PLAYING)
+01011         {
+01012                 fadeOut();
+01013         }
+01014 
+01015         LeaveCriticalSection(&_CriticalSection); 
+01016 */
+01017 }
+
+

+ + + + +
+ + + + + + + + + +
bool NLSOUND::CSourceDSound::play  )  [virtual]
+
+ + + + + +
+   + + +

+Play the static buffer (or stream in and play). +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 688 of file source_dsound.cpp. +

+References _ADPCMState, _CriticalSection, _FillOffset, _LastPlayPos, _Loop, _NextSample, _PlayOffset, _Sample, _SampleFreq, _SampleOffset, _SampleSize, _SilenceWriten, _State, _XFadeSize, advanceFill(), fadeIn(), fillData(), fillSilence(), getCursors(), NLSOUND::IBuffer::getFormat(), NLSOUND::CListenerDSound::getPos(), NLSOUND::IBuffer::getSize(), lock(), min, NLSOUND::Mono16, NLSOUND::Mono16ADPCM, NLSOUND::Mono8, nlassert, nlwarning, NLSOUND::CSourceDSound::TCursors::PlayCursor, NLSOUND::IBuffer::TADPCMState::PreviousSample, sint16, source_playing, source_silencing, source_swap_pending, NLSOUND::IBuffer::TADPCMState::StepIndex, NLSOUND::Stereo16, NLSOUND::Stereo8, uint, unlock(), updateVolume(), NLSOUND::CSourceDSound::TCursors::WriteCursor, NLSOUND::CSourceDSound::TCursors::WriteSize, and xfade(). +

+

00689 {
+00690 //      nldebug("Play");
+00691         EnterCriticalSection(&_CriticalSection); 
+00692 
+00693         _SilenceWriten = 0;
+00694 
+00695 //      uint32 writeSize = checkFillCursor();
+00696         TCursors cursors;
+00697         getCursors(cursors);
+00698 
+00699         // set a new filling point
+00700         _FillOffset = cursors.WriteCursor;
+00701         _FillOffset = (_FillOffset+3) & 0xfffffffC;
+00702         cursors.WriteCursor = _FillOffset;
+00703 
+00704         TLockedBufferInfo lbi;
+00705         if (lock(_FillOffset, cursors.WriteSize, lbi))
+00706         {
+00707                 TLockedBufferInfo unlockInfo(lbi);
+00708                 // ok, the buffer is locked, write data
+00709                 if (_State == source_swap_pending)
+00710                 {
+00711                         // we swap the buffer.
+00712                         _Sample = _NextSample;
+00713                         _NextSample = 0;
+00714                         if (_Sample != 0)
+00715                         {
+00716                                 _Sample->getFormat(_Format, _SampleFreq);
+00717                                 switch(_Format)
+00718                                 {
+00719                                 case Mono8:
+00720                                         _SampleSize = _Sample->getSize();
+00721                                         break;
+00722                                 case Mono16:
+00723                                         _SampleSize = _Sample->getSize() / 2;
+00724                                         break;
+00725                                 case Mono16ADPCM:
+00726                                         _SampleSize = _Sample->getSize() * 2;
+00727                                         break;
+00728                                 case Stereo8:
+00729                                         _SampleSize = _Sample->getSize() / 2;
+00730                                         break;
+00731                                 case Stereo16:
+00732                                         _SampleSize = _Sample->getSize() / 4; 
+00733                                         break;
+00734                                 }
+00735                                 _State = source_playing;
+00736                         }
+00737                         else
+00738                         {
+00739                                 _SampleSize = 0;
+00740                                 _State = source_silencing;
+00741                         }
+00742                 }
+00743                 _LastPlayPos = cursors.PlayCursor;
+00744                 _SampleOffset = 0;
+00745                 _PlayOffset = 0;
+00746                 _ADPCMState.PreviousSample = 0;
+00747                 _ADPCMState.StepIndex = 0;
+00748                 // Compute the size of data to write.
+00749                 uint dataToFill = std::min(uint(cursors.WriteSize / 2), _SampleSize - _SampleOffset);
+00750                 dataToFill &= 0xfffffffe;
+00751                 // ok, the buffer is locked, write data
+00752                 if (_State == source_playing || _State == source_silencing)
+00753                 {
+00754                         // we need a little XFade
+00755                         sint16  fadeBuffer[_XFadeSize];
+00756                         fillData(fadeBuffer, _XFadeSize);
+00757                         xfade(lbi, fadeBuffer);
+00758                         advanceFill(lbi, _XFadeSize);
+00759                         cursors.WriteSize -= _XFadeSize*2;
+00760                         dataToFill -= _XFadeSize;
+00761                 }
+00762                 else
+00763                 {
+00764                         // we need a little FadeIn
+00765                         fillData(lbi, _XFadeSize);
+00766                         fadeIn(lbi);
+00767                         advanceFill(lbi, _XFadeSize);
+00768                         cursors.WriteSize -= _XFadeSize*2;
+00769                         dataToFill -= _XFadeSize;
+00770                 }
+00771                 fillData(lbi, dataToFill);
+00772                 cursors.WriteSize -= dataToFill * 2;
+00773                 advanceFill(lbi, dataToFill);
+00774                 _State = source_playing;
+00775                 if (_Loop)
+00776                 {
+00777                         while (cursors.WriteSize >= 4)
+00778                         {
+00779                                 if (_SampleOffset == _SampleSize)
+00780                                 {
+00781                                         // rewind the sample
+00782                                         _SampleOffset = 0;
+00783                                         _ADPCMState.PreviousSample = 0;
+00784                                         _ADPCMState.StepIndex = 0;
+00785                                 }
+00786                 nlassert(_SampleOffset < _SampleSize);
+00787                                 dataToFill = std::min(uint(cursors.WriteSize / 2), _SampleSize - _SampleOffset);
+00788                                 dataToFill &= 0xfffffffe;
+00789                                 fillData(lbi, dataToFill);
+00790                                 advanceFill(lbi, dataToFill);
+00791                                 cursors.WriteSize -= dataToFill*2;
+00792                         }
+00793                 }
+00794                 else
+00795                 {
+00796                         if (_SampleOffset == _SampleSize)
+00797                         {
+00798                                 // begin to write silence, but stil in play state until all sample are played
+00799 //                              _State = source_silencing;
+00800                                 fillSilence(lbi, cursors.WriteSize/2);
+00801                                 advanceFill(lbi, cursors.WriteSize/2);
+00802                                 _SilenceWriten = cursors.WriteSize;
+00803                                 cursors.WriteSize = 0;
+00804                         }
+00805 //                      else
+00806 //                              _State = source_playing;
+00807                 }
+00808 
+00809 
+00810                 unlock(unlockInfo);
+00811         }
+00812         else
+00813         {
+00814                 nlwarning("Couldn't lock the sound buffer for %u bytes", cursors.WriteSize);
+00815         }
+00816 
+00817         // set the volume NOW
+00818         CListenerDSound* listener = CListenerDSound::instance();
+00819 
+00820         updateVolume(listener->getPos());
+00821 
+00822         LeaveCriticalSection(&_CriticalSection); 
+00823 
+00824         return true;
+00825 }
+
+

+ + + + +
+ + + + + + + + + +
void NLSOUND::CSourceDSound::release  )  [private]
+
+ + + + + +
+   + + +

+Release all DirectSound resources. +

+ +

+Definition at line 171 of file source_dsound.cpp. +

+References _3DBuffer, and _SecondaryBuffer. +

+Referenced by ~CSourceDSound(). +

+

00172 {
+00173 //      _Buffer = 0;
+00174 
+00175 #if EAX_AVAILABLE == 1
+00176         if (_EAXSource != 0)
+00177         {
+00178                 _EAXSource->Release();
+00179                 _EAXSource = 0;
+00180         }
+00181 #endif
+00182 
+00183         if (_SecondaryBuffer != 0)
+00184         {
+00185                 _SecondaryBuffer->Stop();
+00186         }
+00187 
+00188         if (_3DBuffer != 0)
+00189         {
+00190                 _3DBuffer->Release();
+00191                 _3DBuffer = 0;
+00192         }
+00193 
+00194         if (_SecondaryBuffer != 0)
+00195         {
+00196                 _SecondaryBuffer->Release();
+00197                 _SecondaryBuffer = 0;
+00198         }
+00199 
+00200 }
+
+

+ + + + +
+ + + + + + + + + +
void NLSOUND::CSourceDSound::reset  ) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 332 of file source_dsound.cpp. +

+References setGain(), setLooping(), and setPitch(). +

+

00333 {
+00334         setPitch(1.0f);
+00335         setLooping(false);
+00336         setGain(1.0f);
+00337 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NLSOUND::CSourceDSound::setAlpha double  a  )  [inline, virtual]
+
+ + + + + +
+   + + +

+Set the alpha value for the volume-distance curve

+alpha = 0.0: the volume will decrease linearly between 0dB and -100 dB alpha = 1.0: the volume will decrease linearly between 1.0 and 0.0 (linear scale) alpha = -1.0: the volume will decrease inversely with the distance (1/dist). This is the default used by DirectSound/OpenAL

+For any other value of alpha, an interpolation is be done between the two adjacent curves. For example, if alpha equals 0.5, the volume will be halfway between the linear dB curve and the linear amplitude curve. +

+Reimplemented from NLSOUND::ISource. +

+Definition at line 265 of file source_dsound.h. +

+References _Alpha. +

+

00265 { _Alpha = a; }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NLSOUND::CSourceDSound::setCone float  innerAngle,
float  outerAngle,
float  outerGain
[virtual]
+
+ + + + + +
+   + + +

+Set the cone angles (in radian) and gain (in [0 , 1]) (default: 2PI, 2PI, 0) (3D mode only). +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 1671 of file source_dsound.cpp. +

+References _3DBuffer, nlwarning, and NLMISC::Pi. +

+

01672 {
+01673         if (_3DBuffer != 0)
+01674         {
+01675                 // Set the cone angles
+01676 
+01677                 // Convert from radians to degrees
+01678                 DWORD inner = (DWORD)(180.0 * innerAngle / Pi);
+01679                 DWORD outer = (DWORD)(180.0 * outerAngle / Pi);
+01680 
+01681 
+01682                 // Sanity check: wrap the angles in the [0,360] interval
+01683                 if (outer < inner)
+01684                 {
+01685                         outer = inner;
+01686                 }
+01687 
+01688                 while (inner < DS3D_MINCONEANGLE) 
+01689                 {
+01690                         inner += 360;
+01691                 }
+01692 
+01693                 while (inner > DS3D_MAXCONEANGLE)
+01694                 {
+01695                         inner -= 360;
+01696                 }
+01697 
+01698                 while (outer < DS3D_MINCONEANGLE) 
+01699                 {
+01700                         outer += 360;
+01701                 }
+01702 
+01703                 while (outer > DS3D_MAXCONEANGLE)
+01704                 {
+01705                         outer -= 360;
+01706                 }
+01707 
+01708                 if (_3DBuffer->SetConeAngles(inner, outer, DS3D_DEFERRED) != DS_OK)
+01709                 {
+01710                         nlwarning("SetConeAngles failed");                      
+01711                 }
+01712 
+01713                 // Set the outside volume
+01714                 if (outerGain < 0.00001f)
+01715                 {
+01716                         outerGain = 0.00001f;
+01717                 }
+01718 
+01719                 // convert from linear amplitude to hundredths of decibels 
+01720                 LONG volume = (LONG)(100.0 * 20.0 * log10(outerGain));
+01721 
+01722                 if (volume < DSBVOLUME_MIN) 
+01723                 {
+01724                         volume = DSBVOLUME_MIN;
+01725                 }
+01726                 else if (volume > DSBVOLUME_MAX) 
+01727                 {
+01728                         volume = DSBVOLUME_MAX;
+01729                 }
+01730 
+01731                 if (_3DBuffer->SetConeOutsideVolume(volume, DS3D_DEFERRED) != DS_OK)
+01732                 {
+01733                         nlwarning("SetConeOutsideVolume failed");               
+01734                 }
+01735 
+01736         }
+01737         else
+01738         {
+01739                 nlwarning("Requested setCone on a non-3D source");
+01740         }
+01741 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLSOUND::CSourceDSound::setDirection const NLMISC::CVector dir  )  [virtual]
+
+ + + + + +
+   + + +

+Set the direction vector (3D mode only) (default: (0,0,0) as non-directional). +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 1380 of file source_dsound.cpp. +

+References _3DBuffer, nlwarning, NLMISC::CVector::x, NLMISC::CVector::y, and NLMISC::CVector::z. +

+

01381 {
+01382         if (_3DBuffer != 0)
+01383         {
+01384                 if (_3DBuffer->SetConeOrientation(dir.x, dir.z, dir.y, DS3D_DEFERRED) != DS_OK)
+01385                 {
+01386                         nlwarning ("SetConeOrientation failed (x=%.2f, y=%.2f, z=%.2f)", dir.x, dir.y, dir.z);
+01387                 }
+01388                 else
+01389                 {
+01390                         //nlwarning ("NLSOUND: %p set source direction NEL(p:%.2f/%.2f/%.2f) DS(p:%.2f/%.2f/%.2f)", this, dir.x, dir.y, dir.z, dir.x, dir.z, dir.y);
+01391                 }
+01392         }
+01393 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NLSOUND::CSourceDSound::setEAXProperty uint  prop,
void *  value,
uint  valuesize
[virtual]
+
+ + + + + +
+   + + +

+Set any EAX source property if EAX available. +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 1781 of file source_dsound.cpp. +

+References H_AUTO, res, uint, and value. +

+

01782 {
+01783 #if EAX_AVAILABLE == 1
+01784         if (_EAXSource == 0)
+01785         {
+01786                 _EAXSource = CSoundDriverDSound::instance()->createPropertySet(this);
+01787         }
+01788         if ( _EAXSource != NULL )
+01789         {
+01790                 H_AUTO(NLSOUND_EAXPropertySet_Set)
+01791                 HRESULT res = _EAXSource->Set( DSPROPSETID_EAX_BufferProperties, prop, NULL, 0, value, valuesize );
+01792                 if (res != S_OK)
+01793                 {
+01794 //                      nlwarning("Setting EAX Param #%u fail : %x", prop, res);
+01795                 }
+01796         }
+01797 #endif
+01798 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLSOUND::CSourceDSound::setGain float  gain  )  [virtual]
+
+ + + + + +
+   + + +

+Set the gain (volume value inside [0 , 1]) (default: 1) 0.0 -> silence 0.5 -> -6dB 1.0 -> no attenuation values > 1 (amplification) not supported by most drivers +

+Implements NLSOUND::ISource. +

+Definition at line 1423 of file source_dsound.cpp. +

+References NLMISC::clamp(), and uint32. +

+Referenced by reset(). +

+

01424 {
+01425         clamp(gain, 0.00001f, 1.0f);
+01426         _Gain = gain;
+01427 
+01428         /* convert from linear amplitude to hundredths of decibels */
+01429         _Volume = (uint32)(100.0 * 20.0 * log10(gain));
+01430         clamp(_Volume, DSBVOLUME_MIN, DSBVOLUME_MAX);
+01431 
+01432         //nlwarning ("set gain %f vol %d", gain, _Volume);
+01433 
+01434         /*
+01435         if ((_SecondaryBuffer != 0) && (_SecondaryBuffer->SetVolume(_Volume) != DS_OK))
+01436         {
+01437                 nlwarning("SetVolume failed");
+01438         }
+01439         */
+01440 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLSOUND::CSourceDSound::setLooping bool  l  )  [virtual]
+
+ + + + + +
+   + + +

+Set looping on/off for future playbacks (default: off). +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 866 of file source_dsound.cpp. +

+References _Loop. +

+Referenced by reset(). +

+

00867 {
+00868         _Loop = l;
+00869 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NLSOUND::CSourceDSound::setMinMaxDistances float  mindist,
float  maxdist,
bool  deferred
[virtual]
+
+ + + + + +
+   + + +

+Set the min and max distances (default: 1, MAX_FLOAT) (3D mode only). +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 1558 of file source_dsound.cpp. +

+References _3DBuffer, and nlwarning. +

+

01559 {
+01560         if (_3DBuffer != 0)
+01561         {
+01562                 if (_3DBuffer->SetMinDistance(std::max(DS3D_DEFAULTMINDISTANCE, mindist), deferred ? DS3D_DEFERRED : DS3D_IMMEDIATE) != DS_OK)
+01563                 {
+01564                         nlwarning("SetMinDistance (%f) failed", mindist);
+01565                 }
+01566                 if (_3DBuffer->SetMaxDistance(std::min(DS3D_DEFAULTMAXDISTANCE, maxdist), deferred ? DS3D_DEFERRED : DS3D_IMMEDIATE) != DS_OK)
+01567                 {
+01568                         nlwarning("SetMaxDistance (%f) failed", maxdist);
+01569                 }
+01570         }
+01571         else
+01572         {
+01573                 nlwarning("Requested setMinMaxDistances on a non-3D source");
+01574         }
+01575 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLSOUND::CSourceDSound::setPitch float  pitch  )  [virtual]
+
+ + + + + +
+   + + +

+Shift the frequency. 1.0f equals identity, each reduction of 50% equals a pitch shift of one octave. 0 is not a legal value. +

+Implements NLSOUND::ISource. +

+Definition at line 1454 of file source_dsound.cpp. +

+References _Sample, _SampleRate, _SecondaryBuffer, format, NLSOUND::IBuffer::getFormat(), nlwarning, NLSOUND::TSampleFormat, uint, and uint32. +

+Referenced by reset(). +

+

01455 {
+01456 //      _Freq = coeff;
+01457 
+01458         if ((_Sample != 0) && (_SecondaryBuffer != 0))
+01459         {
+01460                 TSampleFormat format;
+01461                 uint freq;
+01462 
+01463                 _Sample->getFormat(format, freq);
+01464 
+01465                 _SampleRate = (uint32) (coeff * (float) freq);
+01466 
+01467                 //nlwarning("Freq=%d", newfreq);
+01468 
+01469                 if (_SecondaryBuffer->SetFrequency(_SampleRate) != DS_OK)
+01470                 {
+01471 //                      nlwarning("SetFrequency failed (buffer freq=%d, NeL freq=%.5f, DSound freq=%d)", freq, coeff, newfreq);
+01472                         nlwarning("SetFrequency");
+01473                 }
+01474         }
+01475 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLSOUND::CSourceDSound::setPos const NLMISC::CVector pos,
bool  deferred
[virtual]
+
+ + + + + +
+   + + +

+Set the position vector (default: (0,0,0)). 3D mode -> 3D position st mode -> x is the pan value (from left (-1) to right (1)), set y and z to 0

Parameters:
+ + +
deferred false to apply position immediatly
+
+ +

+Implements NLSOUND::ISource. +

+Definition at line 1313 of file source_dsound.cpp. +

+References _3DBuffer, and nlwarning. +

+

01314 {
+01315         _Pos = pos;
+01316         // Coordinate system: conversion from NeL to OpenAL/GL:
+01317         if (_3DBuffer != NULL)
+01318         {
+01319                 if (_3DBuffer->SetPosition(pos.x, pos.z, pos.y, deferred ? DS3D_DEFERRED : DS3D_IMMEDIATE) != DS_OK)
+01320                 {
+01321                         nlwarning ("SetPosition failed");
+01322                 }
+01323                 else
+01324                 {
+01325                         //nlwarning ("%p set source NEL(p:%.2f/%.2f/%.2f) DS(p:%.2f/%.2f/%.2f)", this, pos.x, pos.y, pos.z, pos.x, pos.z, pos.y);
+01326                 }
+01327         }
+01328 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLSOUND::CSourceDSound::setSourceRelativeMode bool  mode  )  [virtual]
+
+ + + + + +
+   + + +

+Set the source relative mode. If true, positions are interpreted relative to the listener position (default: false). +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 1505 of file source_dsound.cpp. +

+References _3DBuffer, and nlwarning. +

+

01506 {
+01507         if (_3DBuffer != 0)
+01508         {
+01509                 HRESULT hr;
+01510 
+01511                 if (mode)
+01512                 {
+01513                         hr = _3DBuffer->SetMode(DS3DMODE_HEADRELATIVE, DS3D_IMMEDIATE);
+01514                 }
+01515                 else
+01516                 {
+01517                         hr = _3DBuffer->SetMode(DS3DMODE_NORMAL, DS3D_IMMEDIATE);
+01518                 }
+01519 
+01520                 if (hr != DS_OK)
+01521                 {
+01522                         nlwarning("SetMode failed");
+01523                 }
+01524         }
+01525         else
+01526         {
+01527                 nlwarning("Requested setSourceRelativeMode on a non-3D source");
+01528         }
+01529 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLSOUND::CSourceDSound::setStaticBuffer IBuffer buffer  )  [virtual]
+
+ + + + + +
+   + + +

+Set the buffer that will be played (no streaming) If the buffer is stereo, the source mode becomes stereo and the source relative mode is on, otherwise the source is considered as a 3D source. Set NULL to set "no buffer" +

+Implements NLSOUND::ISource. +

+Definition at line 342 of file source_dsound.cpp. +

+References _ADPCMState, _CriticalSection, _NextSample, _PlayOffset, _Sample, _SampleFreq, _SampleOffset, _SampleSize, _State, buffer, NLSOUND::Mono16, NLSOUND::Mono16ADPCM, NLSOUND::Mono8, NLSOUND::IBuffer::TADPCMState::PreviousSample, source_playing, source_swap_pending, NLSOUND::IBuffer::TADPCMState::StepIndex, NLSOUND::Stereo16, and NLSOUND::Stereo8. +

+

00343 {
+00344         EnterCriticalSection(&_CriticalSection); 
+00345 
+00346         if (_State == source_playing)
+00347         {
+00348                 _State = source_swap_pending;
+00349                 _Sample = 0;
+00350                 _NextSample = buffer;
+00351                 _SampleOffset = 0;
+00352                 _PlayOffset = 0;
+00353         }
+00354         else
+00355         {
+00356                 _Sample = buffer;
+00357                 _NextSample = 0;
+00358                 _SampleOffset = 0;
+00359                 _PlayOffset = 0;
+00360                 _ADPCMState.PreviousSample = 0;
+00361                 _ADPCMState.StepIndex = 0;
+00362                 if (buffer)
+00363                 {
+00364 //                      _SampleSize = buffer->getSize();
+00365                         buffer->getFormat(_Format, _SampleFreq);
+00366                         switch(_Format)
+00367                         {
+00368                         case Mono8:
+00369                                 _SampleSize = buffer->getSize();
+00370                                 break;
+00371                         case Mono16:
+00372                                 _SampleSize = buffer->getSize() / 2;
+00373                                 break;
+00374                         case Mono16ADPCM:
+00375                                 _SampleSize = buffer->getSize() * 2;
+00376                                 break;
+00377                         case Stereo8:
+00378                                 _SampleSize = buffer->getSize() / 2;
+00379                                 break;
+00380                         case Stereo16:
+00381                                 _SampleSize = buffer->getSize() / 4; 
+00382                                 break;
+00383                         }
+00384                 }
+00385         }
+00386         
+00387 /*
+00388         // If the user calls setStaticBuffer with a null buffer,
+00389         // stop the currently playing buffer and set it to null.
+00390         // Otherwise, store the buffer in the swap buffer variable.
+00391         // A crossfade between the current buffer and the swap buffer
+00392         // will be done when the user calls play.
+00393         if (buffer == 0)
+00394         {
+00395                 stop();
+00396                 _Buffer = 0;
+00397                 _BufferSize = 0;
+00398                 _BytesWritten = 0;
+00399         }
+00400 
+00401         _SwapBuffer = _Buffer = buffer;
+00402 
+00403         _ADPCMState.PreviousSample = 0;
+00404         _ADPCMState.StepIndex = 0;
+00405 */      
+00406         LeaveCriticalSection(&_CriticalSection); 
+00407 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NLSOUND::ISource::setStreamLoader ILoader loader  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Set the sound loader that will be used to stream in the data to play If the buffer is stereo, the source mode becomes stereo and the source relative mode is on, otherwise the source is considered as a 3D source. +

+Definition at line 76 of file source.h. +

+References NLSOUND::ISource::_Loader. +

+

00076 { _Loader = loader; }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLSOUND::CSourceDSound::setVelocity const NLMISC::CVector vel,
bool  deferred
[virtual]
+
+ + + + + +
+   + + +

+Set the velocity vector (3D mode only) (default: (0,0,0)). +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 1341 of file source_dsound.cpp. +

+References _3DBuffer, nlwarning, NLMISC::CVector::x, NLMISC::CVector::y, and NLMISC::CVector::z. +

+

01342 {
+01343         if (_3DBuffer != NULL)
+01344         {
+01345                 if (_3DBuffer->SetVelocity(vel.x, vel.z, vel.y, deferred ? DS3D_DEFERRED : DS3D_IMMEDIATE) != DS_OK)
+01346                 {
+01347                         nlwarning ("SetVelocity failed");
+01348                 }
+01349         }
+01350 }
+
+

+ + + + +
+ + + + + + + + + +
bool NLSOUND::CSourceDSound::silence  )  [private]
+
+ + + + + +
+   + + +

+

+

+ + + + +
+ + + + + + + + + +
uint NLSOUND::CSourceDSound::sourceName  )  [inline]
+
+ + + + + +
+   + + +

+Return the OpenAL source name. +

+ +

+Definition at line 242 of file source_dsound.h. +

+References _SourceName, and uint. +

+

00242 { return _SourceName; }
+
+

+ + + + +
+ + + + + + + + + +
void NLSOUND::CSourceDSound::stop  )  [virtual]
+
+ + + + + +
+   + + +

+Stop playing. +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 827 of file source_dsound.cpp. +

+References _CriticalSection, _FillOffset, _SilenceWriten, _State, _XFadeSize, advanceFill(), fadeOut(), fillSilence(), getCursors(), lock(), source_silencing, source_stoped, unlock(), NLSOUND::CSourceDSound::TCursors::WriteCursor, and NLSOUND::CSourceDSound::TCursors::WriteSize. +

+

00828 {
+00829 //      nldebug("Stop");
+00830         EnterCriticalSection(&_CriticalSection); 
+00831         
+00832         if (_State != source_stoped && _State != source_silencing)
+00833         {
+00834                 // retreive the cursors;
+00835                 TCursors        cursors;
+00836                 getCursors(cursors);
+00837 
+00838                 _FillOffset = cursors.WriteCursor;
+00839                 _FillOffset = (_FillOffset+3) & 0xfffffffC;
+00840 
+00841                 TLockedBufferInfo lbi;
+00842                 if (lock(_FillOffset, cursors.WriteSize, lbi))
+00843                 {
+00844                         TLockedBufferInfo unlockInfo(lbi);
+00845 
+00846                         fadeOut(lbi);
+00847                         advanceFill(lbi, _XFadeSize);
+00848                         cursors.WriteSize -= _XFadeSize*2;
+00849                         fillSilence(lbi, cursors.WriteSize/2);
+00850                         advanceFill(lbi, cursors.WriteSize/2);
+00851                         _SilenceWriten = cursors.WriteSize;
+00852 
+00853                         _State = source_silencing;
+00854 
+00855                         unlock(unlockInfo);
+00856                 }
+00857         }
+00858 
+00859         LeaveCriticalSection(&_CriticalSection); 
+00860 }
+
+

+ + + + +
+ + + + + + + + + +
void NLSOUND::CSourceDSound::swap  )  [private]
+
+ + + + + +
+   + + +

+

+

+ + + + +
+ + + + + + + + + + +
bool NLSOUND::CSourceDSound::unlock const TLockedBufferInfo lockedInfo  )  [private]
+
+ + + + + +
+   + + +

+ +

+Definition at line 1868 of file source_dsound.cpp. +

+References _SecondaryBuffer, NLSOUND::CSourceDSound::TLockedBufferInfo::Ptr1, NLSOUND::CSourceDSound::TLockedBufferInfo::Ptr2, NLSOUND::CSourceDSound::TLockedBufferInfo::Size1, and NLSOUND::CSourceDSound::TLockedBufferInfo::Size2. +

+Referenced by play(), stop(), and update(). +

+

01869 {
+01870         _SecondaryBuffer->Unlock(lbi.Ptr1, lbi.Size1, lbi.Ptr2, lbi.Size2);
+01871         return true;
+01872 }
+
+

+ + + + +
+ + + + + + + + + +
bool NLSOUND::CSourceDSound::update  )  [virtual]
+
+ + + + + +
+   + + +

+Update the source (e.g. continue to stream the data in). +

+ +

+Implements NLSOUND::ISource. +

+Definition at line 1059 of file source_dsound.cpp. +

+References _ADPCMState, _CriticalSection, _FillOffset, _LastPlayPos, _Loop, _PlayOffset, _SampleOffset, _SampleSize, _SecondaryBufferSize, _SilenceWriten, _SizeMask, _State, _UpdateCopySize, _XFadeSize, advanceFill(), fadeOut(), fillData(), fillSilence(), getCursors(), H_AUTO, lock(), min, nlassert, nlwarning, NLSOUND::CSourceDSound::TCursors::PlayCursor, NLSOUND::IBuffer::TADPCMState::PreviousSample, source_playing, source_silencing, source_stoped, source_swap_pending, NLSOUND::IBuffer::TADPCMState::StepIndex, uint, uint32, unlock(), NLSOUND::CSourceDSound::TCursors::WriteCursor, and NLSOUND::CSourceDSound::TCursors::WriteSize. +

+

01060 {
+01061         H_AUTO(NLSOUND_SourceDSoundUpdate)
+01062         bool updateDone = false;
+01063 
+01064         EnterCriticalSection(&_CriticalSection);
+01065 
+01066         // fill some data into the buffer
+01067         TCursors cursors;
+01068         getCursors(cursors);
+01069         uint32  writeSize;
+01070 
+01071         // The total size available for fill (between fillOffset and play cusors)
+01072         uint32 fillSize = (cursors.PlayCursor - _FillOffset) & _SizeMask;
+01073         // The play margin (between play and write cursor)
+01074         uint32 margin = (cursors.WriteCursor - cursors.PlayCursor) & _SizeMask;
+01075         // The number of sample played since previous update
+01076         uint32 samplePlayed = ((cursors.PlayCursor - _LastPlayPos) & _SizeMask) / 2;
+01077         _LastPlayPos = cursors.PlayCursor;
+01078 
+01079 
+01080 //      if (_FillOffset < cursors.WriteCursor && _FillOffset >cursors.PlayCursor)
+01081         if (fillSize + margin > _SecondaryBufferSize)
+01082         {
+01083                 // arg ! 
+01084                 nlwarning("FillOffset is between play and write cursor (P = %p F = %p W = %p!", cursors.PlayCursor, _FillOffset, cursors.WriteCursor);
+01085                 _FillOffset = cursors.WriteCursor;
+01086                 _FillOffset = (_FillOffset+3) & 0xfffffffC;
+01087                 _SilenceWriten = 0;
+01088         nlassert(_FillOffset < _SecondaryBufferSize);
+01089         }
+01090 
+01091         // advance of the fill offset over the write cursor
+01092         uint32 advance = (_FillOffset - cursors.WriteCursor) & _SizeMask;
+01093 
+01094 /*      nldebug("Play = %p, Write = %p, Fill = %p, FillSize = %p, Margin = %p, Advance = %p",
+01095                 cursors.PlayCursor, cursors.WriteCursor, _FillOffset, fillSize, margin, advance);
+01096 */
+01097         if (advance > _UpdateCopySize)
+01098         {
+01099                 // enougth data wrote, wait until next update
+01100                 cursors.WriteSize = 0;
+01101         }
+01102 /*      if (cursors.WriteSize)
+01103         {
+01104                 if (_FillOffset < cursors.WriteCursor)
+01105                 {
+01106                         if (_FillOffset > cursors.WriteCursor + _UpdateCopySize - _SecondaryBufferSize )
+01107                         {
+01108 //                              nlwarning("Enougth data wrote");
+01109                                 // already fill enough data
+01110                                 cursors.WriteSize = 0;
+01111                         }
+01112                 }
+01113                 else
+01114                 {
+01115                         if (_FillOffset > cursors.WriteCursor + _UpdateCopySize)
+01116                         {
+01117 //                              nlwarning("Enougth data wrote");
+01118                                 // already fill enough data
+01119                                 cursors.WriteSize = 0;
+01120                         }
+01121                 }
+01122         }
+01123 */
+01124 //      nldebug("Cursors : Play = %p, Write = %p, Fill = %p", cursors.PlayCursor, cursors.WriteCursor, _FillOffset);
+01125 
+01126         cursors.WriteCursor = _FillOffset;
+01127         writeSize = cursors.WriteSize;  // compute the real played sample offset
+01128 
+01129         // update the real number of played sample
+01130         if (_State == source_playing)
+01131                 _PlayOffset += samplePlayed;
+01132 
+01133         if (writeSize >= _UpdateCopySize)
+01134         {
+01135 //              nldebug("Update %p bytes", _UpdateCopySize);
+01136                 writeSize = _UpdateCopySize;
+01137                 updateDone = true;
+01138                 TLockedBufferInfo lbi;
+01139                 if (lock(_FillOffset, writeSize, lbi))
+01140                 {
+01141                         TLockedBufferInfo unlockInfo(lbi);
+01142                         if (_State == source_playing)
+01143                         {
+01144                 nlassert(_SampleOffset <= _SampleSize);
+01145                                 uint32  updateSize = min(_SampleSize - _SampleOffset, uint(writeSize/2));
+01146                                 updateSize &= 0xfffffffe;
+01147                                 fillData(lbi, updateSize);
+01148                                 advanceFill(lbi, updateSize);
+01149                                 writeSize -= updateSize*2;
+01150 
+01151                                 if (_Loop)
+01152                                 {
+01153                                         while (_PlayOffset >= _SampleSize)
+01154                                                 _PlayOffset -= _SampleSize;
+01155 
+01156                                         // repeat until we have at least 2 sample to write
+01157                                         while (writeSize >= 4)
+01158                                         {
+01159                                                 if (_SampleOffset == _SampleSize)
+01160                                                 {
+01161                                                         // rewind the sample
+01162                                                         _SampleOffset = 0;
+01163                                                         _ADPCMState.PreviousSample = 0;
+01164                                                         _ADPCMState.StepIndex = 0;
+01165                                                 }
+01166 
+01167                                                 updateSize = min(_SampleSize - _SampleOffset, uint(writeSize/2));
+01168                                                 updateSize &= 0xfffffffe;
+01169                                                 fillData(lbi, updateSize);
+01170                                                 advanceFill(lbi, updateSize);
+01171                                                 writeSize -= updateSize*2;
+01172                                         }
+01173                                 }
+01174                                 else
+01175                                 {
+01176                                         if (_SampleOffset == _SampleSize)
+01177                                         {
+01178                                                 fillSilence(lbi, writeSize/2);
+01179                                                 advanceFill(lbi, writeSize/2);
+01180                                                 _SilenceWriten += writeSize;
+01181                                         }
+01182                                         if (_PlayOffset >= _SampleSize)
+01183                                         {
+01184                                                 // all the sample is played, no we are in silencing state !
+01185                                                 _PlayOffset = _SampleSize;
+01186                                                 _State = source_silencing;
+01187                                         }
+01188                                 }
+01189 
+01190                         }
+01191                         else if (_State == source_swap_pending)
+01192                         {
+01193                                 // the sample has been changed but not replayed yet ? so we 'stop' the old buffer
+01194 
+01195                                 fadeOut(lbi);
+01196                                 advanceFill(lbi, _XFadeSize);
+01197                                 writeSize -= _XFadeSize*2;
+01198                                 fillSilence(lbi, writeSize/2);
+01199                                 advanceFill(lbi, writeSize/2);
+01200                                 _SilenceWriten = writeSize;
+01201                                 _State = source_silencing;
+01202                         }
+01203                         else if (_State == source_silencing)
+01204                         {
+01205                                 // write silence into the buffer.
+01206                                 uint32 updateSize = min(writeSize, _SecondaryBufferSize - _SilenceWriten);
+01207                                 updateSize &= 0xfffffffC;
+01208                                 fillSilence(lbi, updateSize/2);
+01209                                 advanceFill(lbi, updateSize/2);
+01210                                 _SilenceWriten += updateSize;
+01211 
+01212                                 if (_SilenceWriten == _SecondaryBufferSize)
+01213                                         _State = source_stoped;
+01214                         }
+01215                         else
+01216                         {
+01217                                 nlwarning("Update not needed !");
+01218                         }
+01219 
+01220                         unlock(unlockInfo);
+01221                 }
+01222         }
+01223 
+01224         LeaveCriticalSection(&_CriticalSection);
+01225 
+01226         return updateDone;
+01227 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLSOUND::CSourceDSound::updateVolume const NLMISC::CVector listener  ) 
+
+ + + + + +
+   + + +

+Update the source's volume according to its distance and fade out curve. It takes the current position of the listener as argument. +

+Definition at line 1608 of file source_dsound.cpp. +

+References _Alpha, _SecondaryBuffer, NLMISC::clamp(), getMinMaxDistances(), getPos(), min, sint32, and NLMISC::CVector::sqrnorm(). +

+Referenced by play(). +

+

01609 {
+01610 #if MANUAL_ROLLOFF == 1
+01611         _SecondaryBuffer->SetVolume(_Volume);
+01612         return;
+01613 #endif
+01614 
+01615         CVector pos = getPos();
+01616         pos -= listener;
+01617 
+01618         float sqrdist = pos.sqrnorm();
+01619         float min, max;
+01620 
+01621         getMinMaxDistances(min, max);
+01622 
+01623         if (sqrdist < min * min) 
+01624         {
+01625                 _SecondaryBuffer->SetVolume(_Volume);
+01626                 //nlwarning("VOLUME = %ddB, rolloff = %0.2f", _Volume/100, CListenerDSound::instance()->getRolloffFactor());
+01627         }
+01628         else if (sqrdist > max * max)
+01629         {
+01630                 _SecondaryBuffer->SetVolume(DSBVOLUME_MIN);
+01631                 //nlwarning("VOLUME = %ddB, rolloff = %0.2f", DSBVOLUME_MIN/100, CListenerDSound::instance()->getRolloffFactor());
+01632         }
+01633         else
+01634         {
+01635                 sint32 db = _Volume;
+01636 
+01637                 double dist = (double) sqrt(sqrdist);
+01638 
+01639                 // linearly descending volume on a dB scale
+01640                 double db1 = DSBVOLUME_MIN * (dist - min) / (max - min);
+01641 
+01642                 if (_Alpha == 0.0) {
+01643                         db += (sint32) db1;
+01644 
+01645                 } else if (_Alpha > 0.0) {
+01646                         double amp2 = 0.0001 + 0.9999 * (max - dist) / (max - min); // linear amp between 0.00001 and 1.0
+01647                         double db2 = 2000.0 * log10(amp2); // covert to 1/100th decibels
+01648                         db += (sint32) ((1.0 - _Alpha) * db1 + _Alpha * db2);
+01649 
+01650                 } else if (_Alpha < 0.0) {
+01651                         double amp3 = min / dist; // linear amplitude is 1/distance
+01652                         double db3 = 2000.0 * log10(amp3); // covert to 1/100th decibels
+01653                         db += (sint32) ((1.0 + _Alpha) * db1 - _Alpha * db3);
+01654                 }
+01655 
+01656                 clamp(db, DSBVOLUME_MIN, DSBVOLUME_MAX);
+01657 
+01658                 _SecondaryBuffer->SetVolume(db);
+01659 
+01660 /*              LONG tmp;
+01661                 _SecondaryBuffer->GetVolume(&tmp);
+01662 */
+01663                 
+01664                 //nlwarning("VOLUME = %d dB, rolloff = %0.2f", db/100, CListenerDSound::instance()->getRolloffFactor());
+01665         }
+01666 
+01667 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLSOUND::CSourceDSound::xfade const TLockedBufferInfo lbi,
sint16 src
[private]
+
+ + + + + +
+   + + +

+ +

+Definition at line 562 of file source_dsound.cpp. +

+References _XFadeSize, alpha, count, nlassert, NLSOUND::CSourceDSound::TLockedBufferInfo::Ptr1, NLSOUND::CSourceDSound::TLockedBufferInfo::Ptr2, sint, sint16, NLSOUND::CSourceDSound::TLockedBufferInfo::Size1, NLSOUND::CSourceDSound::TLockedBufferInfo::Size2, src, and uint. +

+Referenced by play(). +

+

00563 {
+00564         // do the XFade in integer fixed point arithmetic
+00565 
+00566         nlassert((_XFadeSize & 0x1) == 0);
+00567         uint    fade = _XFadeSize;
+00568         sint16  *ptr = lbi.Ptr1;
+00569         uint    count = lbi.Size1 /2;
+00570         sint    alpha, invAlpha;
+00571 
+00572         while (fade && count)
+00573         {
+00574                 alpha = (fade<<16) / _XFadeSize;
+00575                 invAlpha = 0x10000 - alpha;
+00576                 *ptr = (sint(*ptr)*alpha + sint(*src) * invAlpha) >> 16;
+00577                 ++src;
+00578                 ++ptr;
+00579                 --count;
+00580                 --fade;
+00581         }
+00582 
+00583         ptr = lbi.Ptr2;
+00584         count = lbi.Size2 /2;
+00585 
+00586         while (fade && count)
+00587         {
+00588                 alpha = (fade<<16) / _XFadeSize;
+00589                 invAlpha = 0x10000 - alpha;
+00590                 *ptr = (sint(*ptr)*alpha + sint(*src) * invAlpha) >> 16;
+00591                 ++src;
+00592                 ++ptr;
+00593                 --count;
+00594                 --fade;
+00595         }
+00596 }
+
+


Friends And Related Function Documentation

+

+ + + + +
+ + +
friend class CSoundDriverDSound [friend] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 102 of file source_dsound.h.

+


Field Documentation

+

+ + + + +
+ + +
LPDIRECTSOUND3DBUFFER NLSOUND::CSourceDSound::_3DBuffer [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 413 of file source_dsound.h. +

+Referenced by CSourceDSound(), getCone(), getDirection(), getMinMaxDistances(), getSourceRelativeMode(), getVelocity(), init(), release(), setCone(), setDirection(), setMinMaxDistances(), setPos(), setSourceRelativeMode(), and setVelocity().

+

+ + + + +
+ + +
IBuffer::TADPCMState NLSOUND::CSourceDSound::_ADPCMState [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 418 of file source_dsound.h. +

+Referenced by fillData(), play(), setStaticBuffer(), and update().

+

+ + + + +
+ + +
double NLSOUND::CSourceDSound::_Alpha [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 458 of file source_dsound.h. +

+Referenced by CSourceDSound(), setAlpha(), and updateVolume().

+

+ + + + +
+ + +
CRITICAL_SECTION NLSOUND::CSourceDSound::_CriticalSection [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 415 of file source_dsound.h. +

+Referenced by CSourceDSound(), play(), setStaticBuffer(), stop(), update(), and ~CSourceDSound().

+

+ + + + +
+ + +
const uint NLSOUND::CSourceDSound::_DefaultChannels = 1 [static, private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 75 of file source_dsound.cpp. +

+Referenced by init().

+

+ + + + +
+ + +
const uint NLSOUND::CSourceDSound::_DefaultSampleRate = 22050 [static, private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 76 of file source_dsound.cpp. +

+Referenced by CSourceDSound(), and init().

+

+ + + + +
+ + +
const uint NLSOUND::CSourceDSound::_DefaultSampleSize = 16 [static, private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 77 of file source_dsound.cpp. +

+Referenced by init().

+

+ + + + +
+ + +
uint32 NLSOUND::CSourceDSound::_FillOffset [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 394 of file source_dsound.h. +

+Referenced by advanceFill(), CSourceDSound(), play(), stop(), and update().

+

+ + + + +
+ + +
TSampleFormat NLSOUND::CSourceDSound::_Format [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 381 of file source_dsound.h.

+

+ + + + +
+ + +
float NLSOUND::CSourceDSound::_Freq [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 386 of file source_dsound.h.

+

+ + + + +
+ + +
float NLSOUND::CSourceDSound::_Gain [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 457 of file source_dsound.h.

+

+ + + + +
+ + +
uint32 NLSOUND::CSourceDSound::_LastPlayPos [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 393 of file source_dsound.h. +

+Referenced by CSourceDSound(), play(), and update().

+

+ + + + +
+ + +
ILoader* NLSOUND::ISource::_Loader [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 170 of file source.h. +

+Referenced by NLSOUND::ISource::ISource(), NLSOUND::ISource::setStreamLoader(), and NLSOUND::ISource::~ISource().

+

+ + + + +
+ + +
bool NLSOUND::CSourceDSound::_Loop [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 401 of file source_dsound.h. +

+Referenced by CSourceDSound(), getLooping(), play(), setLooping(), and update().

+

+ + + + +
+ + +
IBuffer* NLSOUND::CSourceDSound::_NextSample [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 391 of file source_dsound.h. +

+Referenced by getStaticBuffer(), play(), and setStaticBuffer().

+

+ + + + +
+ + +
uint32 NLSOUND::CSourceDSound::_PlayOffset [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 380 of file source_dsound.h. +

+Referenced by CSourceDSound(), getTime(), play(), setStaticBuffer(), and update().

+

+ + + + +
+ + +
NLMISC::CVector NLSOUND::CSourceDSound::_Pos [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 459 of file source_dsound.h.

+

+ + + + +
+ + +
IBuffer* NLSOUND::CSourceDSound::_Sample [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 374 of file source_dsound.h. +

+Referenced by CSourceDSound(), fillData(), getBuffer(), getPitch(), getStaticBuffer(), getTime(), play(), setPitch(), and setStaticBuffer().

+

+ + + + +
+ + +
uint NLSOUND::CSourceDSound::_SampleFreq [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 382 of file source_dsound.h. +

+Referenced by CSourceDSound(), play(), and setStaticBuffer().

+

+ + + + +
+ + +
uint NLSOUND::CSourceDSound::_SampleOffset [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 378 of file source_dsound.h. +

+Referenced by CSourceDSound(), fillData(), play(), setStaticBuffer(), and update().

+

+ + + + +
+ + +
uint32 NLSOUND::CSourceDSound::_SampleRate [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 388 of file source_dsound.h. +

+Referenced by CSourceDSound(), and setPitch().

+

+ + + + +
+ + +
uint NLSOUND::CSourceDSound::_SampleSize [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 376 of file source_dsound.h. +

+Referenced by CSourceDSound(), fillData(), play(), setStaticBuffer(), and update().

+

+ + + + +
+ + +
LPDIRECTSOUNDBUFFER NLSOUND::CSourceDSound::_SecondaryBuffer [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 407 of file source_dsound.h. +

+Referenced by CSourceDSound(), getCursors(), getPitch(), init(), lock(), release(), setPitch(), unlock(), and updateVolume().

+

+ + + + +
+ + +
const uint32 NLSOUND::CSourceDSound::_SecondaryBufferSize = 0x10000 [static, private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 70 of file source_dsound.cpp. +

+Referenced by advanceFill(), init(), and update().

+

+ + + + +
+ + +
uint32 NLSOUND::CSourceDSound::_SilenceWriten [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 395 of file source_dsound.h. +

+Referenced by play(), stop(), and update().

+

+ + + + +
+ + +
const uint32 NLSOUND::CSourceDSound::_SizeMask = 0xffff [static, private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 71 of file source_dsound.cpp. +

+Referenced by advanceFill(), getCursors(), and update().

+

+ + + + +
+ + +
uint NLSOUND::CSourceDSound::_SourceName [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 365 of file source_dsound.h. +

+Referenced by sourceName().

+

+ + + + +
+ + +
TSourceState NLSOUND::CSourceDSound::_State [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 368 of file source_dsound.h. +

+Referenced by CSourceDSound(), getStaticBuffer(), isPlaying(), isStopped(), needsUpdate(), play(), setStaticBuffer(), stop(), and update().

+

+ + + + +
+ + +
const uint32 NLSOUND::CSourceDSound::_SwapCopySize = 0x8000 [static, private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 72 of file source_dsound.cpp.

+

+ + + + +
+ + +
const uint32 NLSOUND::CSourceDSound::_UpdateCopySize = 0x4000 [static, private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 73 of file source_dsound.cpp. +

+Referenced by getCursors(), and update().

+

+ + + + +
+ + +
sint32 NLSOUND::CSourceDSound::_Volume [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 456 of file source_dsound.h.

+

+ + + + +
+ + +
const uint32 NLSOUND::CSourceDSound::_XFadeSize = 64 [static, private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 74 of file source_dsound.cpp. +

+Referenced by fadeIn(), fadeOut(), play(), stop(), update(), and xfade().

+


The documentation for this class was generated from the following files: +
Generated on Tue Mar 16 14:49:17 2004 for NeL by + +doxygen +1.3.6
+ + -- cgit v1.2.1