anonymous_namespace{WaveDataCache.cpp}::AppendBufferHelper Class Reference

Collaboration diagram for anonymous_namespace{WaveDataCache.cpp}::AppendBufferHelper:

Classes
struct	CacheItem

Public Member Functions
bool	FillBuffer (const WaveClip &clip, WaveCacheSampleBlock &outBlock, int channelIndex) noexcept

Private Member Functions
const float *	GetAppendBufferPointer (const WaveClip &clip, int channelIndex)
template<size_t blockSize>
void	FillBlocksFromAppendBuffer (const float *bufferSamples, size_t samplesCount, WaveCacheSampleBlock &outBlock)

Private Attributes
WaveCacheSampleBlock::Type	mSampleType
sampleCount	mFirstClipSampleID { 0 }
std::vector< CacheItem >	mCachedData
std::vector< float >	mConvertedAppendBufferData
size_t	mLastProcessedSample { 0 }

Detailed Description

Definition at line 32 of file WaveDataCache.cpp.

Member Function Documentation

FillBlocksFromAppendBuffer()

template<size_t blockSize>

void anonymous_namespace{WaveDataCache.cpp}::AppendBufferHelper::FillBlocksFromAppendBuffer ( const float *  bufferSamples, size_t  samplesCount, WaveCacheSampleBlock &  outBlock  )

inlineprivate

Definition at line 125 of file WaveDataCache.cpp.

   {
      const size_t startingBlock = mLastProcessedSample / blockSize;
      const size_t blocksCount   = RoundUpUnsafe(samplesCount, blockSize);
 
      for (size_t blockIndex = startingBlock; blockIndex < blocksCount;
           ++blockIndex)
      {
         const size_t samplesInBlock =
            std::min(blockSize, samplesCount - blockIndex * blockSize);
 
         float min = std::numeric_limits<float>::infinity();
         float max = -std::numeric_limits<float>::infinity();
 
         double sqSum = 0.0;
 
         auto samples = bufferSamples + blockIndex * blockSize;
 
         for (size_t sampleIndex = 0; sampleIndex < samplesInBlock;
              ++sampleIndex)
         {
            const float sample = *samples++;
 
            min = std::min(min, sample);
            max = std::max(max, sample);
 
            const double dbl = sample;
 
            sqSum += dbl * dbl;
         }
 
         const auto rms = static_cast<float>(std::sqrt(sqSum / samplesInBlock));
 
         mCachedData[blockIndex] = { min, max, rms };
      }
 
      mLastProcessedSample = samplesCount;
      auto ptr             = outBlock.GetWritePointer(
         sizeof(CacheItem) * blocksCount / sizeof(float));
 
      std::memmove(ptr, mCachedData.data(), sizeof(CacheItem) * blocksCount);
   }

References WaveCacheSampleBlock::GetWritePointer(), min(), RoundUpUnsafe(), and staffpad::audio::simd::sqrt().

Here is the call graph for this function:

FillBuffer()

bool anonymous_namespace{WaveDataCache.cpp}::AppendBufferHelper::FillBuffer ( const WaveClip &  clip, WaveCacheSampleBlock &  outBlock, int  channelIndex  )

inlinenoexcept

Definition at line 35 of file WaveDataCache.cpp.

   {
      if (
         mFirstClipSampleID != clip.GetSequence(0)->GetNumSamples() ||
         mSampleType != outBlock.DataType)
      {
         mFirstClipSampleID   = clip.GetSequence(0)->GetNumSamples();
         mLastProcessedSample = 0;
         mSampleType          = outBlock.DataType;
 
         if (mSampleType != WaveCacheSampleBlock::Type::Samples)
         {
            mCachedData.clear();
            mCachedData.resize(
               RoundUpUnsafe(clip.GetSequence(0)->GetMaxBlockSize(), 256));
         }
      }
 
      const size_t appendedSamples = clip.GetAppendBufferLen(channelIndex);
 
      if (appendedSamples == 0)
         return false;
 
      const auto appendBuffer = GetAppendBufferPointer(clip, channelIndex);
 
      switch (mSampleType)
      {
      case WaveCacheSampleBlock::Type::Samples:
      {
         float* outBuffer = outBlock.GetWritePointer(appendedSamples);
 
         std::copy(appendBuffer, appendBuffer + appendedSamples, outBuffer);
      }
      break;
      case WaveCacheSampleBlock::Type::MinMaxRMS256:
         FillBlocksFromAppendBuffer<256>(
            appendBuffer, appendedSamples, outBlock);
         break;
      case WaveCacheSampleBlock::Type::MinMaxRMS64k:
         FillBlocksFromAppendBuffer<64 * 1024>(
            appendBuffer, appendedSamples, outBlock);
         break;
      default:
         return false;
      }
 
      // If the append buffer was flushed during the copy operation,
      // then outBlock content is no longer valid
      if (mFirstClipSampleID != clip.GetSequence(0)->GetNumSamples() ||
         appendedSamples > clip.GetAppendBufferLen(channelIndex)) {
         return false;
      }
 
      return true;
   }

References staffpad::vo::copy(), WaveCacheSampleBlock::MinMaxRMS256, WaveCacheSampleBlock::MinMaxRMS64k, RoundUpUnsafe(), and WaveCacheSampleBlock::Samples.

Here is the call graph for this function:

GetAppendBufferPointer()

const float * anonymous_namespace{WaveDataCache.cpp}::AppendBufferHelper::GetAppendBufferPointer ( const WaveClip &  clip, int  channelIndex  )

inlineprivate

Definition at line 94 of file WaveDataCache.cpp.

   {
      const auto currentFormat = clip.GetSampleFormats().Stored();
      const auto appendBuffer =
         static_cast<const void*>(clip.GetAppendBuffer(channelIndex));
 
      if (currentFormat == floatSample)
         return static_cast<const float*>(appendBuffer);
 
      const auto samplesCount = clip.GetAppendBufferLen(channelIndex);
      mConvertedAppendBufferData.resize(samplesCount);
 
      if (currentFormat == int16Sample)
      {
         const auto int16Buffer = static_cast<const int16_t*>(appendBuffer);
 
         for (size_t i = 0; i < samplesCount; ++i)
            mConvertedAppendBufferData[i] = float(int16Buffer[i]) / (1 << 15);
      }
      else if (currentFormat == sampleFormat::int24Sample)
      {
         const auto int24Buffer = static_cast<const int32_t*>(appendBuffer);
 
         for (size_t i = 0; i < samplesCount; ++i)
            mConvertedAppendBufferData[i] = float(int24Buffer[i]) / (1 << 23);
      }
 
      return mConvertedAppendBufferData.data();
   }

References floatSample, WaveClip::GetAppendBuffer(), WaveClip::GetAppendBufferLen(), WaveClip::GetSampleFormats(), int16Sample, int24Sample, and SampleFormats::Stored().

Here is the call graph for this function:

Member Data Documentation

mCachedData

std::vector<CacheItem> anonymous_namespace{WaveDataCache.cpp}::AppendBufferHelper::mCachedData

private

Definition at line 182 of file WaveDataCache.cpp.

mConvertedAppendBufferData

std::vector<float> anonymous_namespace{WaveDataCache.cpp}::AppendBufferHelper::mConvertedAppendBufferData

private

Definition at line 183 of file WaveDataCache.cpp.

mFirstClipSampleID

sampleCount anonymous_namespace{WaveDataCache.cpp}::AppendBufferHelper::mFirstClipSampleID { 0 }

private

Definition at line 173 of file WaveDataCache.cpp.

mLastProcessedSample

size_t anonymous_namespace{WaveDataCache.cpp}::AppendBufferHelper::mLastProcessedSample { 0 }

private

Definition at line 184 of file WaveDataCache.cpp.

mSampleType

WaveCacheSampleBlock::Type anonymous_namespace{WaveDataCache.cpp}::AppendBufferHelper::mSampleType

private

Initial value:

{
      WaveCacheSampleBlock::Type::Samples
   }

Definition at line 170 of file WaveDataCache.cpp.

---

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

• WaveDataCache.cpp