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

#include <Mix.h>

Collaboration diagram for Mixer:

Classes
struct	Input

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 >

using	ApplyVolume = DownmixStage::ApplyVolume

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, ApplyVolume applyVolume=ApplyVolume::MapChannels)

	Mixer (const Mixer &)=delete

	Mixer (Mixer &&) noexcept=delete

Mixer &	operator= (const Mixer &)=delete

Mixer &	operator= (Mixer &&) noexcept=delete

	~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::unique_ptr< EffectStage > &	RegisterEffectStage (AudioGraph::Source &upstream, size_t numChannels, 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 ApplyVolume	mApplyVolume

const bool	mHighQuality

const sampleFormat	mFormat

const bool	mInterleaved

sampleFormat	mEffectiveFormat

bool	mNeedsDither

bool	mHasMixerSpec {false}

const std::shared_ptr< TimesAndSpeed >	mTimesAndSpeed

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::unique_ptr< AudioGraph::Source >	mDownmixStage

std::unique_ptr< AudioGraph::Source >	mMasterDownmixStage

AudioGraph::Source *	mDownstream {}

Detailed Description

Functions for doing the mixdown of the tracks.

Definition at line 30 of file Mix.h.

Member Typedef Documentation

◆ ApplyVolume

using Mixer::ApplyVolume = DownmixStage::ApplyVolume

Definition at line 51 of file Mix.h.

◆ Inputs

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

Definition at line 49 of file Mix.h.

◆ MixerSpec

using Mixer::MixerSpec = MixerOptions::Downmix

Definition at line 34 of file Mix.h.

◆ ResampleParameters

using Mixer::ResampleParameters = MixerOptions::ResampleParameters

Definition at line 35 of file Mix.h.

◆ Stages

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

Definition at line 37 of file Mix.h.

◆ TimesAndSpeed

using Mixer::TimesAndSpeed = MixerOptions::TimesAndSpeed

Definition at line 36 of file Mix.h.

◆ WarpOptions

using Mixer::WarpOptions = MixerOptions::Warp

Definition at line 33 of file Mix.h.

Constructor & Destructor Documentation

◆ Mixer() [1/3]

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`,
		ApplyVolume	applyVolume = `ApplyVolume::MapChannels`
	)

When creating with master effects stages applyGain is ignored

Precondition: all sequences in inputs are non-null; !!masterEffects && mixerSpec == nullptr && numOutChannels <= 2

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

    : mNumChannels { numOutChannels }
    , mInputs { move(inputs) }
    , mMasterEffects { move(masterEffects) }
    , mBufferSize { FindBufferSize(mInputs, mMasterEffects, outBufferSize) }
    , mApplyVolume { applyVolume }
    , mHighQuality { highQuality }
    , mFormat { outFormat }
    , mInterleaved { outInterleaved }
    , mTimesAndSpeed { std::make_shared<TimesAndSpeed>(TimesAndSpeed {
         startTime, stopTime, warpOptions.initialSpeed, startTime }) }
 
    // 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(), NeedsDitherPred); }
   );
   if (mMasterEffects)
      needsDither |= std::any_of(
         mMasterEffects->begin(), mMasterEffects->end(), NeedsDitherPred);
 
   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();
         }) +
      nMasterStages;
   mSettings.reserve(nStages);
   mStageBuffers.reserve(nStages);
 
   size_t i = 0;
   std::vector<std::unique_ptr<DownmixSource>> downmixSources;
   for (auto &input : mInputs) {
      const auto &sequence = input.pSequence;
      if (!sequence) {
         assert(false);
         break;
      }
 
      auto &source = mSources.emplace_back(sequence, BufferSize(), outRate,
         warpOptions, highQuality, mayThrow, mTimesAndSpeed);
      AudioGraph::Source *pDownstream = &source;
      for (const auto &stage : input.stages)
         if (
            auto& pNewDownstream =
               RegisterEffectStage(*pDownstream, sequence->NChannels(), stage, outRate))
         {
            pDownstream = pNewDownstream.get();
         }
      downmixSources.emplace_back(
         std::make_unique<SequenceDownmixSource>(
            *pDownstream,
            *sequence,
            pMixerSpec ? &pMixerSpec->mMap[i] : nullptr
         )
      );
 
      i += sequence->NChannels();
   }
   
   if (mMasterEffects && !mMasterEffects->empty())
   {
      mDownmixStage = std::make_unique<DownmixStage>(
         std::move(downmixSources), mNumChannels, mBufferSize, ApplyVolume::MapChannels
      );
 
      AudioGraph::Source* pDownstream = mDownmixStage.get();
      for (const auto& stage : *mMasterEffects)
      {
         if (
            auto& pNewDownstream =
               RegisterEffectStage(*pDownstream, mNumChannels, stage, outRate))
         {
            pDownstream = pNewDownstream.get();
         }
      }
 
      //Effect stage could have more than mNumChannels output
      //and expect at least 3 float buffers input to work correctly...
      std::vector<std::unique_ptr<DownmixSource>> masterDownmixSources;
      masterDownmixSources.push_back(std::make_unique<SimpleDonwmixSource>(*pDownstream, mNumChannels));
      mMasterDownmixStage = std::make_unique<DownmixStage>(
         std::move(masterDownmixSources), mNumChannels, mBufferSize, ApplyVolume::Mixdown);
      mDownstream = mMasterDownmixStage.get();
   }
   else
   {
      mDownmixStage = std::make_unique<DownmixStage>(
         std::move(downmixSources),
         mNumChannels,
         mBufferSize,
         mApplyVolume
      );
      mDownstream = mDownmixStage.get();
   }
 
   // Decide once at construction time
   std::tie(mNeedsDither, mEffectiveFormat) = NeedsDither(needsDither, outRate);
}

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

◆ Mixer() [2/3]

Mixer::Mixer ( const Mixer & )

delete

◆ Mixer() [3/3]

Mixer::Mixer ( Mixer && )

deletenoexcept

◆ ~Mixer()

Mixer::~Mixer ( )

default

Member Function Documentation

◆ BufferSize()

size_t Mixer::BufferSize ( ) const

inline

Definition at line 79 of file Mix.h.

79{ return mBufferSize; }

Referenced by Process().

Here is the caller graph for this function:

◆ Clear()

void Mixer::Clear ( )

private

Definition at line 289 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 354 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 344 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 349 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 359 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 228 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 (mApplyVolume == ApplyVolume::Mixdown &&
         !mHasMixerSpec &&
         sequence.NChannels() > 1 && mNumChannels == 1)
      {
         needsDither = true;
      }
      else if (mApplyVolume != ApplyVolume::Discard) {
         for (auto c : {0, 1}) {
            const auto volume = sequence.GetChannelVolume(c);
            if (!(volume == 0.0 || volume == 1.0))
               // Fractional volume 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 volume 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 DownmixStage::Discard, mApplyVolume, mFormat, mHasMixerSpec, DownmixStage::Mixdown, mNumChannels, mSources, narrowestSampleFormat, and MixerSource::VariableRates().

Here is the call graph for this function:

◆ operator=() [1/2]

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

delete

◆ operator=() [2/2]

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

deletenoexcept

◆ Process() [1/2]

size_t Mixer::Process ( )

inline

Postcondition: result: result <= BufferSize()

Definition at line 98 of file Mix.h.

98{ return Process(BufferSize()); }

Mixer::Process

size_t Process()

Definition: Mix.h:98

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 295 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;
   
   maxOut = mDownstream->Acquire(mTemp, maxToProcess);
   mDownstream->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 _, AudioGraph::Source::Acquire(), BufferSize(), Clear(), CopySamples(), floatSample, AudioGraph::Buffers::GetReadPosition(), gHighQualityDither, gLowQualityDither, mBuffer, mDownstream, mFormat, mHighQuality, mInterleaved, mNeedsDither, mNumChannels, mTemp, mTimesAndSpeed, none, AudioGraph::Source::Release(), 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,
		size_t	numChannels,
		const MixerOptions::StageSpecification &	stage,
		double	outRate
	)

private

Definition at line 414 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, numChannels, 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, MixerOptions::StageSpecification::mpFirstInstance, mSettings, mStageBuffers, mStages, MixerOptions::StageSpecification::settings, and settings().

Here is the call 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 364 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 389 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 379 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

◆ mApplyVolume

const ApplyVolume Mixer::mApplyVolume

private

Definition at line 143 of file Mix.h.

Referenced by NeedsDither().

◆ mBuffer

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

private

Definition at line 163 of file Mix.h.

Referenced by GetBuffer(), and Process().

◆ mBufferSize

const size_t Mixer::mBufferSize

private

Definition at line 135 of file Mix.h.

Referenced by Clear(), and RegisterEffectStage().

◆ mDownmixStage

std::unique_ptr<AudioGraph::Source> Mixer::mDownmixStage

private

Definition at line 169 of file Mix.h.

◆ mDownstream

AudioGraph::Source* Mixer::mDownstream {}

private

Definition at line 171 of file Mix.h.

Referenced by Process().

◆ mEffectiveFormat

sampleFormat Mixer::mEffectiveFormat

private

Definition at line 149 of file Mix.h.

Referenced by EffectiveFormat().

◆ mFormat

const sampleFormat Mixer::mFormat

private

Definition at line 145 of file Mix.h.

Referenced by NeedsDither(), and Process().

◆ mHasMixerSpec

bool Mixer::mHasMixerSpec {false}

private

Definition at line 151 of file Mix.h.

Referenced by NeedsDither().

◆ mHighQuality

const bool Mixer::mHighQuality

private

Definition at line 144 of file Mix.h.

Referenced by Process().

◆ mInputs

Inputs Mixer::mInputs

private

Definition at line 131 of file Mix.h.

◆ mInterleaved

const bool Mixer::mInterleaved

private

Definition at line 146 of file Mix.h.

Referenced by Process().

◆ mMasterDownmixStage

std::unique_ptr<AudioGraph::Source> Mixer::mMasterDownmixStage

private

Definition at line 170 of file Mix.h.

◆ mMasterEffects

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

private

Definition at line 132 of file Mix.h.

◆ mNeedsDither

bool Mixer::mNeedsDither

private

Definition at line 150 of file Mix.h.

Referenced by Process().

◆ mNumChannels

const unsigned Mixer::mNumChannels

private

Definition at line 130 of file Mix.h.

Referenced by NeedsDither(), and Process().

◆ mSettings

std::vector<EffectSettings> Mixer::mSettings

private

Definition at line 166 of file Mix.h.

Referenced by RegisterEffectStage().

◆ mSources

std::vector<MixerSource> Mixer::mSources

private

Definition at line 165 of file Mix.h.

Referenced by NeedsDither(), and Reposition().

◆ mStageBuffers

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

private

Definition at line 167 of file Mix.h.

Referenced by RegisterEffectStage().

◆ mStages

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

private

Definition at line 168 of file Mix.h.

Referenced by RegisterEffectStage().

◆ mTemp

AudioGraph::Buffers Mixer::mTemp

private

Definition at line 160 of file Mix.h.

Referenced by Clear(), and Process().

◆ mTimesAndSpeed

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

private

Definition at line 153 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

◆ ApplyVolume

◆ Inputs

◆ MixerSpec

◆ ResampleParameters

◆ Stages

◆ TimesAndSpeed

◆ WarpOptions

Constructor & Destructor Documentation

◆ Mixer() [1/3]

◆ Mixer() [2/3]

◆ Mixer() [3/3]

◆ ~Mixer()

Member Function Documentation

◆ BufferSize()

◆ Clear()

◆ EffectiveFormat()

◆ GetBuffer() [1/2]

◆ GetBuffer() [2/2]

◆ MixGetCurrentTime()

◆ NeedsDither()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ Process() [1/2]

◆ Process() [2/2]

◆ RegisterEffectStage()

◆ Reposition()

◆ SetSpeedForKeyboardScrubbing()

◆ SetTimesAndSpeed()

Member Data Documentation

◆ mApplyVolume

◆ mBuffer

◆ mBufferSize

◆ mDownmixStage

◆ mDownstream

◆ mEffectiveFormat

◆ mFormat

◆ mHasMixerSpec

◆ mHighQuality

◆ mInputs

◆ mInterleaved

◆ mMasterDownmixStage

◆ mMasterEffects

◆ mNeedsDither

◆ mNumChannels

◆ mSettings

◆ mSources

◆ mStageBuffers

◆ mStages

◆ mTemp

◆ mTimesAndSpeed