Audacity 3.2.0
Classes | Public Types | Public Member Functions | Private Member Functions | Private Attributes | List of all members
Mixer Class Reference

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

#include <Mix.h>

Collaboration diagram for Mixer:
[legend]

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
 
Mixeroperator= (const Mixer &)=delete
 
virtual ~Mixer ()
 
size_t BufferSize () const
 
size_t Process (size_t maxSamples)
 
size_t Process ()
 
void Restart ()
 Restart processing at beginning of buffer next time Process() is called. More...
 
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, sampleFormatNeedsDither (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< TimesAndSpeedmTimesAndSpeed
 
AudioGraph::Buffers mFloatBuffers
 
std::vector< std::vector< float > > mTemp
 
const std::vector< SampleBuffermBuffer
 
std::vector< MixerSourcemSources
 
std::vector< EffectSettingsmSettings
 
std::vector< AudioGraph::BuffersmStageBuffers
 
std::vector< std::unique_ptr< AudioGraph::EffectStage > > mStages
 
std::vector< SourcemDecoratedSources
 

Detailed Description

Functions for doing the mixdown of the tracks.

Definition at line 26 of file Mix.h.

Member Typedef Documentation

◆ Inputs

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

Definition at line 43 of file Mix.h.

◆ MixerSpec

Definition at line 29 of file Mix.h.

◆ ResampleParameters

Definition at line 30 of file Mix.h.

◆ Stages

Definition at line 32 of file Mix.h.

◆ TimesAndSpeed

Definition at line 31 of file Mix.h.

◆ WarpOptions

Definition at line 28 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 inputTracks are non-null
any left channels in inputTracks are immediately followed by their partners
Postcondition
BufferSize() <= outBufferSize (equality when no inputs have stages)
Parameters
mixerSpecNull or else must have a lifetime enclosing this object's

Definition at line 75 of file Mix.cpp.

84 : mNumChannels{ numOutChannels }
85 , mInputs{ move(inputs) }
86 , mBufferSize{ FindBufferSize(mInputs, outBufferSize) }
87 , mApplyTrackGains{ applyTrackGains }
88 , mHighQuality{ highQuality }
89 , mFormat{ outFormat }
90 , mInterleaved{ outInterleaved }
91
92 , mTimesAndSpeed{ std::make_shared<TimesAndSpeed>( TimesAndSpeed{
93 startTime, stopTime, warpOptions.initialSpeed, startTime
94 } ) }
95
96 // PRL: Bug2536: see other comments below for the last, padding argument
97 // TODO: more-than-two-channels
98 // Issue 3565 workaround: allocate one extra buffer when applying a
99 // GVerb effect stage. It is simply discarded
100 // See also issue 3854, when the number of out channels expected by the
101 // plug-in is yet larger
102 , mFloatBuffers{ 3, mBufferSize, 1, 1 }
103
104 // non-interleaved
105 , mTemp{ initVector<float>(mNumChannels, mBufferSize) }
106 , mBuffer{ initVector<SampleBuffer>(mInterleaved ? 1 : mNumChannels,
107 [format = mFormat,
109 ](auto &buffer){ buffer.Allocate(size, format); }
110 )}
112{
113 assert(BufferSize() <= outBufferSize);
114 const auto nTracks = mInputs.size();
115
116 // Examine the temporary instances that were made in FindBufferSize
117 // This finds a sufficient, but not necessary, condition to do dithering
118 bool needsDither = std::any_of(mInputs.begin(), mInputs.end(),
119 [](const Input &input){
120 return std::any_of(input.stages.begin(), input.stages.end(),
121 [](const MixerOptions::StageSpecification &spec){
122 return spec.mpFirstInstance &&
123 spec.mpFirstInstance->NeedsDither(); } ); } );
124
125 auto pMixerSpec = ( mixerSpec &&
126 mixerSpec->GetNumChannels() == mNumChannels &&
127 mixerSpec->GetNumTracks() == nTracks
128 ) ? mixerSpec : nullptr;
129
130 // Reserve vectors first so we can take safe references to pushed elements
131 mSources.reserve(nTracks);
132 auto nStages = std::accumulate(mInputs.begin(), mInputs.end(), 0,
133 [](auto sum, auto &input){ return sum + input.stages.size(); });
134 mSettings.reserve(nStages);
135 mStageBuffers.reserve(nStages);
136
137 for (size_t i = 0; i < nTracks;) {
138 const auto &input = mInputs[i];
139 const auto leader = input.pTrack.get();
140 const auto nInChannels = TrackList::Channels(leader).size();
141 if (!leader || i + nInChannels > nTracks) {
142 assert(false);
143 break;
144 }
145 auto increment = finally([&]{ i += nInChannels; });
146
147 auto &source = mSources.emplace_back( *leader, BufferSize(), outRate,
148 warpOptions, highQuality, mayThrow, mTimesAndSpeed,
149 (pMixerSpec ? &pMixerSpec->mMap[i] : nullptr));
150 AudioGraph::Source *pDownstream = &source;
151 for (const auto &stage : input.stages) {
152 // Make a mutable copy of stage.settings
153 auto &settings = mSettings.emplace_back(stage.settings);
154 // TODO: more-than-two-channels
155 // Like mFloatBuffers but padding not needed for soxr
156 // Allocate one extra buffer to hold dummy zero inputs
157 // (Issue 3854)
158 auto &stageInput = mStageBuffers.emplace_back(3, mBufferSize, 1);
159 const auto &factory = [&stage]{
160 // Avoid unnecessary repeated calls to the factory
161 return stage.mpFirstInstance
162 ? move(stage.mpFirstInstance)
163 : stage.factory();
164 };
165 auto &pNewDownstream =
167 *pDownstream, stageInput,
168 factory, settings, outRate, std::nullopt, *leader
169 ));
170 if (pNewDownstream)
171 pDownstream = pNewDownstream.get();
172 else {
173 // Just omit the failed stage from rendering
174 // TODO propagate the error?
175 mStageBuffers.pop_back();
176 mSettings.pop_back();
177 }
178 }
179 mDecoratedSources.emplace_back(Source{ source, *pDownstream });
180 }
181
182 // Decide once at construction time
183 std::tie(mNeedsDither, mEffectiveFormat) = NeedsDither(needsDither, outRate);
184}
int format
Definition: ExportPCM.cpp:53
static Settings & settings()
Definition: TrackInfo.cpp:87
static std::unique_ptr< EffectStage > Create(bool multi, Source &upstream, Buffers &inBuffers, const Factory &factory, EffectSettings &settings, double sampleRate, std::optional< sampleCount > genLength, const Track &track)
Satisfies postcondition of constructor or returns null.
Definition: EffectStage.cpp:87
Upstream producer of sample streams, taking Buffers as external context.
AudioGraph::Buffers mFloatBuffers
Definition: Mix.h:148
std::vector< EffectSettings > mSettings
Definition: Mix.h:159
const std::vector< SampleBuffer > mBuffer
Definition: Mix.h:156
std::vector< Source > mDecoratedSources
Definition: Mix.h:164
const bool mApplyTrackGains
Definition: Mix.h:134
const sampleFormat mFormat
Definition: Mix.h:136
Inputs mInputs
Definition: Mix.h:123
std::vector< std::unique_ptr< AudioGraph::EffectStage > > mStages
Definition: Mix.h:161
MixerOptions::TimesAndSpeed TimesAndSpeed
Definition: Mix.h:31
std::vector< std::vector< float > > mTemp
Definition: Mix.h:153
std::pair< bool, sampleFormat > NeedsDither(bool needsDither, double rate) const
Definition: Mix.cpp:191
const unsigned mNumChannels
Definition: Mix.h:122
sampleFormat mEffectiveFormat
Definition: Mix.h:140
const bool mInterleaved
Definition: Mix.h:137
const size_t mBufferSize
Definition: Mix.h:126
bool mNeedsDither
Definition: Mix.h:141
std::vector< AudioGraph::Buffers > mStageBuffers
Definition: Mix.h:160
const bool mHighQuality
Definition: Mix.h:135
std::vector< MixerSource > mSources
Definition: Mix.h:158
size_t BufferSize() const
Definition: Mix.h:70
const std::shared_ptr< TimesAndSpeed > mTimesAndSpeed
Definition: Mix.h:143
unsigned GetNumChannels()
Definition: MixerOptions.h:45
unsigned GetNumTracks()
Definition: MixerOptions.h:48
static auto Channels(TrackType *pTrack) -> TrackIterRange< TrackType >
Definition: Track.h:1541
size_t FindBufferSize(const Mixer::Inputs &inputs, size_t bufferSize)
Definition: Mix.cpp:49
static RegisteredToolbarFactory factory

References format, and size.

◆ Mixer() [2/2]

Mixer::Mixer ( const Mixer )
delete

◆ ~Mixer()

Mixer::~Mixer ( )
virtual

Definition at line 186 of file Mix.cpp.

187{
188}

Member Function Documentation

◆ BufferSize()

size_t Mixer::BufferSize ( ) const
inline

Definition at line 70 of file Mix.h.

70{ return mBufferSize; }

Referenced by Process().

Here is the caller graph for this function:

◆ Clear()

void Mixer::Clear ( )
private

Definition at line 249 of file Mix.cpp.

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

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

387{
388 return mEffectiveFormat;
389}

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

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

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

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

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

392{
393 return mTimesAndSpeed->mTime;
394}

References mTimesAndSpeed.

Referenced by 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 191 of file Mix.cpp.

192{
193 // This will accumulate the widest effective format of any input
194 // clip
195 auto widestEffectiveFormat = narrowestSampleFormat;
196
197 // needsDither may already be given as true.
198 // There are many other possible disqualifiers for the avoidance of dither.
199 if (std::any_of(mSources.begin(), mSources.end(),
200 std::mem_fn(&MixerSource::VariableRates))
201 )
202 // We will call MixVariableRates(), so we need nontrivial resampling
203 needsDither = true;
204
205 for (const auto &input : mInputs) {
206 auto &pTrack = input.pTrack;
207 if (!pTrack)
208 continue;
209 auto &track = *pTrack;
210 if (track.GetRate() != rate)
211 // Also leads to MixVariableRates(), needs nontrivial resampling
212 needsDither = true;
213 if (mApplyTrackGains) {
215 for (auto c : {0, 1}) {
216 const auto gain = track.GetChannelGain(c);
217 if (!(gain == 0.0 || gain == 1.0))
218 // Fractional gain may be applied even in MixSameRate
219 needsDither = true;
220 }
221 }
222
223 // Examine all tracks. (This ignores the time bounds for the mixer.
224 // If it did not, we might avoid dither in more cases. But if we fix
225 // that, remember that some mixers change their time bounds after
226 // construction, as when scrubbing.)
227 if (!track.HasTrivialEnvelope())
228 // Varying or non-unit gain may be applied even in MixSameRate
229 needsDither = true;
230 auto effectiveFormat = track.WidestEffectiveFormat();
231 if (effectiveFormat > mFormat)
232 // Real, not just nominal, precision loss would happen in at
233 // least one clip
234 needsDither = true;
235 widestEffectiveFormat =
236 std::max(widestEffectiveFormat, effectiveFormat);
237 }
238
239 if (needsDither)
240 // Results will be dithered to width mFormat
241 return { true, mFormat };
242 else {
243 // Results will not be dithered
244 assert(widestEffectiveFormat <= mFormat);
245 return { false, widestEffectiveFormat };
246 }
247}
@ narrowestSampleFormat
Two synonyms for previous values that might change if more values were added.
bool VariableRates() const
Definition: MixerSource.h:61

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 89 of file Mix.h.

89{ return Process(BufferSize()); }
size_t Process()
Definition: Mix.h:89

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

273{
274 assert(maxToProcess <= BufferSize());
275
276 // MB: this is wrong! mT represented warped time, and mTime is too inaccurate to use
277 // it here. It's also unnecessary I think.
278 //if (mT >= mT1)
279 // return 0;
280
281 size_t maxOut = 0;
282 const auto channelFlags = stackAllocate(unsigned char, mNumChannels);
283 const auto gains = stackAllocate(float, mNumChannels);
284 if (!mApplyTrackGains)
285 std::fill(gains, gains + mNumChannels, 1.0f);
286
287 // Decides which output buffers an input channel accumulates into
288 auto findChannelFlags = [&channelFlags, numChannels = mNumChannels]
289 (const bool *map, Track::ChannelType channel){
290 const auto end = channelFlags + numChannels;
291 std::fill(channelFlags, end, 0);
292 if (map)
293 // ignore left and right when downmixing is customized
294 std::copy(map, map + numChannels, channelFlags);
295 else switch(channel) {
297 default:
298 std::fill(channelFlags, end, 1);
299 break;
301 channelFlags[0] = 1;
302 break;
304 if (numChannels >= 2)
305 channelFlags[1] = 1;
306 else
307 channelFlags[0] = 1;
308 break;
309 }
310 return channelFlags;
311 };
312
313 auto &[mT0, mT1, _, mTime] = *mTimesAndSpeed;
314 auto oldTime = mTime;
315 // backwards (as possibly in scrubbing)
316 const auto backwards = (mT0 > mT1);
317
318 Clear();
319 // TODO: more-than-two-channels
320 auto maxChannels = std::max(2u, mFloatBuffers.Channels());
321
322 for (auto &[ upstream, downstream ] : mDecoratedSources) {
323 auto oResult = downstream.Acquire(mFloatBuffers, maxToProcess);
324 // One of MixVariableRates or MixSameRate assigns into mTemp[*][*] which
325 // are the sources for the CopySamples calls, and they copy into
326 // mBuffer[*][*]
327 if (!oResult)
328 return 0;
329 auto result = *oResult;
330 maxOut = std::max(maxOut, result);
331
332 // Insert effect stages here! Passing them all channels of the track
333
334 const auto limit = std::min<size_t>(upstream.Channels(), maxChannels);
335 for (size_t j = 0; j < limit; ++j) {
336 const auto pFloat = (const float *)mFloatBuffers.GetReadPosition(j);
337 const auto track = upstream.GetChannel(j);
339 for (size_t c = 0; c < mNumChannels; ++c)
340 gains[c] = track->GetChannelGain(c);
341 const auto flags =
342 findChannelFlags(upstream.MixerSpec(j), track->GetChannel());
343 MixBuffers(mNumChannels, flags, gains, *pFloat, mTemp, result);
344 }
345
346 downstream.Release();
347 mFloatBuffers.Advance(result);
349 }
350
351 if (backwards)
352 mTime = std::clamp(mTime, mT1, oldTime);
353 else
354 mTime = std::clamp(mTime, oldTime, mT1);
355
356 const auto dstStride = (mInterleaved ? mNumChannels : 1);
357 auto ditherType = mNeedsDither
360 for (size_t c = 0; c < mNumChannels; ++c)
363 ? mBuffer[0].ptr() + (c * SAMPLE_SIZE(mFormat))
364 : mBuffer[c].ptr()
365 ),
366 mFormat, maxOut, ditherType,
367 1, dstStride);
368
369 // MB: this doesn't take warping into account, replaced with code based on mSamplePos
370 //mT += (maxOut / mRate);
371
372 assert(maxOut <= maxToProcess);
373 return maxOut;
374}
@ none
Definition: Dither.h:20
#define _(s)
Definition: Internat.h:75
static void MixBuffers(unsigned numChannels, const unsigned char *channelFlags, const float *gains, const float &src, std::vector< std::vector< float > > &dests, int len)
Definition: Mix.cpp:255
#define stackAllocate(T, count)
Definition: Mix.cpp:270
DitherType gLowQualityDither
These global variables are assigned at application startup or after change of preferences.
DitherType gHighQualityDither
void CopySamples(constSamplePtr src, sampleFormat srcFormat, samplePtr dst, sampleFormat dstFormat, size_t len, DitherType ditherType, unsigned int srcStride, unsigned int dstStride)
Copy samples from any format to any other format; apply dithering only if narrowing the format.
#define SAMPLE_SIZE(SampleFormat)
Definition: SampleFormat.h:50
const char * constSamplePtr
Definition: SampleFormat.h:56
void Advance(size_t count)
Move the positions.
size_t Rotate()
Shift all data at and after the old position to position 0.
unsigned Channels() const
constSamplePtr GetReadPosition(unsigned iChannel) const
Get accumulated data for one channel.
void Clear()
Definition: Mix.cpp:249
ChannelType
Definition: Track.h:281
@ LeftChannel
Definition: Track.h:282
@ RightChannel
Definition: Track.h:283
@ MonoChannel
Definition: Track.h:284
auto end(const Ptr< Type, BaseDeleter > &p)
Enables range-for.
Definition: PackedArray.h:159

References _, AudioGraph::Buffers::Advance(), BufferSize(), AudioGraph::Buffers::Channels(), Clear(), CopySamples(), PackedArray::end(), floatSample, AudioGraph::Buffers::GetReadPosition(), gHighQualityDither, gLowQualityDither, Track::LeftChannel, mApplyTrackGains, mBuffer, mDecoratedSources, mFloatBuffers, mFormat, mHighQuality, mInterleaved, MixBuffers(), mNeedsDither, mNumChannels, Track::MonoChannel, mTemp, mTimesAndSpeed, none, Track::RightChannel, 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 418 of file Mix.cpp.

419{
420 auto &[mT0, mT1, _, mTime] = *mTimesAndSpeed;
421 mTime = t;
422 const bool backwards = (mT1 < mT0);
423 if (backwards)
424 mTime = std::clamp(mTime, mT1, mT0);
425 else
426 mTime = std::clamp(mTime, mT0, mT1);
427
428 for (auto &source : mSources)
429 source.Reposition(mTime, bSkipping);
430}

References _, mSources, and mTimesAndSpeed.

Referenced by SetSpeedForKeyboardScrubbing(), and SetTimesAndSpeed().

Here is the caller graph for this function:

◆ Restart()

void Mixer::Restart ( )

Restart processing at beginning of buffer next time Process() is called.

◆ SetSpeedForKeyboardScrubbing()

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

Definition at line 442 of file Mix.cpp.

443{
444 wxASSERT(std::isfinite(speed));
445 auto &[mT0, mT1, mSpeed, _] = *mTimesAndSpeed;
446
447 // Check if the direction has changed
448 if ((speed > 0.0 && mT1 < mT0) || (speed < 0.0 && mT1 > mT0)) {
449 // It's safe to use 0 and std::numeric_limits<double>::max(),
450 // because Mixer::MixVariableRates() doesn't sample past the start
451 // or end of the audio in a track.
452 if (speed > 0.0 && mT1 < mT0) {
453 mT0 = 0;
454 mT1 = std::numeric_limits<double>::max();
455 }
456 else {
457 mT0 = std::numeric_limits<double>::max();
458 mT1 = 0;
459 }
460
461 Reposition(startTime, true);
462 }
463
464 mSpeed = fabs(speed);
465}
void Reposition(double t, bool bSkipping=false)
Reposition processing to absolute time next time Process() is called.
Definition: Mix.cpp:418

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

433{
434 wxASSERT(std::isfinite(speed));
435 auto &[mT0, mT1, mSpeed, _] = *mTimesAndSpeed;
436 mT0 = t0;
437 mT1 = t1;
438 mSpeed = fabs(speed);
439 Reposition(t0, bSkipping);
440}

References _, mTimesAndSpeed, and Reposition().

Here is the call graph for this function:

Member Data Documentation

◆ mApplyTrackGains

const bool Mixer::mApplyTrackGains
private

Definition at line 134 of file Mix.h.

Referenced by NeedsDither(), and Process().

◆ mBuffer

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

Definition at line 156 of file Mix.h.

Referenced by GetBuffer(), and Process().

◆ mBufferSize

const size_t Mixer::mBufferSize
private

Definition at line 126 of file Mix.h.

◆ mDecoratedSources

std::vector<Source> Mixer::mDecoratedSources
private

Definition at line 164 of file Mix.h.

Referenced by Process().

◆ mEffectiveFormat

sampleFormat Mixer::mEffectiveFormat
private

Definition at line 140 of file Mix.h.

Referenced by EffectiveFormat().

◆ mFloatBuffers

AudioGraph::Buffers Mixer::mFloatBuffers
private

Definition at line 148 of file Mix.h.

Referenced by Process().

◆ mFormat

const sampleFormat Mixer::mFormat
private

Definition at line 136 of file Mix.h.

Referenced by NeedsDither(), and Process().

◆ mHighQuality

const bool Mixer::mHighQuality
private

Definition at line 135 of file Mix.h.

Referenced by Process().

◆ mInputs

Inputs Mixer::mInputs
private

Definition at line 123 of file Mix.h.

Referenced by NeedsDither().

◆ mInterleaved

const bool Mixer::mInterleaved
private

Definition at line 137 of file Mix.h.

Referenced by Process().

◆ mNeedsDither

bool Mixer::mNeedsDither
private

Definition at line 141 of file Mix.h.

Referenced by Process().

◆ mNumChannels

const unsigned Mixer::mNumChannels
private

Definition at line 122 of file Mix.h.

Referenced by Process().

◆ mSettings

std::vector<EffectSettings> Mixer::mSettings
private

Definition at line 159 of file Mix.h.

◆ mSources

std::vector<MixerSource> Mixer::mSources
private

Definition at line 158 of file Mix.h.

Referenced by NeedsDither(), and Reposition().

◆ mStageBuffers

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

Definition at line 160 of file Mix.h.

◆ mStages

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

Definition at line 161 of file Mix.h.

◆ mTemp

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

Definition at line 153 of file Mix.h.

Referenced by Clear(), and Process().

◆ mTimesAndSpeed

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

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