MixerSource Class Reference

#include <MixerSource.h>

Inheritance diagram for MixerSource:

Collaboration diagram for MixerSource:

Public Types
using	TimesAndSpeed = MixerOptions::TimesAndSpeed
using	ResampleParameters = MixerOptions::ResampleParameters
Public Types inherited from AudioGraph::Source
using	Buffers = AudioGraph::Buffers

Public Member Functions
	MixerSource (const std::shared_ptr< const WideSampleSequence > &seq, size_t bufferSize, double rate, const MixerOptions::Warp &options, bool highQuality, bool mayThrow, std::shared_ptr< TimesAndSpeed > pTimesAndSpeed, const ArrayOf< bool > *pMap)
	MixerSource (MixerSource &&)=default
MixerSource &	operator= (MixerSource &&)=delete
	~MixerSource ()
unsigned	Channels () const
const WideSampleSequence &	GetSequence () const
const bool *	MixerSpec (unsigned iChannel) const
bool	AcceptsBuffers (const Buffers &buffers) const override
bool	AcceptsBlockSize (size_t blockSize) const override
std::optional< size_t >	Acquire (Buffers &data, size_t bound) override
	Occupy vacant space in Buffers with some data. More...
sampleCount	Remaining () const override
	Result includes any amount Acquired and not yet Released. More...
bool	Release () override
	Caller is done examining last Acquire()d positions. More...
bool	Terminates () const override
void	Reposition (double time, bool skipping)
bool	VariableRates () const
Public Member Functions inherited from AudioGraph::Source
virtual	~Source ()
virtual bool	AcceptsBuffers (const Buffers &buffers) const =0
virtual bool	AcceptsBlockSize (size_t blockSize) const =0
virtual std::optional< size_t >	Acquire (Buffers &data, size_t bound)=0
	Occupy vacant space in Buffers with some data. More...
virtual sampleCount	Remaining () const =0
	Result includes any amount Acquired and not yet Released. More...
virtual bool	Release ()=0
	Caller is done examining last Acquire()d positions. More...
virtual bool	Terminates () const
	Needed only to make some postconditions assertable; defaults true. More...

Private Member Functions
void	MakeResamplers ()
size_t	MixSameRate (unsigned nChannels, size_t maxOut, float *floatBuffers[])
size_t	MixVariableRates (unsigned nChannels, size_t maxOut, float *floatBuffers[])
void	ZeroFill (size_t produced, size_t max, float &floatBuffer)

Private Attributes
const std::shared_ptr< const WideSampleSequence >	mpSeq
size_t	i
const size_t	mnChannels
const double	mRate
const BoundedEnvelope *const	mEnvelope
	Resampling, as needed, after gain envelope. More...
const bool	mMayThrow
const std::shared_ptr< TimesAndSpeed >	mTimesAndSpeed
sampleCount	mSamplePos
	Fetch position for source. More...
std::vector< std::vector< float > >	mSampleQueue
	First intermediate buffer when resampling is needed. More...
int	mQueueStart
	Position of the start of the next block to resample. More...
int	mQueueLen
	The number of available samples after the queue start. More...
const ResampleParameters	mResampleParameters
std::vector< std::unique_ptr< Resample > >	mResample
std::vector< double >	mEnvValues
	Gain envelopes are applied to input before other transformations. More...
const ArrayOf< bool > *const	mpMap
unsigned	mMaxChannels {}
	Remember how many channels were passed to Acquire() More...
size_t	mLastProduced {}

Static Private Attributes
static constexpr size_t	sProcessLen = 1024
static constexpr size_t	sQueueMaxLen = 65536

Detailed Description

Fetches from tracks, applies envelopes; can resample, and warp time, even backwards, as for scrubbing.

This class inherits AudioGraph::Source but does not yet fulfill the contracts of all of the members. But it is not yet used through any pointer or reference to its base class.

Definition at line 33 of file MixerSource.h.

Member Typedef Documentation

ResampleParameters

using MixerSource::ResampleParameters = MixerOptions::ResampleParameters

Definition at line 36 of file MixerSource.h.

TimesAndSpeed

using MixerSource::TimesAndSpeed = MixerOptions::TimesAndSpeed

Definition at line 35 of file MixerSource.h.

Constructor & Destructor Documentation

MixerSource() [1/2]

MixerSource::MixerSource	(	const std::shared_ptr< const WideSampleSequence > &	seq,
		size_t	bufferSize,
		double	rate,
		const MixerOptions::Warp &	options,
		bool	highQuality,
		bool	mayThrow,
		std::shared_ptr< TimesAndSpeed >	pTimesAndSpeed,
		const ArrayOf< bool > *	pMap
	)

Precondition

pTimesAndSpeed != nullptr

Parameters

pMap	Null or else must have a lifetime enclosing this objects's

Definition at line 289 of file MixerSource.cpp.

   : mpSeq{ seq }
   , mnChannels{ mpSeq->NChannels() }
   , mRate{ rate }
   , mEnvelope{ options.envelope }
   , mMayThrow{ mayThrow }
   , mTimesAndSpeed{ move(pTimesAndSpeed) }
   , mSampleQueue{ initVector<float>(mnChannels, sQueueMaxLen) }
   , mQueueStart{ 0 }
   , mQueueLen{ 0 }
   , mResampleParameters{ highQuality, mpSeq->GetRate(), rate, options }
   , mResample( mnChannels )
   , mEnvValues( std::max(sQueueMaxLen, bufferSize) )
   , mpMap{ pMap }
{
   assert(mTimesAndSpeed);
   auto t0 = mTimesAndSpeed->mT0;
   mSamplePos = GetSequence().TimeToLongSamples(t0);
   MakeResamplers();
}

References GetSequence(), MakeResamplers(), mSamplePos, mTimesAndSpeed, and WideSampleSequence::TimeToLongSamples().

Here is the call graph for this function:

MixerSource() [2/2]

MixerSource::MixerSource ( MixerSource &&  )

default

~MixerSource()

MixerSource::~MixerSource ( )

default

Member Function Documentation

AcceptsBlockSize()

bool MixerSource::AcceptsBlockSize ( size_t  blockSize ) const

overridevirtual

Implements AudioGraph::Source.

Definition at line 331 of file MixerSource.cpp.

{
   return blockSize <= mEnvValues.size();
}

References mEnvValues.

Referenced by AcceptsBuffers(), and Acquire().

Here is the caller graph for this function:

AcceptsBuffers()

bool MixerSource::AcceptsBuffers ( const Buffers &  buffers ) const

overridevirtual

Implements AudioGraph::Source.

Definition at line 326 of file MixerSource.cpp.

{
   return AcceptsBlockSize(buffers.BufferSize());
}

References AcceptsBlockSize(), and AudioGraph::Buffers::BufferSize().

Referenced by Acquire().

Here is the call graph for this function:

Here is the caller graph for this function:

Acquire()

std::optional< size_t > MixerSource::Acquire ( Buffers &  data, size_t  bound  )

overridevirtual

Occupy vacant space in Buffers with some data.

May exceeed a single block of production Can assume same buffer is passed each time, while the caller advances it over the previous production, or discards it, or rotates the buffer. May rewind or rotate the buffer.

Returns

number of positions available to read from data or nullopt to fail

Precondition

AcceptsBuffers(data)

AcceptsBlockSize(data.BlockSize())

bound <= data.BlockSize()

data.BlockSize() <= data.Remaining()

Postcondition

result: !result || *result <= bound

result: !result || *result <= data.Remaining()

result: !result || *result <= Remaining()

data.Remaining() > 0

result: !result || bound == 0 || Remaining() == 0 || *result > 0 (progress guarantee)

!Terminates() or Remaining() was not previously defined, or is unchanged

Implements AudioGraph::Source.

Definition at line 338 of file MixerSource.cpp.

{
   assert(AcceptsBuffers(data));
   assert(AcceptsBlockSize(data.BlockSize()));
   assert(bound <= data.BlockSize());
   assert(data.BlockSize() <= data.Remaining());
 
   auto &[mT0, mT1, _, mTime] = *mTimesAndSpeed;
   const bool backwards = (mT1 < mT0);
   // TODO: more-than-two-channels
   const auto maxChannels = mMaxChannels = data.Channels();
   const auto limit = std::min<size_t>(mnChannels, maxChannels);
   size_t maxTrack = 0;
   const auto mixed = stackAllocate(size_t, maxChannels);
   const auto pFloats = stackAllocate(float *, limit);
   for (size_t j = 0; j < limit; ++j)
      pFloats[j] = &data.GetWritePosition(j);
   const auto rate = GetSequence().GetRate();
   auto result = (mResampleParameters.mVariableRates || rate != mRate)
      ? MixVariableRates(limit, bound, pFloats)
      : MixSameRate(limit, bound, pFloats);
   maxTrack = std::max(maxTrack, result);
   auto newT = mSamplePos.as_double() / rate;
   if (backwards)
      mTime = std::min(mTime, newT);
   else
      mTime = std::max(mTime, newT);
   for (size_t j = 0; j < limit; ++j) {
      mixed[j] = result;
   }
   // Another pass in case channels of a track did not produce equal numbers
   for (size_t j = 0; j < limit; ++j) {
      const auto pFloat = &data.GetWritePosition(j);
      const auto result = mixed[j];
      ZeroFill(result, maxTrack, *pFloat);
   }
 
   mLastProduced = maxTrack;
   assert(maxTrack <= bound);
   assert(maxTrack <= data.Remaining());
   assert(maxTrack <= Remaining());
   assert(data.Remaining() > 0);
   assert(bound == 0 || Remaining() == 0 || maxTrack > 0);
   return { mLastProduced };
}

References _, AcceptsBlockSize(), AcceptsBuffers(), sampleCount::as_double(), AudioGraph::Buffers::BlockSize(), AudioGraph::Buffers::Channels(), WideSampleSequence::GetRate(), GetSequence(), AudioGraph::Buffers::GetWritePosition(), min(), MixSameRate(), MixVariableRates(), mLastProduced, mMaxChannels, mnChannels, mRate, mResampleParameters, mSamplePos, mTimesAndSpeed, MixerOptions::ResampleParameters::mVariableRates, AudioGraph::Buffers::Remaining(), Remaining(), stackAllocate, and ZeroFill().

Here is the call graph for this function:

Channels()

unsigned MixerSource::Channels ( ) const

inline

Definition at line 52 of file MixerSource.h.

{ return mnChannels; }

References mnChannels.

GetSequence()

const WideSampleSequence & MixerSource::GetSequence

(

)

const

Definition at line 316 of file MixerSource.cpp.

{
   return *mpSeq;
}

References mpSeq.

Referenced by Acquire(), MixerSource(), and Reposition().

Here is the caller graph for this function:

MakeResamplers()

void MixerSource::MakeResamplers ( )

private

Definition at line 40 of file MixerSource.cpp.

{
   for (size_t j = 0; j < mnChannels; ++j)
      mResample[j] = std::make_unique<Resample>(
         mResampleParameters.mHighQuality,
         mResampleParameters.mMinFactor, mResampleParameters.mMaxFactor);
}

References MixerOptions::ResampleParameters::mHighQuality, MixerOptions::ResampleParameters::mMaxFactor, MixerOptions::ResampleParameters::mMinFactor, mnChannels, mResample, and mResampleParameters.

Referenced by MixerSource(), and Reposition().

Here is the caller graph for this function:

MixerSpec()

const bool * MixerSource::MixerSpec

(

unsigned

iChannel

)

const

Definition at line 321 of file MixerSource.cpp.

{
   return mpMap ? mpMap[iChannel].get() : nullptr;
}

References anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel, and mpMap.

MixSameRate()

size_t MixerSource::MixSameRate ( unsigned  nChannels, size_t  maxOut, float *  floatBuffers[]  )

private

Assume floatBuffers has extent nChannels

Postcondition

result: result <= maxOut

Definition at line 219 of file MixerSource.cpp.

{
   const auto &[mT0, mT1, _, __] = *mTimesAndSpeed;
   const bool backwards = (mT1 < mT0);
   const auto sequenceRate = mpSeq->GetRate();
   const double tEnd = [mpSeq = mpSeq, mT1 = mT1, backwards]{
      const double sequenceEndTime = mpSeq->GetEndTime();
      const double sequenceStartTime = mpSeq->GetStartTime();
      return backwards
         ? std::max(sequenceStartTime, mT1)
         : std::min(sequenceEndTime, mT1);
   }();
 
   // This function fetches samples from the input sequences, whatever their
   // formats, as floats; it may also apply envelope values.
 
   auto pos = mSamplePos;
 
   const double t = (pos).as_double() / sequenceRate;
 
   //don't process if we're at the end of the selection or sequence.
   if ((backwards ? t <= tEnd : t >= tEnd))
      return 0;
   //if we're about to approach the end of the sequence or selection, figure out how much we need to grab
   const auto slen = limitSampleBufferSize(
      maxOut,
      // PRL: maybe t and tEnd should be given as sampleCount instead to
      // avoid trouble subtracting one large value from another for a small
      // difference
      sampleCount{ (backwards ? t - tEnd : tEnd - t) * sequenceRate + 0.5 }
   );
 
   constexpr auto iChannel = 0u;
   if (!mpSeq->GetFloats(
      iChannel, nChannels, floatBuffers, pos, slen, backwards,
      FillFormat::fillZero, mMayThrow)
   ) {
      // Now redundant in case of failure
      // for (size_t iChannel = 0; iChannel < nChannels; ++iChannel)
         // memset(floatBuffers[iChannel], 0, sizeof(float) * slen);
      
   }
 
   mpSeq->GetEnvelopeValues(mEnvValues.data(), slen, t, backwards);
 
   for (size_t iChannel = 0; iChannel < nChannels; ++iChannel) {
      const auto pFloat = floatBuffers[iChannel];
      for (size_t i = 0; i < slen; i++)
         pFloat[i] *= mEnvValues[i]; // Track gain control will go here?
   }
 
   if (backwards)
      pos -= slen;
   else
      pos += slen;
 
   assert(slen <= maxOut);
   mSamplePos = pos;
   return slen;
}

References _, fillZero, i, anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel, limitSampleBufferSize(), mEnvValues, min(), mMayThrow, mpSeq, mSamplePos, and mTimesAndSpeed.

Referenced by Acquire().

Here is the call graph for this function:

Here is the caller graph for this function:

MixVariableRates()

size_t MixerSource::MixVariableRates ( unsigned  nChannels, size_t  maxOut, float *  floatBuffers[]  )

private

Assume floatBuffers has extent nChannels

Postcondition

result: result <= maxOut

Definition at line 68 of file MixerSource.cpp.

{
   const auto &[mT0, mT1, mSpeed, _] = *mTimesAndSpeed;
   const bool backwards = (mT1 < mT0);
 
   const double sequenceRate = mpSeq->GetRate();
   const double initialWarp = mRate / mSpeed / sequenceRate;
   const double tstep = 1.0 / sequenceRate;
   const auto sampleSize = SAMPLE_SIZE(floatSample);
   // Find the last sample
   const auto endPos = [mpSeq = mpSeq, mT1 = mT1, backwards]{
      double endTime = mpSeq->GetEndTime();
      double startTime = mpSeq->GetStartTime();
      const double tEnd = backwards
         ? std::max(startTime, mT1)
         : std::min(endTime, mT1);
      return mpSeq->TimeToLongSamples(tEnd);
   }();
 
   auto pos = mSamplePos;
   auto queueStart = mQueueStart;
   auto queueLen = mQueueLen;
 
   size_t out = 0;
 
   /* time is floating point. Sample rate is integer. The number of samples
    * has to be integer, but the multiplication gives a float result, which we
    * round to get an integer result. TODO: is this always right or can it be
    * off by one sometimes? Can we not get this information directly from the
    * clip (which must know) rather than convert the time?
    *
    * LLL:  Not at this time.  While WaveClips provide methods to retrieve the
    *       start and end sample, they do the same float->sampleCount conversion
    *       to calculate the position.
    */
 
   // Find the time corresponding to the start of the queue, for use with time track
   double t = ((pos).as_long_long() +
               (backwards ? queueLen : - queueLen)) / sequenceRate;
 
   while (out < maxOut) {
      if (queueLen < (int)sProcessLen) {
         // Shift pending portion to start of the buffer
         for (size_t iChannel = 0; iChannel < nChannels; ++iChannel) {
            const auto queue = mSampleQueue[iChannel].data();
            memmove(queue, &queue[queueStart], (queueLen) * sampleSize);
         }
         queueStart = 0;
 
         // How far to advance depends on endPos,
         // which is independent of channel
         auto getLen = limitSampleBufferSize(
            sQueueMaxLen - queueLen,
            backwards ? pos - endPos : endPos - pos
         );
 
         // Nothing to do if past end of play interval
         if (getLen > 0) {
            std::vector<float*> dst;
            for (auto& queue : mSampleQueue)
               dst.push_back(queue.data() + queueLen);
            constexpr auto iChannel = 0u;
            if (!mpSeq->GetFloats(
                   iChannel, nChannels, dst.data(), pos, getLen, backwards,
                   FillFormat::fillZero, mMayThrow)) {
               // Now redundant in case of failure
               // for (size_t iChannel = 0; iChannel < nChannels; ++iChannel)
                  // memset(dst[i], 0, sizeof(float) * getLen);
            }
            mpSeq->GetEnvelopeValues(
               mEnvValues.data(), getLen, (pos).as_double() / sequenceRate,
               backwards);
            for (size_t iChannel = 0; iChannel < nChannels; ++iChannel) {
               const auto queue = mSampleQueue[iChannel].data();
               for (decltype(getLen) i = 0; i < getLen; i++)
                  queue[(queueLen) + i] *= mEnvValues[i];
            }
 
            if (backwards)
               pos -= getLen;
            else
               pos += getLen;
            queueLen += getLen;
         }
      }
 
      auto thisProcessLen = sProcessLen;
      bool last = (queueLen < (int)sProcessLen);
      if (last) {
         thisProcessLen = queueLen;
      }
 
      double factor = initialWarp;
      if (mEnvelope)
      {
         //TODO-MB: The end time is wrong when the resampler doesn't use all input samples,
         //         as a result of this the warp factor may be slightly wrong, so AudioIO will stop too soon
         //         or too late (resulting in missing sound or inserted silence). This can't be fixed
         //         without changing the way the resampler works, because the number of input samples that will be used
         //         is unpredictable. Maybe it can be compensated later though.
         if (backwards)
            factor *= ComputeWarpFactor( *mEnvelope,
               t - (double)thisProcessLen / sequenceRate + tstep, t + tstep);
         else
            factor *= ComputeWarpFactor( *mEnvelope,
               t, t + (double)thisProcessLen / sequenceRate);
      }
 
      std::pair<size_t, size_t> results;
      for (size_t iChannel = 0; iChannel < nChannels; ++iChannel) {
         const auto queue = mSampleQueue[iChannel].data();
         const auto pResample = mResample[iChannel].get();
         const auto pFloat = floatBuffers[iChannel];
         // Assuming that progress of the Resampler depends only
         // on the size of its inputs, this assignment has the same effect on
         // each pass.
         results = pResample->Process(factor,
            &queue[queueStart],
            thisProcessLen,
            last,
            // PRL:  Bug2536: crash in soxr happened on Mac, sometimes, when
            // maxOut - out == 1 and &pFloat[out + 1] was an unmapped
            // address, because soxr, strangely, fetched an 8-byte (misaligned!)
            // value from &pFloat[out], but did nothing with it anyway,
            // in soxr_output_no_callback.
            // Now we make the bug go away by allocating a little more space in
            // the buffer than we need.
            &pFloat[out],
            maxOut - out);
      }
 
      const auto input_used = results.first;
      queueStart += input_used;
      queueLen -= input_used;
      out += results.second;
      t += (input_used / sequenceRate) * (backwards ? -1 : 1);
 
      if (last) {
         break;
      }
   }
 
   assert(out <= maxOut);
 
   mSamplePos = pos;
   mQueueStart = queueStart;
   mQueueLen = queueLen;
   return out;
}

References _, anonymous_namespace{MixerSource.cpp}::ComputeWarpFactor(), fillZero, floatSample, i, anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel, limitSampleBufferSize(), mEnvelope, mEnvValues, min(), mMayThrow, mpSeq, mQueueLen, mQueueStart, mRate, mResample, mSamplePos, mSampleQueue, mTimesAndSpeed, SAMPLE_SIZE, sProcessLen, and sQueueMaxLen.

Referenced by Acquire().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

MixerSource & MixerSource::operator= ( MixerSource &&  )

delete

Release()

bool MixerSource::Release ( )

overridevirtual

Caller is done examining last Acquire()d positions.

May be called only after at least one successful call to Acquire()

Returns

success

Postcondition

!Terminates() or Remaining() reduced by what was last returned by Acquire()

Implements AudioGraph::Source.

Definition at line 392 of file MixerSource.cpp.

{
   mLastProduced = 0;
   return true;
}

References mLastProduced.

Remaining()

sampleCount MixerSource::Remaining ( ) const

overridevirtual

Result includes any amount Acquired and not yet Released.

May be undefined before the first successful call to Acquire()

Postcondition

result: result >= 0

Implements AudioGraph::Source.

Definition at line 386 of file MixerSource.cpp.

{
   // TODO:  make a more exact calculation of total remaining; see Terminates()
   return mLastProduced;
}

References mLastProduced.

Referenced by Acquire().

Here is the caller graph for this function:

Reposition()

void MixerSource::Reposition	(	double	time,
		bool	skipping
	)

Definition at line 408 of file MixerSource.cpp.

{
   mSamplePos = GetSequence().TimeToLongSamples(time);
   mQueueStart = 0;
   mQueueLen = 0;
 
   // Bug 2025:  libsoxr 0.1.3, first used in Audacity 2.3.0, crashes with
   // constant rate resampling if you try to reuse the resampler after it has
   // flushed.  Should that be considered a bug in sox?  This works around it.
   // (See also bug 1887, and the same work around in Mixer::Restart().)
   if (skipping)
      MakeResamplers();
}

References GetSequence(), MakeResamplers(), mQueueLen, mQueueStart, mSamplePos, and WideSampleSequence::TimeToLongSamples().

Here is the call graph for this function:

Terminates()

bool MixerSource::Terminates ( ) const

overridevirtual

Returns

false

Reimplemented from AudioGraph::Source.

Definition at line 398 of file MixerSource.cpp.

{
   // Not always terminating
   // TODO: return true sometimes, for mixers that never reposition
   // because they are not used in playback.  But then an exact calculation of
   // Remaining() is needed to satisfy the contract, and that is complicated
   // when there is resampling or a time warp.
   return false;
}

VariableRates()

bool MixerSource::VariableRates ( ) const

inline

Definition at line 65 of file MixerSource.h.

{ return mResampleParameters.mVariableRates; }

References mResampleParameters, and MixerOptions::ResampleParameters::mVariableRates.

Referenced by Mixer::NeedsDither().

Here is the caller graph for this function:

ZeroFill()

void MixerSource::ZeroFill ( size_t  produced, size_t  max, float &  floatBuffer  )

private

Precondition

produced <= max

Definition at line 281 of file MixerSource.cpp.

{
   assert(produced <= max);
   const auto pFloat = &floatBuffer;
   std::fill(pFloat + produced, pFloat + max, 0);
}

Referenced by Acquire().

Here is the caller graph for this function:

Member Data Documentation

i

size_t MixerSource::i

private

Definition at line 101 of file MixerSource.h.

Referenced by MixSameRate(), and MixVariableRates().

mEnvelope

const BoundedEnvelope* const MixerSource::mEnvelope

private

Resampling, as needed, after gain envelope.

Definition at line 107 of file MixerSource.h.

Referenced by MixVariableRates().

mEnvValues

std::vector<double> MixerSource::mEnvValues

private

Gain envelopes are applied to input before other transformations.

Definition at line 131 of file MixerSource.h.

Referenced by AcceptsBlockSize(), MixSameRate(), and MixVariableRates().

mLastProduced

size_t MixerSource::mLastProduced {}

private

Definition at line 139 of file MixerSource.h.

Referenced by Acquire(), Release(), and Remaining().

mMaxChannels

unsigned MixerSource::mMaxChannels {}

private

Remember how many channels were passed to Acquire()

Definition at line 138 of file MixerSource.h.

Referenced by Acquire().

mMayThrow

const bool MixerSource::mMayThrow

private

Definition at line 108 of file MixerSource.h.

Referenced by MixSameRate(), and MixVariableRates().

mnChannels

const size_t MixerSource::mnChannels

private

Definition at line 103 of file MixerSource.h.

Referenced by Acquire(), Channels(), and MakeResamplers().

mpMap

const ArrayOf<bool>* const MixerSource::mpMap

private

many-to-one mixing of channels Pointer into array of arrays

Definition at line 135 of file MixerSource.h.

Referenced by MixerSpec().

mpSeq

const std::shared_ptr<const WideSampleSequence> MixerSource::mpSeq

private

Definition at line 100 of file MixerSource.h.

Referenced by GetSequence(), MixSameRate(), and MixVariableRates().

mQueueLen

int MixerSource::mQueueLen

private

The number of available samples after the queue start.

Definition at line 125 of file MixerSource.h.

Referenced by MixVariableRates(), and Reposition().

mQueueStart

int MixerSource::mQueueStart

private

Position of the start of the next block to resample.

Definition at line 122 of file MixerSource.h.

Referenced by MixVariableRates(), and Reposition().

mRate

const double MixerSource::mRate

private

Definition at line 104 of file MixerSource.h.

Referenced by Acquire(), and MixVariableRates().

mResample

std::vector<std::unique_ptr<Resample> > MixerSource::mResample

private

Definition at line 128 of file MixerSource.h.

Referenced by MakeResamplers(), and MixVariableRates().

mResampleParameters

const ResampleParameters MixerSource::mResampleParameters

private

Definition at line 127 of file MixerSource.h.

Referenced by Acquire(), MakeResamplers(), and VariableRates().

mSamplePos

sampleCount MixerSource::mSamplePos

private

Fetch position for source.

mSamplePos holds the next sample position not yet processed

Definition at line 116 of file MixerSource.h.

Referenced by Acquire(), MixerSource(), MixSameRate(), MixVariableRates(), and Reposition().

mSampleQueue

std::vector<std::vector<float> > MixerSource::mSampleQueue

private

First intermediate buffer when resampling is needed.

Definition at line 119 of file MixerSource.h.

Referenced by MixVariableRates().

mTimesAndSpeed

const std::shared_ptr<TimesAndSpeed> MixerSource::mTimesAndSpeed

private

Definition at line 110 of file MixerSource.h.

Referenced by Acquire(), MixerSource(), MixSameRate(), and MixVariableRates().

sProcessLen

constexpr size_t MixerSource::sProcessLen = 1024

staticconstexprprivate

Cut the queue into blocks of this finer size for variable rate resampling. Each block is resampled at some constant rate.

Definition at line 73 of file MixerSource.h.

Referenced by MixVariableRates().

sQueueMaxLen

constexpr size_t MixerSource::sQueueMaxLen = 65536

staticconstexprprivate

This is the number of samples grabbed in one go from a track and placed in a queue, when mixing with resampling.

(Should we use SampleTrack::GetBestBlockSize instead?)

Definition at line 80 of file MixerSource.h.

Referenced by MixVariableRates().

---

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

• MixerSource.h
• MixerSource.cpp