BrawlLib.Internal.Audio.AudioBuffer Class Reference

Inheritance diagram for BrawlLib.Internal.Audio.AudioBuffer:

Public Member Functions
virtual void	Dispose ()
abstract void	Play ()
abstract void	Stop ()
abstract BufferData	Lock (int offset, int length)
abstract void	Unlock (BufferData data)
void	Seek (int samplePos)
void	Reset ()
virtual void	Update ()
virtual void	Fill ()
virtual void	Fill (IAudioStream source, int samples, bool loop)

Properties
AudioProvider	Owner [get]
IAudioStream	Source [get]
WaveFormatTag	Format [get]
int	Frequency [get]
int	Channels [get]
int	BitsPerSample [get]
int	SampleLength [get]
int	DataLength [get]
int	BlockAlign [get]
int	WriteOffset [get]
int	ReadOffset [get]
int	WriteSample [get]
int	ReadSample [get]
bool	Loop [get, set]
abstract int	Volume [get, set]
abstract int	Pan [get, set]

Member Function Documentation

Dispose()

virtual void BrawlLib.Internal.Audio.AudioBuffer.Dispose ( )

inlinevirtual

        {
            if (_owner != null)
            {
                _owner._buffers.Remove(this);
                _owner = null;
            }
 
            GC.SuppressFinalize(this);
        }

Fill() [1/2]

virtual void BrawlLib.Internal.Audio.AudioBuffer.Fill ( )

inlinevirtual

        {
            //This only works if a source has been assigned!
            if (_source == null)
            {
                return;
            }
 
            //Update read position
            Update();
 
            //Get number of samples available for writing. 
            int sampleCount = ((_readOffset <= _writeOffset ? _readOffset + _dataLength : _readOffset) - _writeOffset) /
                              _blockAlign / 8;
 
            //Fill samples
            Fill(_source, sampleCount, _loop);
        }

Fill() [2/2]

virtual void BrawlLib.Internal.Audio.AudioBuffer.Fill ( IAudioStream  source, int  samples, bool  loop  )

inlinevirtual

        {
            int byteCount = samples * _blockAlign;
 
            //Lock buffer and fill
            BufferData data = Lock(_writeOffset, byteCount);
            try
            {
                data.Fill(source, loop);
            }
            finally
            {
                Unlock(data);
            }
 
            //Advance offsets
            _writeOffset = (_writeOffset + byteCount) % _dataLength;
            _writeSample = source.SamplePosition;
        }

Lock()

abstract BufferData BrawlLib.Internal.Audio.AudioBuffer.Lock ( int  offset, int  length  )

pure virtual

Play()

abstract void BrawlLib.Internal.Audio.AudioBuffer.Play ( )

pure virtual

Reset()

void BrawlLib.Internal.Audio.AudioBuffer.Reset ( )

inline

        {
            _readOffset = _writeOffset = PlayCursor;
        }

Seek()

void BrawlLib.Internal.Audio.AudioBuffer.Seek ( int  samplePos )

inline

        {
            _readOffset = _writeOffset = PlayCursor;
            _readSample = _writeSample = samplePos;
 
            if (_source != null)
            {
                _source.SamplePosition = samplePos;
            }
        }

Stop()

abstract void BrawlLib.Internal.Audio.AudioBuffer.Stop ( )

pure virtual

Unlock()

abstract void BrawlLib.Internal.Audio.AudioBuffer.Unlock ( BufferData  data )

pure virtual

Update()

virtual void BrawlLib.Internal.Audio.AudioBuffer.Update ( )

inlinevirtual

        {
            //Get current sample offset.
            int sampleOffset = PlayCursor / _blockAlign;
            //Get current byte offset
            int byteOffset = sampleOffset * _blockAlign;
            //Get sample difference since last update, taking into account circular wrapping.
            int sampleDifference = ((byteOffset < _readOffset ? byteOffset + _dataLength : byteOffset) - _readOffset) /
                                   _blockAlign;
            //Get byte difference
            //int byteDifference = sampleDifference * _blockAlign;
 
            //If no change, why continue?
            if (sampleDifference == 0)
            {
                return;
            }
 
            //Set new read offset.
            _readOffset = byteOffset;
 
            //Update looping
            if (_source != null)
            {
                if (_loop && _source.IsLooping)
                {
                    int start = _source.LoopStartSample;
                    int end = _source.LoopEndSample;
                    int newSample = _readSample + sampleDifference;
 
                    if (newSample >= end && _writeSample < _readSample)
                    {
                        _readSample = start + (newSample - start) % (end - start);
                    }
                    else
                    {
                        _readSample = Math.Min(newSample, _source.Samples);
                    }
                }
                else
                {
                    _readSample = Math.Min(_readSample + sampleDifference, _source.Samples);
                    //if (_readSample >= _source.Samples)
                    //    Stop();
                }
            }
            else
            {
                _readSample += sampleDifference;
            }
        }

Property Documentation

BitsPerSample

int BrawlLib.Internal.Audio.AudioBuffer.BitsPerSample

get

BlockAlign

int BrawlLib.Internal.Audio.AudioBuffer.BlockAlign

get

Channels

int BrawlLib.Internal.Audio.AudioBuffer.Channels

get

DataLength

int BrawlLib.Internal.Audio.AudioBuffer.DataLength

get

Format

WaveFormatTag BrawlLib.Internal.Audio.AudioBuffer.Format

get

Frequency

int BrawlLib.Internal.Audio.AudioBuffer.Frequency

get

Loop

bool BrawlLib.Internal.Audio.AudioBuffer.Loop

getset

        {
            get => _loop;
            set => _loop = value;
        }

Owner

AudioProvider BrawlLib.Internal.Audio.AudioBuffer.Owner

get

Pan

abstract int BrawlLib.Internal.Audio.AudioBuffer.Pan

getset

{ get; set; }

ReadOffset

int BrawlLib.Internal.Audio.AudioBuffer.ReadOffset

get

ReadSample

int BrawlLib.Internal.Audio.AudioBuffer.ReadSample

get

SampleLength

int BrawlLib.Internal.Audio.AudioBuffer.SampleLength

get

Source

IAudioStream BrawlLib.Internal.Audio.AudioBuffer.Source

get

Volume

abstract int BrawlLib.Internal.Audio.AudioBuffer.Volume

getset

{ get; set; }

WriteOffset

int BrawlLib.Internal.Audio.AudioBuffer.WriteOffset

get

WriteSample

int BrawlLib.Internal.Audio.AudioBuffer.WriteSample

get

---

The documentation for this class was generated from the following file:

• BrawlLib/Internal/Audio/AudioBuffer.cs