Collaboration diagram for WaveBitmapCache::LookupHelper:

[legend]

Public Member Functions
	LookupHelper (std::shared_ptr< WaveDataCache > dataCache)

bool	PerformLookup (WaveBitmapCache *cache, GraphicsDataCacheKey key)

Public Attributes
std::shared_ptr< WaveDataCache >	DataCache

std::array< ColorFunction, GraphicsDataCacheBase::CacheElementWidth >	ColorFunctions {}

WaveCacheElement::Columns	DBRemappedColumns {}

std::array< double, GraphicsDataCacheBase::CacheElementWidth >	EnvelopeValues {}

WaveCacheElement::Columns	EnvRemappedColumns {}

size_t	AvailableColumns { 0 }

bool	IsComplete { 0 }

Detailed Description

Definition at line 84 of file WaveBitmapCache.cpp.

Constructor & Destructor Documentation

◆ LookupHelper()

WaveBitmapCache::LookupHelper::LookupHelper ( std::shared_ptr< WaveDataCache > dataCache )

inlineexplicit

Definition at line 86 of file WaveBitmapCache.cpp.

       : DataCache(std::move(dataCache))
   {
   }

Member Function Documentation

◆ PerformLookup()

bool WaveBitmapCache::LookupHelper::PerformLookup	(	WaveBitmapCache *	cache,
		GraphicsDataCacheKey	key
	)

inline

Definition at line 91 of file WaveBitmapCache.cpp.

   {
      DataCache->UpdateViewportWidth(cache->GetMaxViewportWidth());
 
      auto result = DataCache->PerformLookup(key);
 
      if (result == nullptr)
         return false;
 
      auto sw = FrameStatistics::CreateStopwatch(
         FrameStatistics::SectionID::WaveBitmapCachePreprocess);
 
      const auto columnsCount = result->AvailableColumns;
 
      if (cache->mPaintParamters.DBScale)
      {
         auto GetDBValue =
            [dbRange = cache->mPaintParamters.DBRange](float value)
         {
            float sign = (value >= 0 ? 1 : -1);
 
            if (value != 0.)
            {
               float db = LINEAR_TO_DB(fabs(value));
               value = (db + dbRange) / dbRange;
 
               if (value < 0.0)
                  value = 0.0;
 
               value *= sign;
            }
 
            return value;
         };
 
         for (size_t column = 0; column < columnsCount; ++column)
         {
            auto oldColumn = result->Data[column];
 
            DBRemappedColumns[column] = { GetDBValue(oldColumn.min),
                                        GetDBValue(oldColumn.max),
                                        GetDBValue(oldColumn.rms) };
         }
      }
 
      auto GetRowFromValue =
         [min = cache->mPaintParamters.Min, max = cache->mPaintParamters.Max,
          height = cache->mPaintParamters.Height](float value)
      {
         value = (max - value) / (max - min);
         return static_cast<int>(value * (height - 1) + 0.5);
      };
 
      const auto height = cache->mPaintParamters.Height;
 
      auto inputData = cache->mPaintParamters.DBScale ?
                          DBRemappedColumns.data() :
                          result->Data.data();
 
      auto envelope = cache->mEnvelope;
 
      if (
         envelope != nullptr && (envelope->GetNumberOfPoints() > 0 ||
                                 envelope->GetDefaultValue() != 1.0))
      {
         envelope->GetValues(
            EnvelopeValues.data(), static_cast<int>(EnvelopeValues.size()),
            key.FirstSample / cache->GetScaledSampleRate(),
            1.0 / key.PixelsPerSecond);
 
         for (size_t column = 0; column < columnsCount; ++column)
         {
            const auto columnData = inputData[column];
            const float envelopeValue = EnvelopeValues[column];
 
            EnvRemappedColumns[column] = {
               columnData.min * envelopeValue,
               columnData.max * envelopeValue,
               columnData.rms * envelopeValue
            };
         }
 
         inputData = EnvRemappedColumns.data();
      }
 
      const bool hasTopBlankArea = cache->mPaintParamters.Max > 1.0;
      const auto globalMaxRow = GetRowFromValue(cache->mPaintParamters.Max);
      const auto globalMinRow = GetRowFromValue(cache->mPaintParamters.Min) + 1;
 
      const auto blankColor = cache->mPaintParamters.BlankColor;
 
      const auto backgroundColors = cache->mPaintParamters.BackgroundColors;
      const auto sampleColors = cache->mPaintParamters.SampleColors;
      const auto rmsColors = cache->mPaintParamters.RMSColors;
      const auto clipColors = cache->mPaintParamters.ClippingColors;
      const auto showRMS = cache->mPaintParamters.ShowRMS;
 
      auto firstPixel = int64_t(key.FirstSample / cache->GetScaledSampleRate() * key.PixelsPerSecond + 0.5);
 
      const auto selFirst = cache->mSelection.FirstPixel;
      const auto selLast = cache->mSelection.LastPixel;
 
      const bool showClipping = cache->mPaintParamters.ShowClipping;
 
      for (size_t column = 0; column < columnsCount; ++column)
      {
         const bool selected = firstPixel >= selFirst && firstPixel < selLast;
         ++firstPixel;
 
         const auto columnData = inputData[column];
         auto& function = ColorFunctions[column];
 
         if (showClipping && (columnData.min <= -MAX_AUDIO || columnData.max >= MAX_AUDIO))
         {
            function.SetStop(
               0, selected ? clipColors.Selected : clipColors.Normal, height);
 
            continue;
         }
 
         size_t stopIndex = 0;
 
         if (hasTopBlankArea)
            function.SetStop(stopIndex++, blankColor, globalMaxRow);
 
         const auto maxRow = GetRowFromValue(columnData.max);
 
         if (maxRow > 0)
         {
            function.SetStop(
               stopIndex++,
               selected ? backgroundColors.Selected : backgroundColors.Normal,
               maxRow);
         }
 
         if (maxRow >= height)
            continue;
 
         if (showRMS)
         {
            const auto positiveRMSRow = GetRowFromValue(columnData.rms);
 
            if (maxRow < positiveRMSRow)
            {
               function.SetStop(
                  stopIndex++,
                  selected ? sampleColors.Selected : sampleColors.Normal,
                  positiveRMSRow);
            }
 
            if (positiveRMSRow >= height)
               continue;
 
            const auto negativeRMSRow =
               GetRowFromValue(std::max(-columnData.rms, columnData.min));
 
            if (positiveRMSRow < negativeRMSRow)
            {
               function.SetStop(
                  stopIndex++, selected ? rmsColors.Selected : rmsColors.Normal,
                  negativeRMSRow);
            }
 
            if (negativeRMSRow >= height)
               continue;
         }
 
         const auto minRow = GetRowFromValue(columnData.min);
 
         // if minRow == maxRow - we want to display it as a single pixel
         function.SetStop(
            stopIndex++, selected ? sampleColors.Selected : sampleColors.Normal,
            minRow != maxRow ? minRow : minRow + 1);
 
         if (minRow < globalMinRow)
         {
            function.SetStop(
               stopIndex++,
               selected ? backgroundColors.Selected : backgroundColors.Normal,
               globalMinRow);
         }
 
         if (globalMinRow < height)
            function.SetStop(stopIndex++, blankColor, height);
      }
 
      AvailableColumns = columnsCount;
      IsComplete = result->IsComplete;
 
      return true;
   }