WaveClipWaveformCache Struct Reference

#include <WaveformCache.h>

Inheritance diagram for WaveClipWaveformCache:

Collaboration diagram for WaveClipWaveformCache:

Public Member Functions
	WaveClipWaveformCache (size_t nChannels)
	~WaveClipWaveformCache () override
std::unique_ptr< WaveClipListener >	Clone () const override
void	MarkChanged () noexcept override
void	Invalidate () override
void	Clear ()
	Delete the wave cache - force redraw. Thread-safe. More...
bool	GetWaveDisplay (const WaveChannelInterval &clip, WaveDisplay &display, double t0, double pixelsPerSecond)
void	MakeStereo (WaveClipListener &&other, bool aligned) override
void	SwapChannels () override
	Default implementation does nothing. More...
void	Erase (size_t index) override
Public Member Functions inherited from WaveClipListener
virtual	~WaveClipListener ()=0
virtual void	MarkChanged () noexcept=0
virtual void	Invalidate ()=0
virtual void	WriteXMLAttributes (XMLWriter &writer) const
virtual bool	HandleXMLAttribute (const std::string_view &attr, const XMLAttributeValueView &valueView)
virtual void	MakeStereo (WaveClipListener &&other, bool aligned)
virtual void	SwapChannels ()
	Default implementation does nothing. More...
virtual void	Erase (size_t index)

Static Public Member Functions
static WaveClipWaveformCache &	Get (const WaveChannelInterval &clip)

Public Attributes
std::vector< std::unique_ptr< WaveCache > >	mWaveCaches
int	mDirty { 0 }

Detailed Description

Definition at line 61 of file WaveformCache.h.

Constructor & Destructor Documentation

WaveClipWaveformCache()

WaveClipWaveformCache::WaveClipWaveformCache ( size_t  nChannels )

explicit

Definition at line 271 of file WaveformCache.cpp.

   : mWaveCaches(nChannels)
{
   for (auto &pCache : mWaveCaches)
      pCache = std::make_unique<WaveCache>();
}

References mWaveCaches.

~WaveClipWaveformCache()

WaveClipWaveformCache::~WaveClipWaveformCache ( )

override

Definition at line 278 of file WaveformCache.cpp.

{
}

Member Function Documentation

Clear()

void WaveClipWaveformCache::Clear

(

)

Delete the wave cache - force redraw. Thread-safe.

Clone()

std::unique_ptr< WaveClipListener > WaveClipWaveformCache::Clone ( ) const

override

Definition at line 282 of file WaveformCache.cpp.

{
   // Don't need to copy contents
   return std::make_unique<WaveClipWaveformCache>(mWaveCaches.size());
}

References mWaveCaches.

Erase()

void WaveClipWaveformCache::Erase ( size_t  index )

overridevirtual

Erase attachment at a given index, if it existed, moving later-indexed attachments to earlier indices

Default implementation does nothing

Reimplemented from WaveClipListener.

Definition at line 324 of file WaveformCache.cpp.

{
   if (index < mWaveCaches.size())
      mWaveCaches.erase(mWaveCaches.begin() + index);
}

References mWaveCaches.

Get()

WaveClipWaveformCache & WaveClipWaveformCache::Get ( const WaveChannelInterval &  clip )

static

Definition at line 293 of file WaveformCache.cpp.

{
   return const_cast<WaveClip&>(clip.GetClip()) // Consider it mutable data
      .Attachments::Get< WaveClipWaveformCache >( sKeyW );
}

References WaveClipChannel::GetClip(), and sKeyW.

Referenced by anonymous_namespace{WaveformView.cpp}::DrawClipWaveform().

Here is the call graph for this function:

Here is the caller graph for this function:

GetWaveDisplay()

bool WaveClipWaveformCache::GetWaveDisplay	(	const WaveChannelInterval &	clip,
		WaveDisplay &	display,
		double	t0,
		double	pixelsPerSecond
	)

Getting high-level data for screen display

Definition at line 66 of file WaveformCache.cpp.

{
   auto &waveCache = mWaveCaches[clip.GetChannelIndex()];
 
   t0 += clip.GetTrimLeft();
 
   const bool allocated = (display.where != 0);
 
   const size_t numPixels = (int)display.width;
 
   size_t p0 = 0;         // least column requiring computation
   size_t p1 = numPixels; // greatest column requiring computation, plus one
 
   float *min;
   float *max;
   float *rms;
   std::vector<sampleCount> *pWhere;
 
   if (allocated) {
      // assume ownWhere is filled.
      min = &display.min[0];
      max = &display.max[0];
      rms = &display.rms[0];
      pWhere = &display.ownWhere;
   }
   else {
      const auto sampleRate = clip.GetRate();
      const auto stretchRatio = clip.GetStretchRatio();
      const double samplesPerPixel =
         sampleRate / pixelsPerSecond / stretchRatio;
 
      // Make a tolerant comparison of the samples-per-pixel values in this wise:
      // accumulated difference of times over the number of pixels is less than
      // a sample period.
      const bool samplesPerPixelMatch =
         waveCache &&
         (fabs(samplesPerPixel - waveCache->samplesPerPixel) * numPixels < 1.0);
 
      const bool match = waveCache && samplesPerPixelMatch &&
                         waveCache->len > 0 && waveCache->dirty == mDirty;
 
      if (match &&
         waveCache->start == t0 &&
         waveCache->len >= numPixels) {
 
         // Satisfy the request completely from the cache
         display.min = &waveCache->min[0];
         display.max = &waveCache->max[0];
         display.rms = &waveCache->rms[0];
         display.where = &waveCache->where[0];
         return true;
      }
 
      std::unique_ptr<WaveCache> oldCache(std::move(waveCache));
 
      int oldX0 = 0;
      double correction = 0.0;
      size_t copyBegin = 0, copyEnd = 0;
      if (match) {
         WaveClipUIUtilities::findCorrection(
            oldCache->where, oldCache->len, numPixels, t0, sampleRate,
            stretchRatio, samplesPerPixel, oldX0, correction);
         // Remember our first pixel maps to oldX0 in the old cache,
         // possibly out of bounds.
         // For what range of pixels can data be copied?
         copyBegin = std::min<size_t>(numPixels, std::max(0, -oldX0));
         copyEnd = std::min<size_t>(numPixels, std::max(0,
            (int)oldCache->len - oldX0
         ));
      }
      if (!(copyEnd > copyBegin))
         oldCache.reset(0);
 
      waveCache = std::make_unique<WaveCache>(
         numPixels, samplesPerPixel, sampleRate, t0, mDirty);
      min = &waveCache->min[0];
      max = &waveCache->max[0];
      rms = &waveCache->rms[0];
      pWhere = &waveCache->where;
 
      constexpr auto addBias = false;
      WaveClipUIUtilities::fillWhere(
         *pWhere, numPixels, addBias, correction, t0, sampleRate, stretchRatio,
         samplesPerPixel);
 
      // The range of pixels we must fetch from the Sequence:
      p0 = (copyBegin > 0) ? 0 : copyEnd;
      p1 = (copyEnd >= numPixels) ? copyBegin : numPixels;
 
      // Optimization: if the old cache is good and overlaps
      // with the current one, re-use as much of the cache as
      // possible
 
      if (oldCache) {
 
         // Copy what we can from the old cache.
         const int length = copyEnd - copyBegin;
         const size_t sizeFloats = length * sizeof(float);
         const int srcIdx = (int)copyBegin + oldX0;
         memcpy(&min[copyBegin], &oldCache->min[srcIdx], sizeFloats);
         memcpy(&max[copyBegin], &oldCache->max[srcIdx], sizeFloats);
         memcpy(&rms[copyBegin], &oldCache->rms[srcIdx], sizeFloats);
      }
   }
 
   if (p1 > p0) {
      // Cache was not used or did not satisfy the whole request
      std::vector<sampleCount> &where = *pWhere;
 
      /* handle values in the append buffer */
 
      const auto &sequence = clip.GetSequence();
      auto numSamples = sequence.GetNumSamples();
      auto a = p0;
 
      // Not all of the required columns might be in the sequence.
      // Some might be in the append buffer.
      for (; a < p1; ++a) {
         if (where[a + 1] > numSamples)
            break;
      }
 
      // Handle the columns that land in the append buffer.
      //compute the values that are outside the overlap from scratch.
      if (a < p1) {
         const auto appendBufferLen = clip.GetAppendBufferLen();
         const auto &appendBuffer = clip.GetAppendBuffer();
         sampleFormat seqFormat = sequence.GetSampleFormats().Stored();
         bool didUpdate = false;
         for(auto i = a; i < p1; i++) {
            auto left = std::max(sampleCount{ 0 },
                                 where[i] - numSamples);
            auto right = std::min(sampleCount{ appendBufferLen },
                                  where[i + 1] - numSamples);
 
            //wxCriticalSectionLocker locker(mAppendCriticalSection);
 
            if (right > left) {
               Floats b;
               const float *pb{};
               // left is nonnegative and at most mAppendBufferLen:
               auto sLeft = left.as_size_t();
               // The difference is at most mAppendBufferLen:
               size_t len = ( right - left ).as_size_t();
 
               if (seqFormat == floatSample)
                  pb = &((const float *)appendBuffer)[sLeft];
               else {
                  b.reinit(len);
                  pb = b.get();
                  SamplesToFloats(
                     appendBuffer + sLeft * SAMPLE_SIZE(seqFormat),
                     seqFormat, b.get(), len);
               }
 
               float theMax, theMin, sumsq;
               {
                  const float val = pb[0];
                  theMax = theMin = val;
                  sumsq = val * val;
               }
               for(decltype(len) j = 1; j < len; j++) {
                  const float val = pb[j];
                  theMax = std::max(theMax, val);
                  theMin = std::min(theMin, val);
                  sumsq += val * val;
               }
 
               min[i] = theMin;
               max[i] = theMax;
               rms[i] = (float)sqrt(sumsq / len);
 
               didUpdate=true;
            }
         }
 
         // Shrink the right end of the range to fetch from Sequence
         if(didUpdate)
            p1 = a;
      }
 
      // Done with append buffer, now fetch the rest of the cache miss
      // from the sequence
      if (p1 > p0) {
         if (!::GetWaveDisplay(sequence, &min[p0], &max[p0], &rms[p0], p1 - p0,
            &where[p0]))
         {
            return false;
         }
      }
   }
 
   if (!allocated) {
      // Now report the results
      display.min = min;
      display.max = max;
      display.rms = rms;
      display.where = &(*pWhere)[0];
   }
 
   return true;
}

References WaveClipUIUtilities::fillWhere(), WaveClipUIUtilities::findCorrection(), floatSample, WaveClipChannel::GetAppendBuffer(), WaveClipChannel::GetAppendBufferLen(), WaveClipChannel::GetChannelIndex(), Sequence::GetNumSamples(), WaveClipChannel::GetRate(), WaveClipChannel::GetSequence(), WaveClipChannel::GetStretchRatio(), WaveClipChannel::GetTrimLeft(), GetWaveDisplay(), WaveDisplay::max, mDirty, min(), WaveDisplay::min, mWaveCaches, WaveDisplay::ownWhere, ArrayOf< X >::reinit(), WaveDisplay::rms, SAMPLE_SIZE, anonymous_namespace{ClipSegmentTest.cpp}::sampleRate, SamplesToFloats(), staffpad::audio::simd::sqrt(), WaveDisplay::where, and WaveDisplay::width.

Referenced by GetWaveDisplay().

Here is the call graph for this function:

Here is the caller graph for this function:

Invalidate()

void WaveClipWaveformCache::Invalidate ( )

overridevirtual

Implements WaveClipListener.

Definition at line 304 of file WaveformCache.cpp.

{
   // Invalidate wave display caches
   for (auto &pCache : mWaveCaches)
      pCache = std::make_unique<WaveCache>();
}

References mWaveCaches.

MakeStereo()

void WaveClipWaveformCache::MakeStereo ( WaveClipListener &&  other, bool  aligned  )

overridevirtual

Append the other's attachments to this, assuming concrete subclasses are the same

Default implementation does nothing

Parameters

aligned

whether the strong invariant condition on the clip may be assumed

Precondition

typeid(*this) == typeid(other)

Reimplemented from WaveClipListener.

Definition at line 311 of file WaveformCache.cpp.

{
   auto pOther = dynamic_cast<WaveClipWaveformCache *>(&other);
   assert(pOther); // precondition
   mWaveCaches.push_back(move(pOther->mWaveCaches[0]));
}

References mWaveCaches.

MarkChanged()

void WaveClipWaveformCache::MarkChanged ( )

overridevirtualnoexcept

Implements WaveClipListener.

Definition at line 299 of file WaveformCache.cpp.

{
   ++mDirty;
}

References mDirty.

SwapChannels()

void WaveClipWaveformCache::SwapChannels ( )

overridevirtual

Default implementation does nothing.

Reimplemented from WaveClipListener.

Definition at line 318 of file WaveformCache.cpp.

{
   mWaveCaches.resize(2);
   std::swap(mWaveCaches[0], mWaveCaches[1]);
}

References mWaveCaches, and anonymous_namespace{NoteTrack.cpp}::swap().

Here is the call graph for this function:

Member Data Documentation

mDirty

int WaveClipWaveformCache::mDirty { 0 }

Definition at line 70 of file WaveformCache.h.

Referenced by GetWaveDisplay(), and MarkChanged().

mWaveCaches

std::vector<std::unique_ptr<WaveCache> > WaveClipWaveformCache::mWaveCaches

Definition at line 69 of file WaveformCache.h.

Referenced by Clone(), Erase(), GetWaveDisplay(), Invalidate(), MakeStereo(), SwapChannels(), and WaveClipWaveformCache().

---

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

• WaveformCache.h
• WaveformCache.cpp