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

#include <Mix.h>

Inheritance diagram for Mixer:

Collaboration diagram for Mixer:

Classes
struct	Input

struct	Source

Public Types
enum class	ApplyGain { Discard , MapChannels , Mixdown }

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 Types inherited from AudioGraph::Source
using	Buffers = AudioGraph::Buffers

Public Member Functions
	Mixer (Inputs inputs, std::optional< Stages > masterEffects, 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, ApplyGain applyGain=ApplyGain::MapChannels)

	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...

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	Clear ()

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...

std::unique_ptr< EffectStage > &	RegisterEffectStage (AudioGraph::Source &upstream, const MixerOptions::StageSpecification &stage, double outRate)

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

Private Attributes
const unsigned	mNumChannels

Inputs	mInputs

const std::optional< Stages >	mMasterEffects

const size_t	mBufferSize

const ApplyGain	mApplyGain

const bool	mHighQuality

const sampleFormat	mFormat

const bool	mInterleaved

sampleFormat	mEffectiveFormat

bool	mNeedsDither

bool	mHasMixerSpec {false}

const std::shared_ptr< TimesAndSpeed >	mTimesAndSpeed

AudioGraph::Buffers	mFloatBuffers

AudioGraph::Buffers	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< AudioGraph::Source * >	mMasterStages

std::vector< Source >	mDecoratedSources

Detailed Description

Functions for doing the mixdown of the tracks.

Definition at line 28 of file Mix.h.

Member Typedef Documentation

◆ Inputs

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

Definition at line 47 of file Mix.h.

◆ MixerSpec

using Mixer::MixerSpec = MixerOptions::Downmix

Definition at line 32 of file Mix.h.

◆ ResampleParameters

using Mixer::ResampleParameters = MixerOptions::ResampleParameters

Definition at line 33 of file Mix.h.

◆ Stages

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

Definition at line 35 of file Mix.h.

◆ TimesAndSpeed

using Mixer::TimesAndSpeed = MixerOptions::TimesAndSpeed

Definition at line 34 of file Mix.h.

◆ WarpOptions

using Mixer::WarpOptions = MixerOptions::Warp

Definition at line 31 of file Mix.h.

Member Enumeration Documentation

◆ ApplyGain

enum class Mixer::ApplyGain

strong

Enumerator
Discard
MapChannels
Mixdown

Definition at line 49 of file Mix.h.

   {
      Discard,//< No source gain is applied
      MapChannels, //< Apply gains per source's channel
      Mixdown, //< Average gains from all channels in the source, numOutChannels should be 1
   };

Constructor & Destructor Documentation

◆ Mixer() [1/2]

Mixer::Mixer	(	Inputs	inputs,
		std::optional< Stages >	masterEffects,
		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`,
		ApplyGain	applyGain = `ApplyGain::MapChannels`
	)

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 83 of file Mix.cpp.

    : mNumChannels { numOutChannels }
    , mInputs { move(inputs) }
    , mMasterEffects { move(masterEffects) }
    , mBufferSize { FindBufferSize(mInputs, mMasterEffects, outBufferSize) }
    , mApplyGain { applyGain }
    , 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 { mNumChannels, mBufferSize, 1, 1 }
    , 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(); } ); } );
   if (mMasterEffects)
      needsDither |= std::any_of(
         mMasterEffects->begin(), mMasterEffects->end(),
         [](const MixerOptions::StageSpecification& spec) {
            return spec.mpFirstInstance && spec.mpFirstInstance->NeedsDither();
         });
 
   auto pMixerSpec = ( mixerSpec &&
      mixerSpec->GetNumChannels() == mNumChannels &&
      mixerSpec->GetNumTracks() == nChannelsIn
   ) ? mixerSpec : nullptr;
   mHasMixerSpec = pMixerSpec != nullptr;
 
   // Reserve vectors first so we can take safe references to pushed elements
   mSources.reserve(nChannelsIn);
   // One stereo-capable stage per effect.
   const auto nMasterStages = mMasterEffects ? mMasterEffects->size() : 0;
   const auto nStages =
      std::accumulate(
         mInputs.begin(), mInputs.end(), 0,
         [](auto sum, const auto& input) {
            return sum + input.stages.size() * input.pSequence->NChannels();
         }) +
      nMasterStages;
   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)
         if (
            auto& pNewDownstream =
               RegisterEffectStage(*pDownstream, stage, outRate))
         {
            pDownstream = pNewDownstream.get();
         }
      mDecoratedSources.emplace_back(Source{ source, *pDownstream });
   }
 
   if (mMasterEffects)
   {
      AudioGraph::Source* pDownstream = this;
      for (const auto& stage : *mMasterEffects)
         if (
            auto& pNewDownstream =
               RegisterEffectStage(*pDownstream, stage, outRate))
         {
            mMasterStages.emplace_back(pDownstream = pNewDownstream.get());
         }
   }
 
   // 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 ( )

virtualdefault

Member Function Documentation

◆ AcceptsBlockSize()

bool Mixer::AcceptsBlockSize ( size_t blockSize ) const

overrideprivatevirtual

Implements AudioGraph::Source.

Definition at line 413 of file Mix.cpp.

{
   return blockSize <= BufferSize();
}

References BufferSize().

Referenced by AcceptsBuffers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AcceptsBuffers()

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

overrideprivatevirtual

Implements AudioGraph::Source.

Definition at line 407 of file Mix.cpp.

{
   return buffers.Channels() == mNumChannels &&
          AcceptsBlockSize(buffers.BlockSize());
}

References AcceptsBlockSize(), AudioGraph::Buffers::BlockSize(), AudioGraph::Buffers::Channels(), and mNumChannels.

Here is the call graph for this function:

◆ Acquire()

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

overrideprivatevirtual

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 432 of file Mix.cpp.

{
   // TODO: more-than-two-channels
   auto maxChannels = std::max(2u, mFloatBuffers.Channels());
   const auto channelFlags = stackAllocate(unsigned char, mNumChannels);
   const auto gains = stackAllocate(float, mNumChannels);
   if (mApplyGain == ApplyGain::Discard)
      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;
   };
 
   size_t maxOut = 0;
   for (auto c = 0;c < data.Channels(); ++c)
      data.ClearBuffer(c, maxToProcess);
 
   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;
      const 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 (mApplyGain != ApplyGain::Discard)
         {
            for (size_t c = 0; c < mNumChannels; ++c)
            {
               if (mNumChannels > 1)
                  gains[c] = sequence.GetChannelGain(c);
               else
                  gains[c] = sequence.GetChannelGain(j);
            }
            if (
               mApplyGain == ApplyGain::Mixdown && !mHasMixerSpec &&
               mNumChannels == 1)
               gains[0] /= static_cast<float>(limit);
         }
 
         const auto flags =
            findChannelFlags(upstream.MixerSpec(j), sequence, j);
         MixBuffers(mNumChannels, flags, gains, *pFloat, data, result);
      }
 
      downstream.Release();
      mFloatBuffers.Advance(result);
      mFloatBuffers.Rotate();
   }
 
   // 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(), AudioGraph::Buffers::Channels(), AudioGraph::Buffers::ClearBuffer(), staffpad::vo::copy(), Discard, details::end(), AudioGraph::Buffers::GetReadPosition(), anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel, AudioGraph::IsMono(), mApplyGain, mDecoratedSources, mFloatBuffers, mHasMixerSpec, MixBuffers(), Mixdown, mNumChannels, AudioGraph::Buffers::Rotate(), and stackAllocate.

Referenced by Process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BufferSize()

size_t Mixer::BufferSize ( ) const

inline

Definition at line 80 of file Mix.h.

80{ return mBufferSize; }

Referenced by AcceptsBlockSize(), and Process().

Here is the caller graph for this function:

◆ Clear()

void Mixer::Clear ( )

private

Definition at line 262 of file Mix.cpp.

{
   for (auto c = 0; c < mTemp.Channels(); ++c)
      mTemp.ClearBuffer(c, mBufferSize);
}

References AudioGraph::Buffers::Channels(), AudioGraph::Buffers::ClearBuffer(), mBufferSize, and mTemp.

Referenced by Process().

Here is the call graph for this function:

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 347 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 337 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 342 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 352 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 201 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 : mSources) {
      auto &sequence = input.GetSequence();
 
      if (sequence.GetRate() != rate)
         // Also leads to MixVariableRates(), needs nontrivial resampling
         needsDither = true;
      else if (mApplyGain == ApplyGain::Mixdown &&
         !mHasMixerSpec &&
         sequence.NChannels() > 1 && mNumChannels == 1)
      {
         needsDither = true;
      }
      else if (mApplyGain != ApplyGain::Discard) {
         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 Discard, mApplyGain, mFormat, mHasMixerSpec, Mixdown, mNumChannels, 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 99 of file Mix.h.

99{ return Process(BufferSize()); }

Mixer::Process

size_t Process()

Definition: Mix.h:99

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 284 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;
 
   auto &[mT0, mT1, _, mTime] = *mTimesAndSpeed;
   auto oldTime = mTime;
   // backwards (as possibly in scrubbing)
   const auto backwards = (mT0 > mT1);
 
   Clear();
 
   std::optional<size_t> maxOut;
   if (mMasterStages.empty())
      maxOut = Acquire(mTemp, maxToProcess);
   else
   {
      const auto stage = mMasterStages.back();
      maxOut = stage->Acquire(mTemp, maxToProcess);
      stage->Release();
   }
   if (!maxOut)
      return 0;
 
   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(mTemp.GetReadPosition(c), 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 _, Acquire(), BufferSize(), Clear(), CopySamples(), floatSample, AudioGraph::Buffers::GetReadPosition(), gHighQualityDither, gLowQualityDither, mBuffer, mFormat, mHighQuality, mInterleaved, mMasterStages, mNeedsDither, mNumChannels, mTemp, mTimesAndSpeed, none, and SAMPLE_SIZE.

Referenced by MixAndRender().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RegisterEffectStage()

std::unique_ptr< EffectStage > & Mixer::RegisterEffectStage	(	AudioGraph::Source &	upstream,
		const MixerOptions::StageSpecification &	stage,
		double	outRate
	)

private

Definition at line 516 of file Mix.cpp.

{
   // 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, mNumChannels, upstream, stageInput, factory, settings, outRate,
      std::nullopt));
   if (!pNewDownstream)
   {
      // Just omit the failed stage from rendering
      // TODO propagate the error?
      mStageBuffers.pop_back();
      mSettings.pop_back();
   }
   return pNewDownstream;
}

References EffectStage::Create(), MixerOptions::StageSpecification::factory, factory, mBufferSize, mNumChannels, MixerOptions::StageSpecification::mpFirstInstance, mSettings, mStageBuffers, mStages, MixerOptions::StageSpecification::settings, and settings().

Here is the call graph for this function:

◆ Release()

bool Mixer::Release ( )

overrideprivatevirtual

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 427 of file Mix.cpp.

{
   return true;
}

◆ Remaining()

sampleCount Mixer::Remaining ( ) const

overrideprivatevirtual

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 418 of file Mix.cpp.

{
   return std::accumulate(
      mDecoratedSources.begin(), mDecoratedSources.end(), sampleCount { 0 },
      [](sampleCount sum, const Source& source) {
         return std::max(sum, source.downstream.Remaining());
      });
}

References mDecoratedSources.

◆ Reposition()

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

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

Definition at line 357 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 382 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 372 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

◆ mApplyGain

const ApplyGain Mixer::mApplyGain

private

Definition at line 153 of file Mix.h.

Referenced by Acquire(), and NeedsDither().

◆ mBuffer

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

private

Definition at line 176 of file Mix.h.

Referenced by GetBuffer(), and Process().

◆ mBufferSize

const size_t Mixer::mBufferSize

private

Definition at line 145 of file Mix.h.

Referenced by Clear(), and RegisterEffectStage().

◆ mDecoratedSources

std::vector<Source> Mixer::mDecoratedSources

private

Definition at line 185 of file Mix.h.

Referenced by Acquire(), and Remaining().

◆ mEffectiveFormat

sampleFormat Mixer::mEffectiveFormat

private

Definition at line 159 of file Mix.h.

Referenced by EffectiveFormat().

◆ mFloatBuffers

AudioGraph::Buffers Mixer::mFloatBuffers

private

Definition at line 168 of file Mix.h.

Referenced by Acquire().

◆ mFormat

const sampleFormat Mixer::mFormat

private

Definition at line 155 of file Mix.h.

Referenced by NeedsDither(), and Process().

◆ mHasMixerSpec

bool Mixer::mHasMixerSpec {false}

private

Definition at line 161 of file Mix.h.

Referenced by Acquire(), and NeedsDither().

◆ mHighQuality

const bool Mixer::mHighQuality

private

Definition at line 154 of file Mix.h.

Referenced by Process().

◆ mInputs

Inputs Mixer::mInputs

private

Definition at line 141 of file Mix.h.

◆ mInterleaved

const bool Mixer::mInterleaved

private

Definition at line 156 of file Mix.h.

Referenced by Process().

◆ mMasterEffects

const std::optional<Stages> Mixer::mMasterEffects

private

Definition at line 142 of file Mix.h.

◆ mMasterStages

std::vector<AudioGraph::Source*> Mixer::mMasterStages

private

Definition at line 182 of file Mix.h.

Referenced by Process().

◆ mNeedsDither

bool Mixer::mNeedsDither

private

Definition at line 160 of file Mix.h.

Referenced by Process().

◆ mNumChannels

const unsigned Mixer::mNumChannels

private

Definition at line 140 of file Mix.h.

Referenced by AcceptsBuffers(), Acquire(), NeedsDither(), Process(), and RegisterEffectStage().

◆ mSettings

std::vector<EffectSettings> Mixer::mSettings

private

Definition at line 179 of file Mix.h.

Referenced by RegisterEffectStage().

◆ mSources

std::vector<MixerSource> Mixer::mSources

private

Definition at line 178 of file Mix.h.

Referenced by NeedsDither(), and Reposition().

◆ mStageBuffers

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

private

Definition at line 180 of file Mix.h.

Referenced by RegisterEffectStage().

◆ mStages

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

private

Definition at line 181 of file Mix.h.

Referenced by RegisterEffectStage().

◆ mTemp

AudioGraph::Buffers Mixer::mTemp

private

Definition at line 173 of file Mix.h.

Referenced by Clear(), and Process().

◆ mTimesAndSpeed

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

private

Definition at line 163 of file Mix.h.

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

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

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Inputs

◆ MixerSpec

◆ ResampleParameters

◆ Stages

◆ TimesAndSpeed

◆ WarpOptions

Member Enumeration Documentation

◆ ApplyGain

Constructor & Destructor Documentation

◆ Mixer() [1/2]

◆ Mixer() [2/2]

◆ ~Mixer()

Member Function Documentation

◆ AcceptsBlockSize()

◆ AcceptsBuffers()

◆ Acquire()

◆ BufferSize()

◆ Clear()

◆ EffectiveFormat()

◆ GetBuffer() [1/2]

◆ GetBuffer() [2/2]

◆ MixGetCurrentTime()

◆ NeedsDither()

◆ operator=()

◆ Process() [1/2]

◆ Process() [2/2]

◆ RegisterEffectStage()

◆ Release()

◆ Remaining()

◆ Reposition()

◆ SetSpeedForKeyboardScrubbing()

◆ SetTimesAndSpeed()

Member Data Documentation

◆ mApplyGain

◆ mBuffer

◆ mBufferSize

◆ mDecoratedSources

◆ mEffectiveFormat

◆ mFloatBuffers

◆ mFormat

◆ mHasMixerSpec

◆ mHighQuality

◆ mInputs

◆ mInterleaved

◆ mMasterEffects

◆ mMasterStages

◆ mNeedsDither

◆ mNumChannels

◆ mSettings

◆ mSources

◆ mStageBuffers

◆ mStages

◆ mTemp

◆ mTimesAndSpeed