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 SampleTrack &leader, 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 SampleTrack *	GetChannel (unsigned iChannel) 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 iChannel, size_t maxOut, float &floatBuffer)
size_t	MixVariableRates (unsigned iChannel, size_t maxOut, float &floatBuffer)
void	ZeroFill (size_t produced, size_t max, float &floatBuffer)

Private Attributes
const std::shared_ptr< const SampleTrack >	mpLeader
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
std::vector< SampleTrackCache >	mInputTrack
	SampleTrackCaches are the source of data. More...
std::vector< sampleCount >	mSamplePos
	Fetch position for source. More...
std::vector< std::vector< float > >	mSampleQueue
	First intermediate buffer when resampling is needed. More...
std::vector< int >	mQueueStart
	Position in each queue of the start of the next block to resample. More...
std::vector< int >	mQueueLen
	For each queue, 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 30 of file MixerSource.h.

Member Typedef Documentation

ResampleParameters

using MixerSource::ResampleParameters = MixerOptions::ResampleParameters

Definition at line 33 of file MixerSource.h.

TimesAndSpeed

using MixerSource::TimesAndSpeed = MixerOptions::TimesAndSpeed

Definition at line 32 of file MixerSource.h.

Constructor & Destructor Documentation

MixerSource() [1/2]

MixerSource::MixerSource	(	const SampleTrack &	leader,
		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 283 of file MixerSource.cpp.

   : mpLeader{ leader.SharedPointer<const SampleTrack>() }
   , mnChannels{ TrackList::NChannels(leader) }
   , mRate{ rate }
   , mEnvelope{ options.envelope }
   , mMayThrow{ mayThrow }
   , mTimesAndSpeed{ move(pTimesAndSpeed) }
   , mInputTrack( mnChannels )
   , mSamplePos( mnChannels )
   , mSampleQueue{ initVector<float>(mnChannels, sQueueMaxLen) }
   , mQueueStart( mnChannels, 0 )
   , mQueueLen( mnChannels, 0 )
   , mResampleParameters{ highQuality, leader, rate, options }
   , mResample( mnChannels )
   , mEnvValues( std::max(sQueueMaxLen, bufferSize) )
   , mpMap{ pMap }
{
   size_t j = 0;
   for (auto channel : TrackList::Channels(&leader))
      mInputTrack[j++].SetTrack(channel->SharedPointer<const SampleTrack>());
 
   assert(mTimesAndSpeed);
   auto t0 = mTimesAndSpeed->mT0;
   for (j = 0; j < mnChannels; ++j) {
      mSamplePos[j] = GetChannel(j)->TimeToLongSamples(t0);
   }
   MakeResamplers();
}

References TrackList::Channels(), GetChannel(), MakeResamplers(), mInputTrack, mnChannels, mSamplePos, mTimesAndSpeed, and SampleTrack::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 335 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 330 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 342 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);
   for (size_t j = 0; j < limit; ++j) {
      const auto pFloat = &data.GetWritePosition(j);
      auto &result = mixed[j];
      const auto track = GetChannel(j);
      result =
      (mResampleParameters.mVariableRates || track->GetRate() != mRate)
         ? MixVariableRates(j, bound, *pFloat)
         : MixSameRate(j, bound, *pFloat);
      maxTrack = std::max(maxTrack, result);
      auto newT = mSamplePos[j].as_double() / track->GetRate();
      if (backwards)
         mTime = std::min(mTime, newT);
      else
         mTime = std::max(mTime, newT);
   }
   // 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(), AudioGraph::Buffers::BlockSize(), AudioGraph::Buffers::Channels(), GetChannel(), 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 48 of file MixerSource.h.

{ return mnChannels; }

References mnChannels.

GetChannel()

const SampleTrack * MixerSource::GetChannel

(

unsigned

iChannel

)

const

Definition at line 317 of file MixerSource.cpp.

{
   auto range = TrackList::Channels(mpLeader.get());
   auto iter = range.begin();
   std::advance(iter, iChannel);
   return *iter;
}

References TrackList::Channels(), and mpLeader.

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

Here is the call graph for this function:

Here is the caller graph for this function:

MakeResamplers()

void MixerSource::MakeResamplers ( )

private

Definition at line 41 of file MixerSource.cpp.

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

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 325 of file MixerSource.cpp.

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

References mpMap.

MixSameRate()

size_t MixerSource::MixSameRate ( unsigned  iChannel, size_t  maxOut, float &  floatBuffer  )

private

Postcondition

result: result <= maxOut

Definition at line 213 of file MixerSource.cpp.

{
   // This function fetches samples from the input tracks, whatever their
   // formats, as floats; it may also apply envelope values.
 
   auto &cache = mInputTrack[iChannel];
   const auto pos = &mSamplePos[iChannel];
 
   const auto pFloat = &floatBuffer;
   const auto track = cache.GetTrack().get();
   const double t = ( *pos ).as_double() / track->GetRate();
   const double trackEndTime = track->GetEndTime();
   const double trackStartTime = track->GetStartTime();
   const auto &[mT0, mT1, _, __] = *mTimesAndSpeed;
   const bool backwards = (mT1 < mT0);
   const double tEnd = backwards
      ? std::max(trackStartTime, mT1)
      : std::min(trackEndTime, mT1);
 
   //don't process if we're at the end of the selection or track.
   if ((backwards ? t <= tEnd : t >= tEnd))
      return 0;
   //if we're about to approach the end of the track 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) * track->GetRate() + 0.5 }
   );
 
   if (backwards) {
      auto results = cache.GetFloats(*pos - (slen - 1), slen, mMayThrow);
      if (results)
         memcpy(pFloat, results, sizeof(float) * slen);
      else
         memset(pFloat, 0, sizeof(float) * slen);
      track->GetEnvelopeValues(mEnvValues.data(), slen, t - (slen - 1) / mRate);
      for (size_t i = 0; i < slen; i++)
         pFloat[i] *= mEnvValues[i]; // Track gain control will go here?
      ReverseSamples((samplePtr)pFloat, floatSample, 0, slen);
 
      *pos -= slen;
   }
   else {
      auto results = cache.GetFloats(*pos, slen, mMayThrow);
      if (results)
         memcpy(pFloat, results, sizeof(float) * slen);
      else
         memset(pFloat, 0, sizeof(float) * slen);
      track->GetEnvelopeValues(mEnvValues.data(), slen, t);
      for (size_t i = 0; i < slen; i++)
         pFloat[i] *= mEnvValues[i]; // Track gain control will go here?
 
      *pos += slen;
   }
 
   assert(slen <= maxOut);
   return slen;
}

References _, floatSample, i, limitSampleBufferSize(), mEnvValues, min(), mInputTrack, mMayThrow, mRate, mSamplePos, mTimesAndSpeed, and ReverseSamples().

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  iChannel, size_t  maxOut, float &  floatBuffer  )

private

Postcondition

result: result <= maxOut

Definition at line 69 of file MixerSource.cpp.

{
   auto &cache = mInputTrack[iChannel];
   const auto pos = &mSamplePos[iChannel];
   const auto queue = mSampleQueue[iChannel].data();
   const auto queueStart = &mQueueStart[iChannel];
   const auto queueLen = &mQueueLen[iChannel];
   const auto pResample = mResample[iChannel].get();
 
   const auto pFloat = &floatBuffer;
   const auto track = cache.GetTrack().get();
   const double trackRate = track->GetRate();
   const auto &[mT0, mT1, mSpeed, _] = *mTimesAndSpeed;
   const double initialWarp = mRate / mSpeed / trackRate;
   const double tstep = 1.0 / trackRate;
   auto sampleSize = SAMPLE_SIZE(floatSample);
 
   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 last sample
   double endTime = track->GetEndTime();
   double startTime = track->GetStartTime();
   const bool backwards = (mT1 < mT0);
   const double tEnd = backwards
      ? std::max(startTime, mT1)
      : std::min(endTime, mT1);
   const auto endPos = track->TimeToLongSamples(tEnd);
   // Find the time corresponding to the start of the queue, for use with time track
   double t = ((*pos).as_long_long() +
               (backwards ? *queueLen : - *queueLen)) / trackRate;
 
   while (out < maxOut) {
      if (*queueLen < (int)sProcessLen) {
         // Shift pending portion to start of the buffer
         memmove(queue, &queue[*queueStart], (*queueLen) * sampleSize);
         *queueStart = 0;
 
         auto getLen = limitSampleBufferSize(
            sQueueMaxLen - *queueLen,
            backwards ? *pos - endPos : endPos - *pos
         );
 
         // Nothing to do if past end of play interval
         if (getLen > 0) {
            if (backwards) {
               auto results =
                  cache.GetFloats(*pos - (getLen - 1), getLen, mMayThrow);
               if (results)
                  memcpy(&queue[*queueLen], results, sizeof(float) * getLen);
               else
                  memset(&queue[*queueLen], 0, sizeof(float) * getLen);
 
               track->GetEnvelopeValues(mEnvValues.data(),
                  getLen, (*pos - (getLen - 1)).as_double() / trackRate);
               *pos -= getLen;
            }
            else {
               auto results = cache.GetFloats(*pos, getLen, mMayThrow);
               if (results)
                  memcpy(&queue[*queueLen], results, sizeof(float) * getLen);
               else
                  memset(&queue[*queueLen], 0, sizeof(float) * getLen);
 
               track->GetEnvelopeValues(mEnvValues.data(),
                  getLen, (*pos).as_double() / trackRate);
 
               *pos += getLen;
            }
 
            for (decltype(getLen) i = 0; i < getLen; i++) {
               queue[(*queueLen) + i] *= mEnvValues[i];
            }
 
            if (backwards)
               ReverseSamples((samplePtr)&queue[0], floatSample,
                              *queueLen, 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 / trackRate + tstep, t + tstep);
         else
            factor *= ComputeWarpFactor( *mEnvelope,
               t, t + (double)thisProcessLen / trackRate);
      }
 
      auto 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 / trackRate) * (backwards ? -1 : 1);
 
      if (last) {
         break;
      }
   }
 
   assert(out <= maxOut);
   return out;
}

References _, anonymous_namespace{MixerSource.cpp}::ComputeWarpFactor(), floatSample, i, limitSampleBufferSize(), mEnvelope, mEnvValues, min(), mInputTrack, mMayThrow, mQueueLen, mQueueStart, mRate, mResample, mSamplePos, mSampleQueue, mTimesAndSpeed, ReverseSamples(), 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 395 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 389 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 411 of file MixerSource.cpp.

{
   for (size_t j = 0; j < mnChannels; ++j) {
      mSamplePos[j] = GetChannel(j)->TimeToLongSamples(time);
      mQueueStart[j] = 0;
      mQueueLen[j] = 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 GetChannel(), MakeResamplers(), mnChannels, mQueueLen, mQueueStart, mSamplePos, and SampleTrack::TimeToLongSamples().

Here is the call graph for this function:

Terminates()

bool MixerSource::Terminates ( ) const

overridevirtual

Returns

false

Reimplemented from AudioGraph::Source.

Definition at line 401 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 61 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 275 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 95 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 101 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 128 of file MixerSource.h.

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

mInputTrack

std::vector<SampleTrackCache> MixerSource::mInputTrack

private

SampleTrackCaches are the source of data.

Definition at line 107 of file MixerSource.h.

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

mLastProduced

size_t MixerSource::mLastProduced {}

private

Definition at line 136 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 135 of file MixerSource.h.

Referenced by Acquire().

mMayThrow

const bool MixerSource::mMayThrow

private

Definition at line 102 of file MixerSource.h.

Referenced by MixSameRate(), and MixVariableRates().

mnChannels

const size_t MixerSource::mnChannels

private

Definition at line 97 of file MixerSource.h.

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

mpLeader

const std::shared_ptr<const SampleTrack> MixerSource::mpLeader

private

Definition at line 94 of file MixerSource.h.

Referenced by GetChannel().

mpMap

const ArrayOf<bool>* const MixerSource::mpMap

private

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

Definition at line 132 of file MixerSource.h.

Referenced by MixerSpec().

mQueueLen

std::vector<int> MixerSource::mQueueLen

private

For each queue, the number of available samples after the queue start.

Definition at line 122 of file MixerSource.h.

Referenced by MixVariableRates(), and Reposition().

mQueueStart

std::vector<int> MixerSource::mQueueStart

private

Position in each queue of the start of the next block to resample.

Definition at line 119 of file MixerSource.h.

Referenced by MixVariableRates(), and Reposition().

mRate

const double MixerSource::mRate

private

Definition at line 98 of file MixerSource.h.

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

mResample

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

private

Definition at line 125 of file MixerSource.h.

Referenced by MakeResamplers(), and MixVariableRates().

mResampleParameters

const ResampleParameters MixerSource::mResampleParameters

private

Definition at line 124 of file MixerSource.h.

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

mSamplePos

std::vector<sampleCount> MixerSource::mSamplePos

private

Fetch position for source.

mSamplePos holds for each track the next sample position not yet processed.

Definition at line 113 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 116 of file MixerSource.h.

Referenced by MixVariableRates().

mTimesAndSpeed

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

private

Definition at line 104 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 69 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 76 of file MixerSource.h.

Referenced by MixVariableRates().

---

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

• MixerSource.h
• MixerSource.cpp