WaveChannelUtilities Namespace Reference

Typedefs
using	Clip = WaveClipChannel
using	ClipPointer = std::shared_ptr< Clip >
using	ClipPointers = std::vector< ClipPointer >
using	ClipConstPointer = std::shared_ptr< const Clip >
using	ClipConstPointers = std::vector< ClipConstPointer >

Functions
WAVE_TRACK_API bool	CompareClipsByPlayStartTime (const Clip &x, const Clip &y)
bool	CompareClipPointersByPlayStartTime (const ClipConstPointer x, const ClipConstPointer y)
bool	IsSortedByPlayStartTime (const ClipPointers &clips)
bool	IsSortedByPlayStartTime (const ClipConstPointers &clips)
WAVE_TRACK_API ClipPointers	SortedClipArray (WaveChannel &channel)
	Get clips sorted by play start time. More...
WAVE_TRACK_API ClipConstPointers	SortedClipArray (const WaveChannel &channel)
	Get clips sorted by play start time. More...
WAVE_TRACK_API ClipPointer	GetClipAtTime (WaveChannel &channel, double time)
WAVE_TRACK_API ClipConstPointer	GetClipAtTime (const WaveChannel &channel, double time)
WAVE_TRACK_API Envelope *	GetEnvelopeAtTime (WaveChannel &channel, double time)
WAVE_TRACK_API std::pair< float, float >	GetMinMax (const WaveChannel &channel, double t0, double t1, bool mayThrow=true)
WAVE_TRACK_API float	GetRMS (const WaveChannel &channel, double t0, double t1, bool mayThrow=true)
WAVE_TRACK_API std::pair< size_t, size_t >	GetFloatsCenteredAroundTime (const WaveChannel &channel, double t, float *buffer, size_t numSideSamples, bool mayThrow)
	Gets as many samples as it can, but no more than 2 * numSideSamples + 1, centered around t. Reads nothing if GetClipAtTime(t) == nullptr. Useful to access samples across clip boundaries, as it spreads the read to adjacent clips, i.e., not separated by silence from clip at t. More...
WAVE_TRACK_API bool	GetFloatAtTime (const WaveChannel &channel, double t, float &value, bool mayThrow)
WAVE_TRACK_API bool	GetFloatAtTime (const Clip &clip, double t, float &value, bool mayThrow)
WAVE_TRACK_API void	SetFloatsCenteredAroundTime (WaveChannel &channel, double t, const float *buffer, size_t numSideSamples, sampleFormat effectiveFormat)
	Similar to GetFloatsCenteredAroundTime, but for writing. Sets as many samples as it can according to the same rules as GetFloatsCenteredAroundTime. Leaves the other samples untouched. More...
WAVE_TRACK_API void	SetFloatAtTime (WaveChannel &channel, double t, float value, sampleFormat effectiveFormat)
	Sets sample nearest to t to value. Silently fails if GetClipAtTime(t) == nullptr. More...
WAVE_TRACK_API void	SetFloatsWithinTimeRange (WaveChannel &channel, double t0, double t1, const std::function< float(double sampleTime)> &producer, sampleFormat effectiveFormat)
	Provides a means of setting clip values as a function of time. Included are closest sample to t0 up to closest sample to t1, exclusively. If the given interval is empty, i.e., t0 >= t1, no action is taken. More...
WAVE_TRACK_API size_t	GetFloatsFromTime (const WaveChannel &channel, double t, float *buffer, size_t numSamples, bool mayThrow, PlaybackDirection direction)
	Helper for GetFloatsCenteredAroundTime. If direction == PlaybackDirection::Backward, fetches samples to the left of t, excluding t, without reversing. More...
WAVE_TRACK_API void	SetFloatsFromTime (WaveChannel &channel, double t, const float *buffer, size_t numSamples, sampleFormat effectiveFormat, PlaybackDirection direction)
	Similar to GetFloatsFromTime, but for writing. Sets as many samples as it can according to the same rules as GetFloatsFromTime. Leaves the other samples untouched. More...
WAVE_TRACK_API void	SetFloatsFromTime (Clip &channel, double t, const float *buffer, size_t numSamples, sampleFormat effectiveFormat, PlaybackDirection direction)
	Similar to GetFloatsFromTime, but for writing. Sets as many samples as it can according to the same rules as GetFloatsFromTime. Leaves the other samples untouched. More...
WAVE_TRACK_API ClipConstPointer	GetAdjacentClip (const ClipConstPointers &clips, const Clip &clip, PlaybackDirection searchDirection)
	Similar to GetNextClip, but returns nullptr if the neighbour clip is not adjacent. More...
WAVE_TRACK_API ClipPointer	GetAdjacentClip (const ClipPointers &clips, const Clip &clip, PlaybackDirection searchDirection)
WAVE_TRACK_API ClipConstPointer	GetNextClip (const ClipConstPointers &clips, const Clip &clip, PlaybackDirection searchDirection)
	Returns clips next to clip in the given direction, or nullptr if there is none. More...
WAVE_TRACK_API ClipPointer	GetNextClip (const ClipPointers &clips, const Clip &clip, PlaybackDirection searchDirection)
WAVE_TRACK_API ClipPointer	GetIntervalAtTime (WaveChannel &channel, double t)

Typedef Documentation

Clip

using WaveChannelUtilities::Clip = typedef WaveClipChannel

Definition at line 30 of file WaveChannelUtilities.h.

ClipConstPointer

using WaveChannelUtilities::ClipConstPointer = typedef std::shared_ptr<const Clip>

Definition at line 33 of file WaveChannelUtilities.h.

ClipConstPointers

using WaveChannelUtilities::ClipConstPointers = typedef std::vector<ClipConstPointer>

Definition at line 34 of file WaveChannelUtilities.h.

ClipPointer

using WaveChannelUtilities::ClipPointer = typedef std::shared_ptr<Clip>

Definition at line 31 of file WaveChannelUtilities.h.

ClipPointers

using WaveChannelUtilities::ClipPointers = typedef std::vector<ClipPointer>

Definition at line 32 of file WaveChannelUtilities.h.

Function Documentation

CompareClipPointersByPlayStartTime()

bool WaveChannelUtilities::CompareClipPointersByPlayStartTime ( const ClipConstPointer  x, const ClipConstPointer  y  )

inline

Definition at line 39 of file WaveChannelUtilities.h.

{
   return CompareClipsByPlayStartTime(*x, *y);
}

References CompareClipsByPlayStartTime().

Referenced by IsSortedByPlayStartTime(), and SortedClipArray().

Here is the call graph for this function:

Here is the caller graph for this function:

CompareClipsByPlayStartTime()

bool WaveChannelUtilities::CompareClipsByPlayStartTime	(	const Clip &	x,
		const Clip &	y
	)

Definition at line 389 of file WaveChannelUtilities.cpp.

{
   return x.GetPlayStartTime() < y.GetPlayStartTime();
}

References WaveClipChannel::GetPlayStartTime().

Referenced by CompareClipPointersByPlayStartTime(), and anonymous_namespace{WaveChannelUtilities.cpp}::DoGetNextClip().

Here is the call graph for this function:

Here is the caller graph for this function:

GetAdjacentClip() [1/2]

auto WaveChannelUtilities::GetAdjacentClip	(	const ClipConstPointers &	clips,
		const Clip &	clip,
		PlaybackDirection	searchDirection
	)

Similar to GetNextClip, but returns nullptr if the neighbour clip is not adjacent.

Precondition

IsSortedByPlayStartTime(clips)

Definition at line 349 of file WaveChannelUtilities.cpp.

{
   assert(IsSortedByPlayStartTime(clips));
   return DoGetAdjacentClip(clips, clip, direction);
}

References anonymous_namespace{WaveChannelUtilities.cpp}::DoGetAdjacentClip(), and IsSortedByPlayStartTime().

Referenced by GetFloatsFromTime(), and SetFloatsFromTime().

Here is the call graph for this function:

Here is the caller graph for this function:

GetAdjacentClip() [2/2]

auto WaveChannelUtilities::GetAdjacentClip	(	const ClipPointers &	clips,
		const Clip &	clip,
		PlaybackDirection	searchDirection
	)

Definition at line 356 of file WaveChannelUtilities.cpp.

{
   assert(IsSortedByPlayStartTime(clips));
   return DoGetAdjacentClip(clips, clip, direction);
}

References anonymous_namespace{WaveChannelUtilities.cpp}::DoGetAdjacentClip(), and IsSortedByPlayStartTime().

Here is the call graph for this function:

GetClipAtTime() [1/2]

auto WaveChannelUtilities::GetClipAtTime	(	const WaveChannel &	channel,
		double	time
	)

When the time is both the end of a clip and the start of the next clip, the latter clip is returned.

Definition at line 424 of file WaveChannelUtilities.cpp.

{
   return GetClipAtTime(const_cast<WaveChannel&>(channel), time);
}

References GetClipAtTime().

Here is the call graph for this function:

GetClipAtTime() [2/2]

auto WaveChannelUtilities::GetClipAtTime	(	WaveChannel &	channel,
		double	time
	)

When the time is both the end of a clip and the start of the next clip, the latter clip is returned.

Definition at line 412 of file WaveChannelUtilities.cpp.

{
   const auto clips = SortedClipArray(channel);
   auto p = std::find_if(
      clips.rbegin(), clips.rend(), [&](const auto& clip) {
         return clip->WithinPlayRegion(time);
      });
   return p != clips.rend() ? *p : nullptr;
}

References SortedClipArray().

Referenced by anonymous_namespace{SampleHandle.cpp}::adjustTime(), SampleHandle::Click(), GetClipAtTime(), GetEnvelopeAtTime(), GetFloatAtTime(), GetFloatsFromTime(), WaveChannelSubView::GetMenuItems(), SampleHandle::HitTest(), anonymous_namespace{WaveChannelUtilities.cpp}::RoundToNearestClipSample(), SetFloatsFromTime(), and SetFloatsWithinTimeRange().

Here is the call graph for this function:

Here is the caller graph for this function:

GetEnvelopeAtTime()

Envelope * WaveChannelUtilities::GetEnvelopeAtTime	(	WaveChannel &	channel,
		double	time
	)

Definition at line 378 of file WaveChannelUtilities.cpp.

{
   // Substitute the first channel
   auto &first = **channel.GetTrack().Channels().begin();
   if (const auto clip = GetClipAtTime(first, time))
      return &clip->GetEnvelope();
   else
      return nullptr;
}

References WaveTrack::Channels(), GetClipAtTime(), and WaveChannel::GetTrack().

Referenced by WaveformView::DetailedHitTest(), SampleHandle::FindSampleEditingLevel(), SampleHandle::HitTest(), and EnvelopeHandle::WaveChannelHitTest().

Here is the call graph for this function:

Here is the caller graph for this function:

GetFloatAtTime() [1/2]

bool WaveChannelUtilities::GetFloatAtTime	(	const Clip &	clip,
		double	t,
		float &	value,
		bool	mayThrow
	)

Definition at line 212 of file WaveChannelUtilities.cpp.

{
   const size_t iChannel = clip.GetChannelIndex();
   WaveClipUtilities::GetFloatAtTime(clip.GetClip(),
      t - clip.GetPlayStartTime(), iChannel, value, mayThrow);
   return true;
}

References WaveClipChannel::GetChannelIndex(), WaveClipChannel::GetClip(), WaveClipUtilities::GetFloatAtTime(), WaveClipChannel::GetPlayStartTime(), and anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel.

Here is the call graph for this function:

GetFloatAtTime() [2/2]

bool WaveChannelUtilities::GetFloatAtTime	(	const WaveChannel &	channel,
		double	t,
		float &	value,
		bool	mayThrow
	)

Returns

true if GetClipAtTime(t) != nullptr, false otherwise.

Definition at line 203 of file WaveChannelUtilities.cpp.

{
   const auto clip = GetClipAtTime(channel, t);
   if (!clip)
      return false;
   return GetFloatAtTime(*clip, t, value, mayThrow);
}

References GetClipAtTime(), and GetFloatAtTime().

Referenced by GetFloatAtTime(), and SampleHandle::HitTest().

Here is the call graph for this function:

Here is the caller graph for this function:

GetFloatsCenteredAroundTime()

std::pair< size_t, size_t > WaveChannelUtilities::GetFloatsCenteredAroundTime	(	const WaveChannel &	channel,
		double	t,
		float *	buffer,
		size_t	numSideSamples,
		bool	mayThrow
	)

Gets as many samples as it can, but no more than 2 * numSideSamples + 1, centered around t. Reads nothing if GetClipAtTime(t) == nullptr. Useful to access samples across clip boundaries, as it spreads the read to adjacent clips, i.e., not separated by silence from clip at t.

Returns

The begin and end indices of the samples in the buffer where samples could actually be copied.

Definition at line 109 of file WaveChannelUtilities.cpp.

{
   const auto numSamplesReadLeft = GetFloatsFromTime(channel,
      t, buffer, numSideSamples, mayThrow, PlaybackDirection::backward);
   const auto numSamplesReadRight = GetFloatsFromTime(channel,
      t, buffer + numSideSamples, numSideSamples + 1, mayThrow,
      PlaybackDirection::forward);
   return { numSideSamples - numSamplesReadLeft,
            numSideSamples + numSamplesReadRight };
}

References backward, forward, and GetFloatsFromTime().

Referenced by SampleHandle::Click().

Here is the call graph for this function:

Here is the caller graph for this function:

GetFloatsFromTime()

size_t WaveChannelUtilities::GetFloatsFromTime	(	const WaveChannel &	channel,
		double	t,
		float *	buffer,
		size_t	numSamples,
		bool	mayThrow,
		PlaybackDirection	direction
	)

Helper for GetFloatsCenteredAroundTime. If direction == PlaybackDirection::Backward, fetches samples to the left of t, excluding t, without reversing.

See also

GetFloatsCenteredAroundTime

Returns

The number of samples actually copied.

Definition at line 178 of file WaveChannelUtilities.cpp.

{
   RoundToNearestClipSample(channel, t);
   auto clip = GetClipAtTime(channel, t);
   auto numSamplesRead = 0u;
   const auto forward = direction == PlaybackDirection::forward;
   const auto clips = SortedClipArray(channel);
   while (clip)
   {
      const auto args = GetSampleAccessArgs(
         *clip, t, buffer, numSamples, numSamplesRead, forward);
      if (!clip->GetSamples(
            args.offsetBuffer, floatSample, args.start, args.len,
            mayThrow))
         return 0u;
      numSamplesRead += args.len;
      if (numSamplesRead >= numSamples)
         break;
      clip = GetAdjacentClip(clips, *clip, direction);
   }
   return numSamplesRead;
}

References floatSample, forward, GetAdjacentClip(), GetClipAtTime(), anonymous_namespace{WaveChannelUtilities.cpp}::GetSampleAccessArgs(), anonymous_namespace{WaveChannelUtilities.cpp}::RoundToNearestClipSample(), and SortedClipArray().

Referenced by GetFloatsCenteredAroundTime().

Here is the call graph for this function:

Here is the caller graph for this function:

GetIntervalAtTime()

auto WaveChannelUtilities::GetIntervalAtTime	(	WaveChannel &	channel,
		double	t
	)

Definition at line 430 of file WaveChannelUtilities.cpp.

{
   ClipPointer result;
   for (const auto &interval : channel.Intervals())
      if (interval->WithinPlayRegion(t))
         return interval;
   return nullptr;
}

References WaveChannel::Intervals().

Referenced by SelectHandle::Click().

Here is the call graph for this function:

Here is the caller graph for this function:

GetMinMax()

std::pair< float, float > WaveChannelUtilities::GetMinMax	(	const WaveChannel &	channel,
		double	t0,
		double	t1,
		bool	mayThrow = true
	)

Getting high-level data for one channel for screen display and clipping calculations and Contrast

---

Audacity: A Digital Audio Editor

WaveChannelUtilities.cpp

Paul Licameli

Definition at line 21 of file WaveChannelUtilities.cpp.

{
   std::pair<float, float> results {
      // we need these at extremes to make sure we find true min and max
      std::numeric_limits<float>::max(),
      std::numeric_limits<float>::lowest(),
   };
   bool clipFound = false;
 
   if (t0 > t1) {
      if (mayThrow)
         THROW_INCONSISTENCY_EXCEPTION;
      return results;
   }
 
   if (t0 == t1)
      return results;
 
   for (const auto &clip: channel.Intervals())
   {
      if (t1 >= clip->GetPlayStartTime() && t0 <= clip->GetPlayEndTime())
      {
         clipFound = true;
         auto clipResults = clip->GetMinMax(t0, t1, mayThrow);
         if (clipResults.first < results.first)
            results.first = clipResults.first;
         if (clipResults.second > results.second)
            results.second = clipResults.second;
      }
   }
 
   if(!clipFound)
   {
      results = { 0.f, 0.f }; // sensible defaults if no clips found
   }
 
   return results;
}

References WaveChannel::Intervals(), and THROW_INCONSISTENCY_EXCEPTION.

Referenced by NormalizeBase::AnalyseTrack(), AmplifyBase::Init(), and NyquistBase::ProcessOne().

Here is the call graph for this function:

Here is the caller graph for this function:

GetNextClip() [1/2]

auto WaveChannelUtilities::GetNextClip	(	const ClipConstPointers &	clips,
		const Clip &	clip,
		PlaybackDirection	searchDirection
	)

Returns clips next to clip in the given direction, or nullptr if there is none.

Definition at line 363 of file WaveChannelUtilities.cpp.

{
   assert(IsSortedByPlayStartTime(clips));
   return DoGetNextClip(clips, clip, direction);
}

References anonymous_namespace{WaveChannelUtilities.cpp}::DoGetNextClip(), and IsSortedByPlayStartTime().

Referenced by anonymous_namespace{WaveChannelUtilities.cpp}::DoGetAdjacentClip(), and SetFloatsWithinTimeRange().

Here is the call graph for this function:

Here is the caller graph for this function:

GetNextClip() [2/2]

auto WaveChannelUtilities::GetNextClip	(	const ClipPointers &	clips,
		const Clip &	clip,
		PlaybackDirection	searchDirection
	)

Definition at line 371 of file WaveChannelUtilities.cpp.

{
   assert(IsSortedByPlayStartTime(clips));
   return DoGetNextClip(clips, clip, direction);
}

References anonymous_namespace{WaveChannelUtilities.cpp}::DoGetNextClip(), and IsSortedByPlayStartTime().

Here is the call graph for this function:

GetRMS()

float WaveChannelUtilities::GetRMS	(	const WaveChannel &	channel,
		double	t0,
		double	t1,
		bool	mayThrow = true
	)

Getting high-level data for one channel for screen display and clipping calculations and Contrast

---

Audacity: A Digital Audio Editor

WaveChannelUtilities.cpp

Paul Licameli

Definition at line 61 of file WaveChannelUtilities.cpp.

{
   if (t0 > t1) {
      if (mayThrow)
         THROW_INCONSISTENCY_EXCEPTION;
      return 0.f;
   }
 
   if (t0 == t1)
      return 0.f;
 
   double sumsq = 0.0;
   double duration = 0;
 
   for (const auto &clip: channel.Intervals())
   {
      // If t1 == clip->GetStartTime() or t0 == clip->GetEndTime(), then the clip
      // is not inside the selection, so we don't want it.
      // if (t1 >= clip->GetStartTime() && t0 <= clip->GetEndTime())
      if (t1 >= clip->GetPlayStartTime() && t0 <= clip->GetPlayEndTime())
      {
         const auto clipStart = std::max(t0, clip->GetPlayStartTime());
         const auto clipEnd = std::min(t1, clip->GetPlayEndTime());
 
         float cliprms = clip->GetRMS(t0, t1, mayThrow);
 
         sumsq += cliprms * cliprms * (clipEnd - clipStart);
         duration += (clipEnd - clipStart);
      }
   }
   return duration > 0 ? sqrt(sumsq / duration) : 0.0;
}

References WaveChannel::Intervals(), min(), staffpad::audio::simd::sqrt(), and THROW_INCONSISTENCY_EXCEPTION.

Referenced by ContrastBase::GetDB(), LoudnessBase::GetTrackRMS(), and NyquistBase::ProcessOne().

Here is the call graph for this function:

Here is the caller graph for this function:

IsSortedByPlayStartTime() [1/2]

bool WaveChannelUtilities::IsSortedByPlayStartTime ( const ClipConstPointers &  clips )

inline

Definition at line 51 of file WaveChannelUtilities.h.

{
   return is_sorted(
      clips.begin(), clips.end(), CompareClipPointersByPlayStartTime);
}

References CompareClipPointersByPlayStartTime().

Here is the call graph for this function:

IsSortedByPlayStartTime() [2/2]

bool WaveChannelUtilities::IsSortedByPlayStartTime ( const ClipPointers &  clips )

inline

Definition at line 45 of file WaveChannelUtilities.h.

{
   return is_sorted(
      clips.begin(), clips.end(), CompareClipPointersByPlayStartTime);
}

References CompareClipPointersByPlayStartTime().

Referenced by anonymous_namespace{WaveChannelUtilities.cpp}::DoGetNextClip(), GetAdjacentClip(), and GetNextClip().

Here is the call graph for this function:

Here is the caller graph for this function:

SetFloatAtTime()

void WaveChannelUtilities::SetFloatAtTime	(	WaveChannel &	channel,
		double	t,
		float	value,
		sampleFormat	effectiveFormat
	)

Sets sample nearest to t to value. Silently fails if GetClipAtTime(t) == nullptr.

Definition at line 259 of file WaveChannelUtilities.cpp.

{
   SetFloatsCenteredAroundTime(channel, t, &value, 0u, effectiveFormat);
}

References SetFloatsCenteredAroundTime().

Referenced by SampleHandle::Click().

Here is the call graph for this function:

Here is the caller graph for this function:

SetFloatsCenteredAroundTime()

void WaveChannelUtilities::SetFloatsCenteredAroundTime	(	WaveChannel &	channel,
		double	t,
		const float *	buffer,
		size_t	numSideSamples,
		sampleFormat	effectiveFormat
	)

Similar to GetFloatsCenteredAroundTime, but for writing. Sets as many samples as it can according to the same rules as GetFloatsCenteredAroundTime. Leaves the other samples untouched.

See also

GetFloatsCenteredAroundTime

Definition at line 221 of file WaveChannelUtilities.cpp.

{
   SetFloatsFromTime(channel,
      t, buffer, numSideSamples, effectiveFormat,
      PlaybackDirection::backward);
   SetFloatsFromTime(channel,
      t, buffer + numSideSamples, numSideSamples + 1, effectiveFormat,
      PlaybackDirection::forward);
}

References backward, forward, and SetFloatsFromTime().

Referenced by SampleHandle::Click(), and SetFloatAtTime().

Here is the call graph for this function:

Here is the caller graph for this function:

SetFloatsFromTime() [1/2]

WAVE_TRACK_API void WaveChannelUtilities::SetFloatsFromTime	(	Clip &	channel,
		double	t,
		const float *	buffer,
		size_t	numSamples,
		sampleFormat	effectiveFormat,
		PlaybackDirection	direction
	)

Similar to GetFloatsFromTime, but for writing. Sets as many samples as it can according to the same rules as GetFloatsFromTime. Leaves the other samples untouched.

See also

GetFloatsFromTime

SetFloatsFromTime() [2/2]

void WaveChannelUtilities::SetFloatsFromTime	(	WaveChannel &	channel,
		double	t,
		const float *	buffer,
		size_t	numSamples,
		sampleFormat	effectiveFormat,
		PlaybackDirection	direction
	)

Similar to GetFloatsFromTime, but for writing. Sets as many samples as it can according to the same rules as GetFloatsFromTime. Leaves the other samples untouched.

See also

GetFloatsFromTime

Definition at line 233 of file WaveChannelUtilities.cpp.

{
   RoundToNearestClipSample(channel, t);
   auto clip = GetClipAtTime(channel, t);
   auto numSamplesWritten = 0u;
   const auto forward = direction == PlaybackDirection::forward;
   const auto clips = SortedClipArray(channel);
   while (clip)
   {
      const auto args = GetSampleAccessArgs(
         *clip, t, buffer, numSamples, numSamplesWritten, forward);
      if (args.len > 0u)
      {
         clip->SetSamples(
            args.offsetBuffer, floatSample, args.start, args.len,
            effectiveFormat);
         numSamplesWritten += args.len;
         if (numSamplesWritten >= numSamples)
            break;
      }
      clip = GetAdjacentClip(clips, *clip, direction);
   }
}

References floatSample, forward, GetAdjacentClip(), GetClipAtTime(), anonymous_namespace{WaveChannelUtilities.cpp}::GetSampleAccessArgs(), anonymous_namespace{WaveChannelUtilities.cpp}::RoundToNearestClipSample(), and SortedClipArray().

Referenced by SetFloatsCenteredAroundTime().

Here is the call graph for this function:

Here is the caller graph for this function:

SetFloatsWithinTimeRange()

void WaveChannelUtilities::SetFloatsWithinTimeRange	(	WaveChannel &	channel,
		double	t0,
		double	t1,
		const std::function< float(double sampleTime)> &	producer,
		sampleFormat	effectiveFormat
	)

Provides a means of setting clip values as a function of time. Included are closest sample to t0 up to closest sample to t1, exclusively. If the given interval is empty, i.e., t0 >= t1, no action is taken.

Parameters

producer

a function taking sample (absolute, not clip-relative) time and returning the desired value for the sample at that time.

Definition at line 265 of file WaveChannelUtilities.cpp.

{
   if (t0 >= t1)
      return;
   const auto sortedClips = SortedClipArray(channel);
   if (sortedClips.empty())
      return;
   t0 = std::max(t0, (*sortedClips.begin())->GetPlayStartTime());
   t1 = std::min(t1, (*sortedClips.rbegin())->GetPlayEndTime());
   auto clip = GetClipAtTime(channel, t0);
   const auto clips = SortedClipArray(channel);
   while (clip) {
      const auto clipStartTime = clip->GetPlayStartTime();
      const auto clipEndTime = clip->GetPlayEndTime();
      const auto sampsPerSec = clip->GetRate() / clip->GetStretchRatio();
      const auto roundedT0 =
         std::round((t0 - clipStartTime) * sampsPerSec) / sampsPerSec +
         clipStartTime;
      const auto roundedT1 =
         std::round((t1 - clipStartTime) * sampsPerSec) / sampsPerSec +
         clipStartTime;
      if (clipStartTime > roundedT1)
         break;
      const auto tt0 = std::max(clipStartTime, roundedT0);
      const auto tt1 = std::min(clipEndTime, roundedT1);
      const size_t numSamples = (tt1 - tt0) * sampsPerSec + .5;
      std::vector<float> values(numSamples);
      for (auto i = 0u; i < numSamples; ++i)
         values[i] = producer(tt0 + clip->SamplesToTime(i));
      const size_t iChannel = clip->GetChannelIndex();
      WaveClipUtilities::SetFloatsFromTime(clip->GetClip(),
         tt0 - clipStartTime, iChannel, values.data(), numSamples,
         effectiveFormat);
      clip = GetNextClip(clips, *clip, PlaybackDirection::forward);
   }
}

References forward, GetClipAtTime(), GetNextClip(), anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel, min(), fast_float::round(), WaveClipUtilities::SetFloatsFromTime(), SortedClipArray(), and values.

Referenced by SampleHandle::Drag().

Here is the call graph for this function:

Here is the caller graph for this function:

SortedClipArray() [1/2]

auto WaveChannelUtilities::SortedClipArray

(

const WaveChannel &

channel

)

Get clips sorted by play start time.

Definition at line 405 of file WaveChannelUtilities.cpp.

{
   auto pointers = SortedClipArray(const_cast<WaveChannel &>(channel));
   return { pointers.begin(), pointers.end() };
}

References SortedClipArray().

Here is the call graph for this function:

SortedClipArray() [2/2]

auto WaveChannelUtilities::SortedClipArray

(

WaveChannel &

channel

)

Get clips sorted by play start time.

Definition at line 395 of file WaveChannelUtilities.cpp.

{
   auto &&clips = channel.Intervals();
   ClipPointers result{ clips.begin(), clips.end() };
   sort(result.begin(), result.end(), CompareClipPointersByPlayStartTime);
   return result;
}

References CompareClipPointersByPlayStartTime(), and WaveChannel::Intervals().

Referenced by SampleHandle::Drag(), WaveTrack::GetClipAtTime(), GetClipAtTime(), GetFloatsFromTime(), WaveChannelView::SelectNextClip(), SetFloatsFromTime(), SetFloatsWithinTimeRange(), and SortedClipArray().

Here is the call graph for this function:

Here is the caller graph for this function: