Mixer Class Reference

Functions for doing the mixdown of the tracks. More...

#include <Mix.h>

Collaboration diagram for Mixer:

Classes
struct	Input
struct	Source

Public Types
using	WarpOptions = MixerOptions::Warp
using	MixerSpec = MixerOptions::Downmix
using	ResampleParameters = MixerOptions::ResampleParameters
using	TimesAndSpeed = MixerOptions::TimesAndSpeed
using	Stages = std::vector< MixerOptions::StageSpecification >
using	Inputs = std::vector< Input >

Public Member Functions
	Mixer (Inputs inputs, bool mayThrow, const WarpOptions &warpOptions, double startTime, double stopTime, unsigned numOutChannels, size_t outBufferSize, bool outInterleaved, double outRate, sampleFormat outFormat, bool highQuality=true, MixerSpec *mixerSpec=nullptr, bool applytTrackGains=true)
	Mixer (const Mixer &)=delete
Mixer &	operator= (const Mixer &)=delete
virtual	~Mixer ()
size_t	BufferSize () const
size_t	Process (size_t maxSamples)
size_t	Process ()
void	Reposition (double t, bool bSkipping=false)
	Reposition processing to absolute time next time Process() is called. More...
void	SetTimesAndSpeed (double t0, double t1, double speed, bool bSkipping=false)
	Used in scrubbing and other nonuniform playback policies. More...
void	SetSpeedForKeyboardScrubbing (double speed, double startTime)
double	MixGetCurrentTime ()
	Current time in seconds (unwarped, i.e. always between startTime and stopTime) More...
constSamplePtr	GetBuffer ()
	Retrieve the main buffer or the interleaved buffer. More...
constSamplePtr	GetBuffer (int channel)
	Retrieve one of the non-interleaved buffers. More...
sampleFormat	EffectiveFormat () const
	Deduce the effective width of the output, which may be narrower than the stored format. More...

Private Member Functions
void	Clear ()
std::pair< bool, sampleFormat >	NeedsDither (bool needsDither, double rate) const

Private Attributes
const unsigned	mNumChannels
Inputs	mInputs
const size_t	mBufferSize
const bool	mApplyTrackGains
const bool	mHighQuality
const sampleFormat	mFormat
const bool	mInterleaved
sampleFormat	mEffectiveFormat
bool	mNeedsDither
const std::shared_ptr< TimesAndSpeed >	mTimesAndSpeed
AudioGraph::Buffers	mFloatBuffers
std::vector< std::vector< float > >	mTemp
const std::vector< SampleBuffer >	mBuffer
std::vector< MixerSource >	mSources
std::vector< EffectSettings >	mSettings
std::vector< AudioGraph::Buffers >	mStageBuffers
std::vector< std::unique_ptr< EffectStage > >	mStages
std::vector< Source >	mDecoratedSources

Detailed Description

Functions for doing the mixdown of the tracks.

Definition at line 27 of file Mix.h.

Member Typedef Documentation

Inputs

using Mixer::Inputs = std::vector<Input>

Definition at line 45 of file Mix.h.

MixerSpec

using Mixer::MixerSpec = MixerOptions::Downmix

Definition at line 30 of file Mix.h.

ResampleParameters

using Mixer::ResampleParameters = MixerOptions::ResampleParameters

Definition at line 31 of file Mix.h.

Stages

using Mixer::Stages = std::vector<MixerOptions::StageSpecification>

Definition at line 33 of file Mix.h.

TimesAndSpeed

using Mixer::TimesAndSpeed = MixerOptions::TimesAndSpeed

Definition at line 32 of file Mix.h.

WarpOptions

using Mixer::WarpOptions = MixerOptions::Warp

Definition at line 29 of file Mix.h.

Constructor & Destructor Documentation

Mixer() [1/2]

Mixer::Mixer	(	Inputs	inputs,
		bool	mayThrow,
		const WarpOptions &	warpOptions,
		double	startTime,
		double	stopTime,
		unsigned	numOutChannels,
		size_t	outBufferSize,
		bool	outInterleaved,
		double	outRate,
		sampleFormat	outFormat,
		bool	highQuality = true,
		MixerSpec *	mixerSpec = nullptr,
		bool	applytTrackGains = true
	)

Precondition

all sequences in inputs are non-null

any left channels in inputs are immediately followed by their partners

Postcondition

BufferSize() <= outBufferSize (equality when no inputs have stages)

Parameters

mixerSpec

Null or else must have a lifetime enclosing this object's

Definition at line 71 of file Mix.cpp.

   : mNumChannels{ numOutChannels }
   , mInputs{ move(inputs) }
   , mBufferSize{ FindBufferSize(mInputs, outBufferSize) }
   , mApplyTrackGains{ applyTrackGains }
   , mHighQuality{ highQuality }
   , mFormat{ outFormat }
   , mInterleaved{ outInterleaved }
 
   , mTimesAndSpeed{ std::make_shared<TimesAndSpeed>( TimesAndSpeed{
      startTime, stopTime, warpOptions.initialSpeed, startTime
   } ) }
 
   // PRL:  Bug2536: see other comments below for the last, padding argument
   // TODO: more-than-two-channels
   // Issue 3565 workaround:  allocate one extra buffer when applying a
   // GVerb effect stage.  It is simply discarded
   // See also issue 3854, when the number of out channels expected by the
   // plug-in is yet larger
   , mFloatBuffers{ 3, mBufferSize, 1, 1 }
 
   // non-interleaved
   , mTemp{ initVector<float>(mNumChannels, mBufferSize) }
   , mBuffer{ initVector<SampleBuffer>(mInterleaved ? 1 : mNumChannels,
      [format = mFormat,
         size = mBufferSize * (mInterleaved ? mNumChannels : 1)
      ](auto &buffer){ buffer.Allocate(size, format); }
   )}
   , mEffectiveFormat{ floatSample }
{
   assert(BufferSize() <= outBufferSize);
   const auto nChannelsIn =
   std::accumulate(mInputs.begin(), mInputs.end(), size_t{},
      [](auto sum, const auto &input){
         return sum + input.pSequence->NChannels(); });
 
   // Examine the temporary instances that were made in FindBufferSize
   // This finds a sufficient, but not necessary, condition to do dithering
   bool needsDither = std::any_of(mInputs.begin(), mInputs.end(),
      [](const Input &input){
         return std::any_of(input.stages.begin(), input.stages.end(),
            [](const MixerOptions::StageSpecification &spec){
               return spec.mpFirstInstance &&
                  spec.mpFirstInstance->NeedsDither(); } ); } );
 
   auto pMixerSpec = ( mixerSpec &&
      mixerSpec->GetNumChannels() == mNumChannels &&
      mixerSpec->GetNumTracks() == nChannelsIn
   ) ? mixerSpec : nullptr;
 
   // Reserve vectors first so we can take safe references to pushed elements
   mSources.reserve(nChannelsIn);
   const auto nStages = std::accumulate(mInputs.begin(), mInputs.end(), 0,
      [](auto sum, const auto &input){
         return sum + input.stages.size() * input.pSequence->NChannels(); });
   mSettings.reserve(nStages);
   mStageBuffers.reserve(nStages);
 
   size_t i = 0;
   for (auto &input : mInputs) {
      const auto &sequence = input.pSequence;
      if (!sequence) {
         assert(false);
         break;
      }
      auto increment = finally([&]{ i += sequence->NChannels(); });
 
      auto &source = mSources.emplace_back(sequence, BufferSize(), outRate,
         warpOptions, highQuality, mayThrow, mTimesAndSpeed,
         (pMixerSpec ? &pMixerSpec->mMap[i] : nullptr));
      AudioGraph::Source *pDownstream = &source;
      for (const auto &stage : input.stages) {
         // Make a mutable copy of stage.settings
         auto &settings = mSettings.emplace_back(stage.settings);
         // TODO: more-than-two-channels
         // Like mFloatBuffers but padding not needed for soxr
         // Allocate one extra buffer to hold dummy zero inputs
         // (Issue 3854)
         auto &stageInput = mStageBuffers.emplace_back(3, mBufferSize, 1);
         const auto &factory = [&stage]{
            // Avoid unnecessary repeated calls to the factory
            return stage.mpFirstInstance
               ? move(stage.mpFirstInstance)
               : stage.factory();
         };
         auto &pNewDownstream =
         mStages.emplace_back(EffectStage::Create(-1,
            *pDownstream, stageInput,
            factory, settings, outRate, std::nullopt, *sequence
         ));
         if (pNewDownstream)
            pDownstream = pNewDownstream.get();
         else {
            // Just omit the failed stage from rendering
            // TODO propagate the error?
            mStageBuffers.pop_back();
            mSettings.pop_back();
         }
      }
      mDecoratedSources.emplace_back(Source{ source, *pDownstream });
   }
 
   // Decide once at construction time
   std::tie(mNeedsDither, mEffectiveFormat) = NeedsDither(needsDither, outRate);
}

References anonymous_namespace{ExportPCM.cpp}::format, and size.

Mixer() [2/2]

Mixer::Mixer ( const Mixer &  )

delete

~Mixer()

Mixer::~Mixer ( )

virtual

Definition at line 185 of file Mix.cpp.

{
}

Member Function Documentation

BufferSize()

size_t Mixer::BufferSize ( ) const

inline

Definition at line 72 of file Mix.h.

{ return mBufferSize; }

Referenced by Process().

Here is the caller graph for this function:

Clear()

void Mixer::Clear ( )

private

Definition at line 248 of file Mix.cpp.

{
   for (auto &buffer: mTemp)
      std::fill(buffer.begin(), buffer.end(), 0);
}

References mTemp.

Referenced by Process().

Here is the caller graph for this function:

EffectiveFormat()

sampleFormat Mixer::EffectiveFormat

(

)

const

Deduce the effective width of the output, which may be narrower than the stored format.

Definition at line 385 of file Mix.cpp.

{
   return mEffectiveFormat;
}

References mEffectiveFormat.

Referenced by MixAndRender().

Here is the caller graph for this function:

GetBuffer() [1/2]

constSamplePtr Mixer::GetBuffer

(

)

Retrieve the main buffer or the interleaved buffer.

Definition at line 375 of file Mix.cpp.

{
   return mBuffer[0].ptr();
}

References mBuffer.

Referenced by MixAndRender().

Here is the caller graph for this function:

GetBuffer() [2/2]

constSamplePtr Mixer::GetBuffer

(

int

channel

)

Retrieve one of the non-interleaved buffers.

Definition at line 380 of file Mix.cpp.

{
   return mBuffer[channel].ptr();
}

References mBuffer.

MixGetCurrentTime()

double Mixer::MixGetCurrentTime

(

)

Current time in seconds (unwarped, i.e. always between startTime and stopTime)

This value is not accurate, it's useful for progress bars and indicators, but nothing else.

Definition at line 390 of file Mix.cpp.

{
   return mTimesAndSpeed->mTime;
}

References mTimesAndSpeed.

Referenced by anonymous_namespace{ExportPluginHelpers.cpp}::EvalExportProgress(), and MixAndRender().

Here is the caller graph for this function:

NeedsDither()

std::pair< bool, sampleFormat > Mixer::NeedsDither ( bool  needsDither, double  rate  ) const

private

TODO: more-than-two-channels

Definition at line 190 of file Mix.cpp.

{
   // This will accumulate the widest effective format of any input
   // clip
   auto widestEffectiveFormat = narrowestSampleFormat;
 
   // needsDither may already be given as true.
   // There are many other possible disqualifiers for the avoidance of dither.
   if (std::any_of(mSources.begin(), mSources.end(),
      std::mem_fn(&MixerSource::VariableRates))
   )
      // We will call MixVariableRates(), so we need nontrivial resampling
      needsDither = true;
 
   for (const auto &input : mInputs) {
      auto &pSequence = input.pSequence;
      if (!pSequence)
         continue;
      auto &sequence = *pSequence;
      if (sequence.GetRate() != rate)
         // Also leads to MixVariableRates(), needs nontrivial resampling
         needsDither = true;
      if (mApplyTrackGains) {
         for (auto c : {0, 1}) {
            const auto gain = sequence.GetChannelGain(c);
            if (!(gain == 0.0 || gain == 1.0))
               // Fractional gain may be applied even in MixSameRate
               needsDither = true;
         }
      }
 
      // Examine all tracks.  (This ignores the time bounds for the mixer.
      // If it did not, we might avoid dither in more cases.  But if we fix
      // that, remember that some mixers change their time bounds after
      // construction, as when scrubbing.)
      if (!sequence.HasTrivialEnvelope())
         // Varying or non-unit gain may be applied even in MixSameRate
         needsDither = true;
      auto effectiveFormat = sequence.WidestEffectiveFormat();
      if (effectiveFormat > mFormat)
         // Real, not just nominal, precision loss would happen in at
         // least one clip
         needsDither = true;
      widestEffectiveFormat =
         std::max(widestEffectiveFormat, effectiveFormat);
   }
 
   if (needsDither)
      // Results will be dithered to width mFormat
      return { true, mFormat };
   else {
      // Results will not be dithered
      assert(widestEffectiveFormat <= mFormat);
      return { false, widestEffectiveFormat };
   }
}

References mApplyTrackGains, mFormat, mInputs, mSources, narrowestSampleFormat, and MixerSource::VariableRates().

Here is the call graph for this function:

operator=()

Mixer & Mixer::operator= ( const Mixer &  )

delete

Process() [1/2]

size_t Mixer::Process ( )

inline

Postcondition

result: result <= BufferSize()

Definition at line 91 of file Mix.h.

{ return Process(BufferSize()); }

References BufferSize, and Process().

Referenced by Process().

Here is the call graph for this function:

Here is the caller graph for this function:

Process() [2/2]

size_t Mixer::Process

(

size_t

maxSamples

)

Process a maximum of 'maxSamples' samples and put them into the buffer, at GetBuffer().

Precondition

maxSamples <= BufferSize()

Postcondition

result: result <= maxSamples

Returns

number of output samples, or 0, if there are no more samples that must be processed.

Definition at line 271 of file Mix.cpp.

{
   assert(maxToProcess <= BufferSize());
 
   // MB: this is wrong! mT represented warped time, and mTime is too inaccurate to use
   // it here. It's also unnecessary I think.
   //if (mT >= mT1)
   //   return 0;
 
   size_t maxOut = 0;
   const auto channelFlags = stackAllocate(unsigned char, mNumChannels);
   const auto gains = stackAllocate(float, mNumChannels);
   if (!mApplyTrackGains)
      std::fill(gains, gains + mNumChannels, 1.0f);
 
   // Decides which output buffers an input channel accumulates into
   auto findChannelFlags = [&channelFlags, numChannels = mNumChannels]
   (const bool *map, const WideSampleSequence &sequence, size_t iChannel){
      const auto end = channelFlags + numChannels;
      std::fill(channelFlags, end, 0);
      if (map)
         // ignore left and right when downmixing is customized
         std::copy(map, map + numChannels, channelFlags);
      else if (IsMono(sequence))
         std::fill(channelFlags, end, 1);
      else if (iChannel == 0)
         channelFlags[0] = 1;
      else if (iChannel == 1) {
         if (numChannels >= 2)
            channelFlags[1] = 1;
         else
            channelFlags[0] = 1;
      }
      return channelFlags;
   };
 
   auto &[mT0, mT1, _, mTime] = *mTimesAndSpeed;
   auto oldTime = mTime;
   // backwards (as possibly in scrubbing)
   const auto backwards = (mT0 > mT1);
 
   Clear();
   // TODO: more-than-two-channels
   auto maxChannels = std::max(2u, mFloatBuffers.Channels());
 
   for (auto &[ upstream, downstream ] : mDecoratedSources) {
      auto oResult = downstream.Acquire(mFloatBuffers, maxToProcess);
      // One of MixVariableRates or MixSameRate assigns into mTemp[*][*] which
      // are the sources for the CopySamples calls, and they copy into
      // mBuffer[*][*]
      if (!oResult)
         return 0;
      auto result = *oResult;
      maxOut = std::max(maxOut, result);
 
      // Insert effect stages here!  Passing them all channels of the track
 
      const auto limit = std::min<size_t>(upstream.Channels(), maxChannels);
      for (size_t j = 0; j < limit; ++j) {
         const auto pFloat = (const float *)mFloatBuffers.GetReadPosition(j);
         auto &sequence = upstream.GetSequence();
         if (mApplyTrackGains) {
            for (size_t c = 0; c < mNumChannels; ++c) {
               if (mNumChannels > 1)
                  gains[c] = sequence.GetChannelGain(c);
               else
                  gains[c] = sequence.GetChannelGain(j);
            }
         }
         const auto flags =
            findChannelFlags(upstream.MixerSpec(j), sequence, j);
         MixBuffers(mNumChannels, flags, gains, *pFloat, mTemp, result);
      }
 
      downstream.Release();
      mFloatBuffers.Advance(result);
      mFloatBuffers.Rotate();
   }
 
   if (backwards)
      mTime = std::clamp(mTime, mT1, oldTime);
   else
      mTime = std::clamp(mTime, oldTime, mT1);
 
   const auto dstStride = (mInterleaved ? mNumChannels : 1);
   auto ditherType = mNeedsDither
      ? (mHighQuality ? gHighQualityDither : gLowQualityDither)
      : DitherType::none;
   for (size_t c = 0; c < mNumChannels; ++c)
      CopySamples((constSamplePtr)mTemp[c].data(), floatSample,
         (mInterleaved
            ? mBuffer[0].ptr() + (c * SAMPLE_SIZE(mFormat))
            : mBuffer[c].ptr()
         ),
         mFormat, maxOut, ditherType,
         1, dstStride);
 
   // MB: this doesn't take warping into account, replaced with code based on mSamplePos
   //mT += (maxOut / mRate);
 
   assert(maxOut <= maxToProcess);
   return maxOut;
}

References _, AudioGraph::Buffers::Advance(), BufferSize(), AudioGraph::Buffers::Channels(), Clear(), staffpad::vo::copy(), CopySamples(), PackedArray::end(), floatSample, AudioGraph::Buffers::GetReadPosition(), gHighQualityDither, gLowQualityDither, anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel, AudioGraph::IsMono(), mApplyTrackGains, mBuffer, mDecoratedSources, mFloatBuffers, mFormat, mHighQuality, mInterleaved, MixBuffers(), mNeedsDither, mNumChannels, mTemp, mTimesAndSpeed, none, AudioGraph::Buffers::Rotate(), SAMPLE_SIZE, and stackAllocate.

Referenced by MixAndRender().

Here is the call graph for this function:

Here is the caller graph for this function:

Reposition()

void Mixer::Reposition	(	double	t,
		bool	bSkipping = false
	)

Reposition processing to absolute time next time Process() is called.

Definition at line 395 of file Mix.cpp.

{
   const auto &[mT0, mT1, _, __] = *mTimesAndSpeed;
   auto &mTime = mTimesAndSpeed->mTime;
   mTime = t;
   const bool backwards = (mT1 < mT0);
   if (backwards)
      mTime = std::clamp(mTime, mT1, mT0);
   else
      mTime = std::clamp(mTime, mT0, mT1);
 
   for (auto &source : mSources)
      source.Reposition(mTime, bSkipping);
}

References _, mSources, and mTimesAndSpeed.

Referenced by SetSpeedForKeyboardScrubbing(), and SetTimesAndSpeed().

Here is the caller graph for this function:

SetSpeedForKeyboardScrubbing()

void Mixer::SetSpeedForKeyboardScrubbing	(	double	speed,
		double	startTime
	)

Definition at line 420 of file Mix.cpp.

{
   wxASSERT(std::isfinite(speed));
   auto &[mT0, mT1, mSpeed, _] = *mTimesAndSpeed;
 
   // Check if the direction has changed
   if ((speed > 0.0 && mT1 < mT0) || (speed < 0.0 && mT1 > mT0)) {
      // It's safe to use 0 and std::numeric_limits<double>::max(),
      // because Mixer::MixVariableRates() doesn't sample past the start
      // or end of the audio in a track.
      if (speed > 0.0 && mT1 < mT0) {
         mT0 = 0;
         mT1 = std::numeric_limits<double>::max();
      }
      else {
         mT0 = std::numeric_limits<double>::max();
         mT1 = 0;
      }
 
      Reposition(startTime, true);
   }
 
   mSpeed = fabs(speed);
}

References _, mTimesAndSpeed, and Reposition().

Here is the call graph for this function:

SetTimesAndSpeed()

void Mixer::SetTimesAndSpeed	(	double	t0,
		double	t1,
		double	speed,
		bool	bSkipping = false
	)

Used in scrubbing and other nonuniform playback policies.

Definition at line 410 of file Mix.cpp.

{
   wxASSERT(std::isfinite(speed));
   auto &[mT0, mT1, mSpeed, _] = *mTimesAndSpeed;
   mT0 = t0;
   mT1 = t1;
   mSpeed = fabs(speed);
   Reposition(t0, bSkipping);
}

References _, mTimesAndSpeed, and Reposition().

Here is the call graph for this function:

Member Data Documentation

mApplyTrackGains

const bool Mixer::mApplyTrackGains

private

Definition at line 133 of file Mix.h.

Referenced by NeedsDither(), and Process().

mBuffer

const std::vector<SampleBuffer> Mixer::mBuffer

private

Definition at line 155 of file Mix.h.

Referenced by GetBuffer(), and Process().

mBufferSize

const size_t Mixer::mBufferSize

private

Definition at line 125 of file Mix.h.

mDecoratedSources

std::vector<Source> Mixer::mDecoratedSources

private

Definition at line 163 of file Mix.h.

Referenced by Process().

mEffectiveFormat

sampleFormat Mixer::mEffectiveFormat

private

Definition at line 139 of file Mix.h.

Referenced by EffectiveFormat().

mFloatBuffers

AudioGraph::Buffers Mixer::mFloatBuffers

private

Definition at line 147 of file Mix.h.

Referenced by Process().

mFormat

const sampleFormat Mixer::mFormat

private

Definition at line 135 of file Mix.h.

Referenced by NeedsDither(), and Process().

mHighQuality

const bool Mixer::mHighQuality

private

Definition at line 134 of file Mix.h.

Referenced by Process().

mInputs

Inputs Mixer::mInputs

private

Definition at line 122 of file Mix.h.

Referenced by NeedsDither().

mInterleaved

const bool Mixer::mInterleaved

private

Definition at line 136 of file Mix.h.

Referenced by Process().

mNeedsDither

bool Mixer::mNeedsDither

private

Definition at line 140 of file Mix.h.

Referenced by Process().

mNumChannels

const unsigned Mixer::mNumChannels

private

Definition at line 121 of file Mix.h.

Referenced by Process().

mSettings

std::vector<EffectSettings> Mixer::mSettings

private

Definition at line 158 of file Mix.h.

mSources

std::vector<MixerSource> Mixer::mSources

private

Definition at line 157 of file Mix.h.

Referenced by NeedsDither(), and Reposition().

mStageBuffers

std::vector<AudioGraph::Buffers> Mixer::mStageBuffers

private

Definition at line 159 of file Mix.h.

mStages

std::vector<std::unique_ptr<EffectStage> > Mixer::mStages

private

Definition at line 160 of file Mix.h.

mTemp

std::vector<std::vector<float> > Mixer::mTemp

private

Definition at line 152 of file Mix.h.

Referenced by Clear(), and Process().

mTimesAndSpeed

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

private

Definition at line 142 of file Mix.h.

Referenced by MixGetCurrentTime(), Process(), Reposition(), SetSpeedForKeyboardScrubbing(), and SetTimesAndSpeed().

---

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

• Mix.h
• Mix.cpp