SampleTrackCache Class Reference

A short-lived object, during whose lifetime, the contents of the WaveTrack are assumed not to change. More...

#include <SampleTrackCache.h>

Collaboration diagram for SampleTrackCache:

Classes
struct	Buffer

Public Member Functions
	SampleTrackCache ()
	SampleTrackCache (const std::shared_ptr< const WideSampleSequence > &pSequence)
	~SampleTrackCache ()
const std::shared_ptr< const WideSampleSequence > &	GetSequence () const
void	SetSequence (const std::shared_ptr< const WideSampleSequence > &pSequence)
std::pair< const float *, const float * >	GetFloatsWide (size_t nChannels, sampleCount start, size_t len, bool mayThrow)
	Retrieve samples as floats from the track or from the memory cache. More...
const float *	GetFloats (sampleCount start, size_t len, bool mayThrow)
	fetch first channel only More...

Private Member Functions
void	Free ()

Private Attributes
std::shared_ptr< const WideSampleSequence >	mpSequence
size_t	mBufferSize
Buffer	mBuffers [2]
GrowableSampleBuffer	mOverlapBuffers [2]
int	mNValidBuffers

Detailed Description

A short-lived object, during whose lifetime, the contents of the WaveTrack are assumed not to change.

It can replace repeated calls to WaveTrack::Get() (each of which opens and closes at least one block).

Definition at line 24 of file SampleTrackCache.h.

Constructor & Destructor Documentation

SampleTrackCache() [1/2]

SampleTrackCache::SampleTrackCache ( )

inline

Definition at line 26 of file SampleTrackCache.h.

      : mBufferSize(0)
      , mNValidBuffers(0)
   {
   }

SampleTrackCache() [2/2]

SampleTrackCache::SampleTrackCache ( const std::shared_ptr< const WideSampleSequence > &  pSequence )

inlineexplicit

Definition at line 32 of file SampleTrackCache.h.

      : mBufferSize(0)
      , mNValidBuffers(0)
   {
      SetSequence(pSequence);
   }

~SampleTrackCache()

SampleTrackCache::~SampleTrackCache

(

)

Definition at line 15 of file SampleTrackCache.cpp.

{
}

Member Function Documentation

Free()

void SampleTrackCache::Free ( )

private

Definition at line 238 of file SampleTrackCache.cpp.

{
   mBuffers[0].Free();
   mBuffers[1].Free();
   mOverlapBuffers[0].Free();
   mOverlapBuffers[1].Free();
   mNValidBuffers = 0;
}

References GrowableSampleBuffer::Free(), SampleTrackCache::Buffer::Free(), mBuffers, mNValidBuffers, and mOverlapBuffers.

Referenced by SetSequence().

Here is the call graph for this function:

Here is the caller graph for this function:

GetFloats()

const float * SampleTrackCache::GetFloats ( sampleCount  start, size_t  len, bool  mayThrow  )

inline

fetch first channel only

Definition at line 60 of file SampleTrackCache.h.

   {
      return GetFloatsWide(1, start, len, mayThrow).first;
   }

Referenced by SpecCache::CalculateOneSpectrum().

Here is the caller graph for this function:

GetFloatsWide()

std::pair< const float *, const float * > SampleTrackCache::GetFloatsWide	(	size_t	nChannels,
		sampleCount	start,
		size_t	len,
		bool	mayThrow
	)

Retrieve samples as floats from the track or from the memory cache.

Uses fillZero always

Returns

both null on failure; this object owns the memory; may be invalidated if GetFloats() is called again

Precondition

nChannels <= GetSequence()->NChannels()

nChannels <= 2

Definition at line 44 of file SampleTrackCache.cpp.

{
   float *overlaps[2]{};
   assert(nChannels <= GetSequence()->NChannels());
   assert(nChannels <= 2);
 
   constexpr auto format = floatSample;
   if (format == floatSample && len > 0) {
      const auto end = start + len;
 
      bool fillFirst = (mNValidBuffers < 1);
      bool fillSecond = (mNValidBuffers < 2);
 
      // Discard cached results that we no longer need
      if (mNValidBuffers > 0 &&
          (end <= mBuffers[0].start ||
           start >= mBuffers[mNValidBuffers - 1].end())) {
         // Complete miss
         fillFirst = true;
         fillSecond = true;
      }
      else if (mNValidBuffers == 2 &&
               start >= mBuffers[1].start &&
               end > mBuffers[1].end()) {
         // Request starts in the second buffer and extends past it.
         // Discard the first buffer.
         // (But don't deallocate the buffer space.)
         mBuffers[0] .swap ( mBuffers[1] );
         fillSecond = true;
         mNValidBuffers = 1;
      }
      else if (mNValidBuffers > 0 &&
         start < mBuffers[0].start &&
         0 <= mpSequence->GetBlockStart(start)) {
         // Request is not a total miss but starts before the cache,
         // and there is a clip to fetch from.
         // Not the access pattern for drawing spectrogram or playback,
         // but maybe scrubbing causes this.
         // Move the first buffer into second place, and later
         // refill the first.
         // (This case might be useful when marching backwards through
         // the sequence, as with scrubbing.)
         mBuffers[0] .swap ( mBuffers[1] );
         fillFirst = true;
         fillSecond = false;
         // Cache is not in a consistent state yet
         mNValidBuffers = 0;
      }
 
      // Refill buffers as needed
      if (fillFirst) {
         const auto start0 = mpSequence->GetBlockStart(start);
         if (start0 >= 0) {
            const auto len0 = mpSequence->GetBestBlockSize(start0);
            assert(len0 <= mBufferSize);
            if (!mpSequence->GetFloats(0, nChannels,
                  mBuffers[0].GetBuffers(), start0, len0,
                  fillZero, mayThrow))
               return { nullptr, nullptr };
            mBuffers[0].start = start0;
            mBuffers[0].len = len0;
            if (!fillSecond &&
                mBuffers[0].end() != mBuffers[1].start)
               fillSecond = true;
            // Keep the partially updated state consistent:
            mNValidBuffers = fillSecond ? 1 : 2;
         }
         else {
            // Request may fall between the clips of a sequence.
            // Invalidate all.  WaveTrack::Get() will return zeroes.
            mNValidBuffers = 0;
            fillSecond = false;
         }
      }
      assert(!fillSecond || mNValidBuffers > 0);
      if (fillSecond) {
         mNValidBuffers = 1;
         const auto end0 = mBuffers[0].end();
         if (end > end0) {
            const auto start1 = mpSequence->GetBlockStart(end0);
            if (start1 == end0) {
               const auto len1 = mpSequence->GetBestBlockSize(start1);
               assert(len1 <= mBufferSize);
               if (!mpSequence->GetFloats(0, nChannels,
                  mBuffers[1].GetBuffers(), start1, len1, fillZero, mayThrow))
                  return { nullptr, nullptr };
               mBuffers[1].start = start1;
               mBuffers[1].len = len1;
               mNValidBuffers = 2;
            }
         }
      }
      assert(mNValidBuffers < 2 || mBuffers[0].end() == mBuffers[1].start);
 
      samplePtr buffers[2]{}; // will point into mOverlapBuffers
      auto remaining = len;
      const auto resizeOverlapBuffers = [&]{
         for (size_t iChannel = 0; iChannel < nChannels; ++iChannel) {
            auto &overlapBuffer = mOverlapBuffers[iChannel];
            overlapBuffer.Resize(len, format);
            // See comment below about casting
            overlaps[iChannel] = reinterpret_cast<float*>(overlapBuffer.ptr());
         }
      };
      const auto assignBuffers = [&]{
         size_t iChannel = 0;
         for (; iChannel < nChannels; ++iChannel)
            buffers[iChannel] = reinterpret_cast<samplePtr>(overlaps[iChannel]);
         for (; iChannel < 2; ++iChannel)
            buffers[iChannel] = nullptr;
      };
 
      // Possibly get an initial portion that is uncached
 
      // This may be negative
      const auto initLen =
         mNValidBuffers < 1 ? sampleCount( len )
            : std::min(sampleCount( len ), mBuffers[0].start - start);
 
      if (initLen > 0) {
         // This might be fetching zeroes between clips
         resizeOverlapBuffers();
         // initLen is not more than len:
         auto sinitLen = initLen.as_size_t();
         if (!mpSequence->GetFloats(0, nChannels, overlaps,
            start, sinitLen, fillZero, mayThrow))
            return { nullptr, nullptr };
         assert(sinitLen <= remaining);
         remaining -= sinitLen;
         start += initLen;
         for (size_t iChannel = 0; iChannel < nChannels; ++iChannel)
            buffers[iChannel] =
               reinterpret_cast<samplePtr>(overlaps[iChannel] + sinitLen);
      }
 
      // Now satisfy the request from the buffers
      for (int ii = 0; ii < mNValidBuffers && remaining > 0; ++ii) {
         const auto starti = start - mBuffers[ii].start;
         // Treatment of initLen above establishes this loop invariant,
         // and statements below preserve it:
         assert(starti >= 0);
 
         // This may be negative
         const auto leni =
            std::min( sampleCount( remaining ), mBuffers[ii].len - starti );
         if (initLen <= 0 && leni == len) {
            // All is contiguous already.  We can completely avoid copying
            // leni is nonnegative, therefore start falls within mBuffers[ii],
            // so starti is bounded between 0 and buffer length
            return mBuffers[ii].GetResults(nChannels, starti.as_size_t());
         }
         else if (leni > 0) {
            // leni is nonnegative, therefore start falls within mBuffers[ii]
            // But we can't satisfy all from one buffer, so copy
            if (!buffers[0]) {
               resizeOverlapBuffers();
               assignBuffers();
            }
            // leni is positive and not more than remaining
            const size_t size = sizeof(float) * leni.as_size_t();
            // starti is less than mBuffers[ii].len and nonnegative
            for (size_t iChannel = 0; iChannel < nChannels; ++iChannel)
               memcpy(buffers[iChannel],
                  mBuffers[ii].areas[iChannel].get() + starti.as_size_t(),
                  size);
            assert(leni <= remaining);
            remaining -= leni.as_size_t();
            start += leni;
            for (size_t iChannel = 0; iChannel < nChannels; ++iChannel)
               buffers[iChannel] += size;
         }
      }
 
      if (remaining > 0) {
         // Very big request!
         // Fall back to direct fetch
         if (!buffers[0])
            resizeOverlapBuffers();
         // See comment below about casting
         if (!mpSequence->GetFloats(0, nChannels,
            reinterpret_cast<float**>(buffers),
            start, remaining, fillZero, mayThrow))
            return { nullptr, nullptr };
      }
 
      return { overlaps[0], overlaps[1] };
   }
   else {
      // No longer handling other than float format.  Therefore len is 0.
      return { nullptr, nullptr };
   }
}

References SampleTrackCache::Buffer::end(), PackedArray::end(), fillZero, floatSample, format, SampleTrackCache::Buffer::GetBuffers(), SampleTrackCache::Buffer::GetResults(), GetSequence(), SampleTrackCache::Buffer::len, mBuffers, mBufferSize, min(), mNValidBuffers, mOverlapBuffers, mpSequence, GrowableSampleBuffer::Resize(), size, SampleTrackCache::Buffer::start, and SampleTrackCache::Buffer::swap().

Here is the call graph for this function:

GetSequence()

const std::shared_ptr< const WideSampleSequence > & SampleTrackCache::GetSequence ( ) const

inline

Definition at line 41 of file SampleTrackCache.h.

                                                                      {
      return mpSequence;
   }

Referenced by anonymous_namespace{SpectrumView.cpp}::DrawClipSpectrum(), GetFloatsWide(), and WaveClipSpectrumCache::GetSpectrogram().

Here is the caller graph for this function:

SetSequence()

void SampleTrackCache::SetSequence

(

const std::shared_ptr< const WideSampleSequence > &

pSequence

)

Definition at line 19 of file SampleTrackCache.cpp.

{
   if (mpSequence != pSequence) {
      if (pSequence) {
         mBufferSize = pSequence->GetMaxBlockSize();
         if (!mpSequence ||
             mpSequence->GetMaxBlockSize() != mBufferSize) {
            Free();
            const auto nChannels = pSequence->NChannels();
            for (size_t ii : {0, 1}) {
               mBuffers[ii].areas.reinit(nChannels, true);
               for (size_t iChannel = 0; iChannel < nChannels; ++iChannel)
                  mBuffers[ii].areas[iChannel] = Floats{ mBufferSize };
            }
         }
      }
      else
         Free();
      mpSequence = pSequence;
      mNValidBuffers = 0;
   }
}

References SampleTrackCache::Buffer::areas, Free(), mBuffers, mBufferSize, mNValidBuffers, mpSequence, and ArraysOf< X >::reinit().

Here is the call graph for this function:

Member Data Documentation

mBuffers

Buffer SampleTrackCache::mBuffers[2]

private

Definition at line 101 of file SampleTrackCache.h.

Referenced by Free(), GetFloatsWide(), and SetSequence().

mBufferSize

size_t SampleTrackCache::mBufferSize

private

Definition at line 100 of file SampleTrackCache.h.

Referenced by GetFloatsWide(), and SetSequence().

mNValidBuffers

int SampleTrackCache::mNValidBuffers

private

Definition at line 103 of file SampleTrackCache.h.

Referenced by Free(), GetFloatsWide(), and SetSequence().

mOverlapBuffers

GrowableSampleBuffer SampleTrackCache::mOverlapBuffers[2]

private

Definition at line 102 of file SampleTrackCache.h.

Referenced by Free(), and GetFloatsWide().

mpSequence

std::shared_ptr<const WideSampleSequence> SampleTrackCache::mpSequence

private

Definition at line 99 of file SampleTrackCache.h.

Referenced by GetFloatsWide(), and SetSequence().

---

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

• SampleTrackCache.h
• SampleTrackCache.cpp