anonymous_namespace{WaveDataCache.cpp} Namespace Reference

Classes
class	AppendBufferHelper

Functions
WaveDataCache::DataProvider	MakeDefaultDataProvider (const WaveClip &clip, int channelIndex)
template<size_t blockSize>
void	processBlock (const float *input, int64_t from, size_t count, WaveCacheSampleBlock::Summary &summary)

Detailed Description

---

Audacity: A Digital Audio Editor

WaveDataCache.cpp

Dmitry Vedenko

Function Documentation

MakeDefaultDataProvider()

WaveDataCache::DataProvider anonymous_namespace{WaveDataCache.cpp}::MakeDefaultDataProvider	(	const WaveClip &	clip,
		int	channelIndex
	)

Definition at line 188 of file WaveDataCache.cpp.

{
   return [sequence = clip.GetSequence(channelIndex), clip = &clip,
           channelIndex, appendBufferHelper = AppendBufferHelper()](
             int64_t requiredSample, WaveCacheSampleBlock::Type dataType,
             WaveCacheSampleBlock& outBlock) mutable
   {
      if (requiredSample < 0)
         return false;
 
      auto sequenceSampleCount = sequence->GetNumSamples();
      if (requiredSample >= sequenceSampleCount)
      {
         auto appendBufferOffset = requiredSample - sequence->GetNumSamples().as_long_long();
 
         if (appendBufferOffset >= clip->GetAppendBufferLen(channelIndex))
            return false;
 
         outBlock.DataType    = dataType;
         outBlock.FirstSample = sequenceSampleCount.as_long_long();
         outBlock.NumSamples  = clip->GetAppendBufferLen(channelIndex);
 
         bool success = appendBufferHelper.FillBuffer(*clip, outBlock, channelIndex);
 
         // While we were filling outBlock from the append buffer
         // it wasn't flushed to sequence, we are good to go 
         if (sequenceSampleCount == sequence->GetNumSamples()) {
            return success;
         }
         
         if (requiredSample >= sequence->GetNumSamples()) {
            return false;
         }
         // if the data was moved to sequence,
         // then continue with the rest of the function
      }
 
      const auto blockIndex  = sequence->FindBlock(requiredSample);
      const auto& inputBlock = sequence->GetBlockArray()[blockIndex];
 
      outBlock.FirstSample = inputBlock.start.as_long_long();
      outBlock.NumSamples  = inputBlock.sb->GetSampleCount();
 
      switch (dataType)
      {
      case WaveCacheSampleBlock::Type::Samples:
      {
         samplePtr ptr = static_cast<samplePtr>(
            static_cast<void*>(outBlock.GetWritePointer(outBlock.NumSamples)));
 
         inputBlock.sb->GetSamples(
            ptr, floatSample, 0, outBlock.NumSamples, false);
      }
      break;
      case WaveCacheSampleBlock::Type::MinMaxRMS256:
      {
         size_t framesCount = RoundUpUnsafe(outBlock.NumSamples, 256);
 
         float* ptr =
            static_cast<float*>(outBlock.GetWritePointer(framesCount * 3));
 
         inputBlock.sb->GetSummary256(ptr, 0, framesCount);
      }
      break;
      case WaveCacheSampleBlock::Type::MinMaxRMS64k:
      {
         size_t framesCount = RoundUpUnsafe(outBlock.NumSamples, 64 * 1024);
 
         float* ptr =
            static_cast<float*>(outBlock.GetWritePointer(framesCount * 3));
 
         inputBlock.sb->GetSummary64k(ptr, 0, framesCount);
      }
      break;
      default:
         return false;
      }
 
      outBlock.DataType = dataType;
 
      return true;
   };
}

References floatSample, WaveClip::GetAppendBufferLen(), WaveClip::GetSequence(), WaveCacheSampleBlock::MinMaxRMS256, WaveCacheSampleBlock::MinMaxRMS64k, RoundUpUnsafe(), and WaveCacheSampleBlock::Samples.

Here is the call graph for this function:

processBlock()

template<size_t blockSize>

void anonymous_namespace{WaveDataCache.cpp}::processBlock	(	const float *	input,
		int64_t	from,
		size_t	count,
		WaveCacheSampleBlock::Summary &	summary
	)

Definition at line 408 of file WaveDataCache.cpp.

{
   input = input + 3 * (from / blockSize);
   count = RoundUpUnsafe(count, blockSize);
 
   float min        = summary.Min;
   float max        = summary.Max;
   double squareSum = summary.SquaresSum;
 
   for (size_t idx = 0; idx < count; ++idx)
   {
      min = std::min(min, *input++);
      max = std::max(max, *input++);
 
      const double rms = *input++;
 
      squareSum += rms * rms * blockSize;
   }
 
   // By construction, min should be always not greater than max.
   assert(min <= max);
 
   summary.Min        = min;
   summary.Max        = max;
   summary.SquaresSum = squareSum;
   summary.SumItemsCount += count * blockSize;
}

References WaveCacheSampleBlock::Summary::Max, WaveCacheSampleBlock::Summary::Min, min(), RoundUpUnsafe(), WaveCacheSampleBlock::Summary::SquaresSum, and WaveCacheSampleBlock::Summary::SumItemsCount.

Here is the call graph for this function: