anonymous_namespace{WaveTrack.cpp} Namespace Reference

Namespaces
namespace	anonymous_namespace{WaveTrack.cpp}

Classes
struct	SplitInfo
struct	WaveTrackData

Functions
WaveTrack::IntervalHolder	GetRenderedCopy (const WaveTrack::IntervalHolder &pInterval, const std::function< void(double)> &reportProgress, const SampleBlockFactoryPtr &factory, sampleFormat format)
Track::LinkType	ToLinkType (int value)
bool	ClipsAreUnique (const WaveClipHolders &clips)

Variables
static const ChannelGroup::Attachments::RegisteredFactory	waveTrackDataFactory

Detailed Description

Postcondition

result: result->GetStretchRatio() == 1

Function Documentation

ClipsAreUnique()

bool anonymous_namespace{WaveTrack.cpp}::ClipsAreUnique

(

const WaveClipHolders &

clips

)

Definition at line 3209 of file WaveTrack.cpp.

{
   // This is used only in assertions
   using Set = std::unordered_set<WaveClipHolder>;
   return clips.size() == Set{ clips.begin(), clips.end() }.size();
}

Referenced by WaveTrack::InsertInterval().

Here is the caller graph for this function:

GetRenderedCopy()

WaveTrack::IntervalHolder anonymous_namespace{WaveTrack.cpp}::GetRenderedCopy	(	const WaveTrack::IntervalHolder &	pInterval,
		const std::function< void(double)> &	reportProgress,
		const SampleBlockFactoryPtr &	factory,
		sampleFormat	format
	)

Definition at line 76 of file WaveTrack.cpp.

{
   auto &interval = *pInterval;
   using Interval = WaveTrack::Interval;
   if (!interval.HasPitchOrSpeed())
      return pInterval;
 
   const auto dst = std::make_shared<Interval>(
      interval.NChannels(), factory, format, interval.GetRate());
 
   const auto originalPlayStartTime = interval.GetPlayStartTime();
   const auto originalPlayEndTime = interval.GetPlayEndTime();
   const auto stretchRatio = interval.GetStretchRatio();
 
   auto success = false;
   Finally Do { [&] {
      if (!success)
      {
         interval.TrimLeftTo(originalPlayStartTime);
         interval.TrimRightTo(originalPlayEndTime);
      }
   } };
 
   // Leave 1 second of raw, unstretched audio before and after visible region
   // to give the algorithm a chance to be in a steady state when reaching the
   // play boundaries.
   const auto tmpPlayStartTime =
      std::max(interval.GetSequenceStartTime(), originalPlayStartTime - stretchRatio);
   const auto tmpPlayEndTime =
      std::min(interval.GetSequenceEndTime(), originalPlayEndTime + stretchRatio);
   interval.TrimLeftTo(tmpPlayStartTime);
   interval.TrimRightTo(tmpPlayEndTime);
 
   constexpr auto sourceDurationToDiscard = 0.;
   constexpr auto blockSize = 1024;
   const auto numChannels = interval.NChannels();
   ClipTimeAndPitchSource stretcherSource { interval, sourceDurationToDiscard,
                                            PlaybackDirection::forward };
   TimeAndPitchInterface::Parameters params;
   params.timeRatio = stretchRatio;
   params.pitchRatio = std::pow(2., interval.GetCentShift() / 1200.);
   params.preserveFormants =
      interval.GetPitchAndSpeedPreset() == PitchAndSpeedPreset::OptimizeForVoice;
   StaffPadTimeAndPitch stretcher { interval.GetRate(), numChannels,
                                    stretcherSource, std::move(params) };
 
   // Post-rendering sample counts, i.e., stretched units
   const auto totalNumOutSamples =
      sampleCount { interval.GetVisibleSampleCount().as_double() *
                    stretchRatio };
 
   sampleCount numOutSamples { 0 };
   AudioContainer container(blockSize, numChannels);
 
   while (numOutSamples < totalNumOutSamples)
   {
      const auto numSamplesToGet =
         limitSampleBufferSize(blockSize, totalNumOutSamples - numOutSamples);
      stretcher.GetSamples(container.Get(), numSamplesToGet);
      constSamplePtr data[2];
      data[0] = reinterpret_cast<constSamplePtr>(container.Get()[0]);
      if (interval.NChannels() == 2)
         data[1] = reinterpret_cast<constSamplePtr>(container.Get()[1]);
      dst->Append(data, floatSample, numSamplesToGet, 1, widestSampleFormat);
      numOutSamples += numSamplesToGet;
      if (reportProgress)
         reportProgress(
            numOutSamples.as_double() / totalNumOutSamples.as_double());
   }
   dst->Flush();
 
   // Now we're all like `this` except unstretched. We can clear leading and
   // trailing, stretching transient parts.
   dst->SetPlayStartTime(tmpPlayStartTime);
   dst->ClearLeft(originalPlayStartTime);
   dst->ClearRight(originalPlayEndTime);
 
   // We don't preserve cutlines but the relevant part of the envelope.
   auto dstEnvelope = std::make_unique<Envelope>(interval.GetEnvelope());
   const auto samplePeriod = 1. / interval.GetRate();
   dstEnvelope->CollapseRegion(
      originalPlayEndTime, interval.GetSequenceEndTime() + samplePeriod, samplePeriod);
   dstEnvelope->CollapseRegion(0, originalPlayStartTime, samplePeriod);
   dstEnvelope->SetOffset(originalPlayStartTime);
   dst->SetEnvelope(move(dstEnvelope));
 
   success = true;
 
   assert(!dst->HasPitchOrSpeed());
   return dst;
}

References sampleCount::as_double(), factory, floatSample, anonymous_namespace{ExportPCM.cpp}::format, forward, AudioContainer::Get(), limitSampleBufferSize(), min(), OptimizeForVoice, params, and widestSampleFormat.

Here is the call graph for this function:

ToLinkType()

Track::LinkType anonymous_namespace{WaveTrack.cpp}::ToLinkType

(

int

value

)

Definition at line 345 of file WaveTrack.cpp.

{
   if (value < 0)
      return Track::LinkType::None;
   else if (value > 3)
      return Track::LinkType::Group;
   return static_cast<Track::LinkType>(value);
}

References ChannelGroup::Group, and ChannelGroup::None.

Referenced by WaveTrack::HandleXMLTag().

Here is the caller graph for this function:

Variable Documentation

waveTrackDataFactory

const ChannelGroup::Attachments::RegisteredFactory anonymous_namespace{WaveTrack.cpp}::waveTrackDataFactory

static

Initial value:

{
   [](auto &) { return std::make_unique<WaveTrackData>(); } }

Definition at line 247 of file WaveTrack.cpp.

Referenced by anonymous_namespace{WaveTrack.cpp}::WaveTrackData::Get().