anonymous_namespace{SpectrumView.cpp} Namespace Reference

Classes
struct	Handler
struct	SpectrogramSettingsHandler

Functions
static float	findValue (const float *spectrum, float bin0, float bin1, unsigned nBins, bool autocorrelation, int gain, int range)
AColor::ColorGradientChoice	ChooseColorSet (float bin0, float bin1, float selBinLo, float selBinCenter, float selBinHi, int dashCount, bool isSpectral)
std::pair< sampleCount, sampleCount >	GetSelectedSampleIndices (const SelectedRegion &selectedRegion, const WaveChannelInterval &clip, bool trackIsSelected)
void	DrawClipSpectrum (TrackPanelDrawingContext &context, const WaveChannel &channel, const WaveChannelInterval &clip, const wxRect &rect, const std::shared_ptr< SpectralData > &mpSpectralData, bool selected)
void	DoNextPeakFrequency (AudacityProject &project, bool up)
static CommandHandlerObject &	findCommandHandler (AudacityProject &project)
auto	SpectralSelectionMenu ()

Variables
PopupMenuTable::AttachedItem	sAttachment
static const AttachedProjectObjects::RegisteredFactory	key
AttachedItem	sAttachment2

Function Documentation

ChooseColorSet()

AColor::ColorGradientChoice anonymous_namespace{SpectrumView.cpp}::ChooseColorSet ( float  bin0, float  bin1, float  selBinLo, float  selBinCenter, float  selBinHi, int  dashCount, bool  isSpectral  )

inline

Definition at line 309 of file SpectrumView.cpp.

{
   if (!isSpectral)
      return  AColor::ColorGradientTimeSelected;
   if ((selBinCenter >= 0) && (bin0 <= selBinCenter) &&
       (selBinCenter < bin1))
      return AColor::ColorGradientEdge;
   if ((0 == dashCount % 2) &&
       (((selBinLo >= 0) && (bin0 <= selBinLo) && ( selBinLo < bin1))  ||
        ((selBinHi >= 0) && (bin0 <= selBinHi) && ( selBinHi < bin1))))
      return AColor::ColorGradientEdge;
   if ((selBinLo < 0 || selBinLo < bin1) && (selBinHi < 0 || selBinHi > bin0))
      return  AColor::ColorGradientTimeAndFrequencySelected;
 
   return  AColor::ColorGradientTimeSelected;
}

References AColor::ColorGradientEdge, AColor::ColorGradientTimeAndFrequencySelected, and AColor::ColorGradientTimeSelected.

Referenced by DrawClipSpectrum().

Here is the caller graph for this function:

DoNextPeakFrequency()

void anonymous_namespace{SpectrumView.cpp}::DoNextPeakFrequency	(	AudacityProject &	project,
		bool	up
	)

Definition at line 1100 of file SpectrumView.cpp.

{
   // This only ever considered the left member of a stereo pair!
   // TODO:  account for the right hand channel too.
   // (How?  Average corresponding bin power?)
 
   auto &tracks = TrackList::Get( project );
   auto &viewInfo = ViewInfo::Get( project );
 
   // Find the first selected wave track that is in a spectrogram view.
   const auto hasSpectrum = [](const WaveTrack *wt){
      const auto displays = WaveChannelView::GetFirst(*wt).GetDisplays();
      return displays.end() != std::find(
         displays.begin(), displays.end(),
         WaveChannelSubView::Type{ WaveChannelViewConstants::Spectrum, {} });
   };
   const auto range = tracks.Selected<const WaveTrack>();
   const auto iter = find_if(begin(range), end(range), hasSpectrum);
   if (iter != end(range)) {
      SpectrumAnalyst analyst;
      auto &wt = **iter;
      SelectHandle::SnapCenterOnce(analyst,
         viewInfo, **wt.Channels().first, up);
      ProjectHistory::Get( project ).ModifyState(false);
   }
}

References ViewInfo::Get(), TrackList::Get(), WaveChannelView::GetDisplays(), WaveChannelView::GetFirst(), project, and tracks.

Referenced by anonymous_namespace{SpectrumView.cpp}::Handler::OnNextHigherPeakFrequency(), and anonymous_namespace{SpectrumView.cpp}::Handler::OnNextLowerPeakFrequency().

Here is the call graph for this function:

Here is the caller graph for this function:

DrawClipSpectrum()

void anonymous_namespace{SpectrumView.cpp}::DrawClipSpectrum	(	TrackPanelDrawingContext &	context,
		const WaveChannel &	channel,
		const WaveChannelInterval &	clip,
		const wxRect &	rect,
		const std::shared_ptr< SpectralData > &	mpSpectralData,
		bool	selected
	)

Definition at line 343 of file SpectrumView.cpp.

{
  auto &dc = context.dc;
  const auto artist = TrackArtist::Get(context);
  bool onBrushTool = artist->onBrushTool;
  const auto &selectedRegion = *artist->pSelectedRegion;
  const auto &zoomInfo = *artist->pZoomInfo;
 
#ifdef PROFILE_WAVEFORM
   Profiler profiler;
#endif
 
   //If clip is "too small" draw a placeholder instead of
   //attempting to fit the contents into a few pixels
   if (!WaveChannelView::ClipDetailsVisible(clip, zoomInfo, rect))
   {
      auto clipRect = ClipParameters::GetClipRect(clip, zoomInfo, rect);
      TrackArt::DrawClipFolded(dc, clipRect);
      return;
   }
 
   auto &settings = SpectrogramSettings::Get(channel);
   const bool autocorrelation = (settings.algorithm == SpectrogramSettings::algPitchEAC);
 
   enum { DASH_LENGTH = 10 /* pixels */ };
 
   const ClipParameters params { clip, rect, zoomInfo };
   const wxRect &hiddenMid = params.hiddenMid;
   // The "hiddenMid" rect contains the part of the display actually
   // containing the waveform, as it appears without the fisheye.  If it's empty, we're done.
   if (hiddenMid.width <= 0) {
      return;
   }
 
   const double &t0 = params.t0;
   const double playStartTime = clip.GetPlayStartTime();
 
   const auto [ssel0, ssel1] = GetSelectedSampleIndices(selectedRegion, clip,
      channel.GetTrack().GetSelected());
   const double &averagePixelsPerSecond = params.averagePixelsPerSecond;
   const double sampleRate = clip.GetRate();
   const double stretchRatio = clip.GetStretchRatio();
   const double &hiddenLeftOffset = params.hiddenLeftOffset;
   const double &leftOffset = params.leftOffset;
   const wxRect &mid = params.mid;
 
   double freqLo = SelectedRegion::UndefinedFrequency;
   double freqHi = SelectedRegion::UndefinedFrequency;
   freqLo = selectedRegion.f0();
   freqHi = selectedRegion.f1();
 
   const int &colorScheme = settings.colorScheme;
   const int &range = settings.range;
   const int &gain = settings.gain;
 
#ifdef EXPERIMENTAL_FIND_NOTES
   const bool &fftFindNotes = settings.fftFindNotes;
   const double &findNotesMinA = settings.findNotesMinA;
   const int &numberOfMaxima = settings.numberOfMaxima;
   const bool &findNotesQuantize = settings.findNotesQuantize;
#endif
#ifdef EXPERIMENTAL_FFT_Y_GRID
   const bool &fftYGrid = settings.fftYGrid;
#endif
 
   dc.SetPen(*wxTRANSPARENT_PEN);
 
   // We draw directly to a bit image in memory,
   // and then paint this directly to our offscreen
   // bitmap.  Note that this could be optimized even
   // more, but for now this is not bad.  -dmazzoni
   wxImage image((int)mid.width, (int)mid.height);
   if (!image.IsOk())
      return;
#ifdef EXPERIMENTAL_SPECTROGRAM_OVERLAY
   image.SetAlpha();
   unsigned char *alpha = image.GetAlpha();
#endif
   unsigned char *data = image.GetData();
 
   const auto half = settings.GetFFTLength() / 2;
   const double binUnit = sampleRate / (2 * half);
   const float *freq = 0;
   const sampleCount *where = 0;
   bool updated = WaveClipSpectrumCache::Get(clip).GetSpectrogram(
      clip, freq, settings, where, (size_t)hiddenMid.width, t0,
      averagePixelsPerSecond);
   auto nBins = settings.NBins();
 
   float minFreq, maxFreq;
   SpectrogramBounds::Get(channel).GetBounds(channel, minFreq, maxFreq);
 
   const SpectrogramSettings::ScaleType scaleType = settings.scaleType;
 
   // nearest frequency to each pixel row from number scale, for selecting
   // the desired fft bin(s) for display on that row
   float *bins = (float*)alloca(sizeof(*bins)*(hiddenMid.height + 1));
   {
      const NumberScale numberScale( settings.GetScale( minFreq, maxFreq ) );
 
      NumberScale::Iterator it = numberScale.begin(mid.height);
      float nextBin = std::max( 0.0f, std::min( float(nBins - 1),
         settings.findBin( *it, binUnit ) ) );
 
      int yy;
      for (yy = 0; yy < hiddenMid.height; ++yy) {
         bins[yy] = nextBin;
         nextBin = std::max( 0.0f, std::min( float(nBins - 1),
            settings.findBin( *++it, binUnit ) ) );
      }
      bins[yy] = nextBin;
   }
 
#ifdef EXPERIMENTAL_FFT_Y_GRID
   const float
      log2 = logf(2.0f),
      scale2 = (lmax - lmin) / log2,
      lmin2 = lmin / log2;
 
   ArrayOf<bool> yGrid{size_t(mid.height)};
   for (int yy = 0; yy < mid.height; ++yy) {
      float n = (float(yy) / mid.height*scale2 - lmin2) * 12;
      float n2 = (float(yy + 1) / mid.height*scale2 - lmin2) * 12;
      float f = float(minFreq) / (fftSkipPoints + 1)*powf(2.0f, n / 12.0f + lmin2);
      float f2 = float(minFreq) / (fftSkipPoints + 1)*powf(2.0f, n2 / 12.0f + lmin2);
      n = logf(f / 440) / log2 * 12;
      n2 = logf(f2 / 440) / log2 * 12;
      if (floor(n) < floor(n2))
         yGrid[yy] = true;
      else
         yGrid[yy] = false;
   }
#endif //EXPERIMENTAL_FFT_Y_GRID
 
   auto &clipCache = WaveClipSpectrumCache::Get(clip);
   auto &specPxCache = clipCache.mSpecPxCaches[clip.GetChannelIndex()];
   if (!updated && specPxCache &&
      ((int)specPxCache->len == hiddenMid.height * hiddenMid.width)
      && scaleType == specPxCache->scaleType
      && gain == specPxCache->gain
      && range == specPxCache->range
      && minFreq == specPxCache->minFreq
      && maxFreq == specPxCache->maxFreq
#ifdef EXPERIMENTAL_FFT_Y_GRID
   && fftYGrid==fftYGridOld
#endif //EXPERIMENTAL_FFT_Y_GRID
#ifdef EXPERIMENTAL_FIND_NOTES
   && fftFindNotes == artist->fftFindNotesOld
   && findNotesMinA == artist->findNotesMinAOld
   && numberOfMaxima == artist->findNotesNOld
   && findNotesQuantize == artist->findNotesQuantizeOld
#endif
   ) {
      // Wave clip's spectrum cache is up to date,
      // and so is the spectrum pixel cache
   }
   else {
      // Update the spectrum pixel cache
      specPxCache = std::make_unique<SpecPxCache>(hiddenMid.width * hiddenMid.height);
      specPxCache->scaleType = scaleType;
      specPxCache->gain = gain;
      specPxCache->range = range;
      specPxCache->minFreq = minFreq;
      specPxCache->maxFreq = maxFreq;
#ifdef EXPERIMENTAL_FIND_NOTES
      artist->fftFindNotesOld = fftFindNotes;
      artist->findNotesMinAOld = findNotesMinA;
      artist->findNotesNOld = numberOfMaxima;
      artist->findNotesQuantizeOld = findNotesQuantize;
#endif
 
#ifdef EXPERIMENTAL_FIND_NOTES
      float log2 = logf( 2.0f ),
         lmin = logf( minFreq ), lmax = logf( maxFreq ), scale = lmax - lmin,
         lmins = lmin,
         lmaxs = lmax
         ;
#endif //EXPERIMENTAL_FIND_NOTES
 
#ifdef EXPERIMENTAL_FIND_NOTES
      int maxima[128];
      float maxima0[128], maxima1[128];
      const float
         f2bin = half / (sampleRate / 2.0f),
         bin2f = 1.0f / f2bin,
         minDistance = powf(2.0f, 2.0f / 12.0f),
         i0 = expf(lmin) / binUnit,
         i1 = expf(scale + lmin) / binUnit,
         minColor = 0.0f;
      const size_t maxTableSize = 1024;
      ArrayOf<int> indexes{ maxTableSize };
#endif //EXPERIMENTAL_FIND_NOTES
 
#ifdef _OPENMP
#pragma omp parallel for
#endif
      for (int xx = 0; xx < hiddenMid.width; ++xx) {
#ifdef EXPERIMENTAL_FIND_NOTES
         int maximas = 0;
         const int x0 = nBins * xx;
         if (fftFindNotes) {
            for (int i = maxTableSize - 1; i >= 0; i--)
               indexes[i] = -1;
 
            // Build a table of (most) values, put the index in it.
            for (int i = (int)(i0); i < (int)(i1); i++) {
               float freqi = freq[x0 + (int)(i)];
               int value = (int)((freqi + gain + range) / range*(maxTableSize - 1));
               if (value < 0)
                  value = 0;
               if (value >= maxTableSize)
                  value = maxTableSize - 1;
               indexes[value] = i;
            }
            // Build from the indices an array of maxima.
            for (int i = maxTableSize - 1; i >= 0; i--) {
               int index = indexes[i];
               if (index >= 0) {
                  float freqi = freq[x0 + index];
                  if (freqi < findNotesMinA)
                     break;
 
                  bool ok = true;
                  for (int m = 0; m < maximas; m++) {
                     // Avoid to store very close maxima.
                     float maxm = maxima[m];
                     if (maxm / index < minDistance && index / maxm < minDistance) {
                        ok = false;
                        break;
                     }
                  }
                  if (ok) {
                     maxima[maximas++] = index;
                     if (maximas >= numberOfMaxima)
                        break;
                  }
               }
            }
 
// The f2pix helper macro converts a frequency into a pixel coordinate.
#define f2pix(f) (logf(f)-lmins)/(lmaxs-lmins)*hiddenMid.height
 
            // Possibly quantize the maxima frequencies and create the pixel block limits.
            for (int i = 0; i < maximas; i++) {
               int index = maxima[i];
               float f = float(index)*bin2f;
               if (findNotesQuantize)
               {
                  f = expf((int)(log(f / 440) / log2 * 12 - 0.5) / 12.0f*log2) * 440;
                  maxima[i] = f*f2bin;
               }
               float f0 = expf((log(f / 440) / log2 * 24 - 1) / 24.0f*log2) * 440;
               maxima0[i] = f2pix(f0);
               float f1 = expf((log(f / 440) / log2 * 24 + 1) / 24.0f*log2) * 440;
               maxima1[i] = f2pix(f1);
            }
         }
 
         int it = 0;
         bool inMaximum = false;
#endif //EXPERIMENTAL_FIND_NOTES
 
         for (int yy = 0; yy < hiddenMid.height; ++yy) {
            const float bin     = bins[yy];
            const float nextBin = bins[yy+1];
 
            if (settings.scaleType != SpectrogramSettings::stLogarithmic) {
               const float value = findValue
                  (freq + nBins * xx, bin, nextBin, nBins, autocorrelation, gain, range);
               specPxCache->values[xx * hiddenMid.height + yy] = value;
            }
            else {
               float value;
 
#ifdef EXPERIMENTAL_FIND_NOTES
               if (fftFindNotes) {
                  if (it < maximas) {
                     float i0 = maxima0[it];
                     if (yy >= i0)
                        inMaximum = true;
 
                     if (inMaximum) {
                        float i1 = maxima1[it];
                        if (yy + 1 <= i1) {
                           value = findValue(freq + x0, bin, nextBin, nBins, autocorrelation, gain, range);
                           if (value < findNotesMinA)
                              value = minColor;
                        }
                        else {
                           it++;
                           inMaximum = false;
                           value = minColor;
                        }
                     }
                     else {
                        value = minColor;
                     }
                  }
                  else
                     value = minColor;
               }
               else
#endif //EXPERIMENTAL_FIND_NOTES
               {
                  value = findValue
                     (freq + nBins * xx, bin, nextBin, nBins, autocorrelation, gain, range);
               }
               specPxCache->values[xx * hiddenMid.height + yy] = value;
            } // logF
         } // each yy
      } // each xx
   } // updating cache
 
   float selBinLo = settings.findBin( freqLo, binUnit);
   float selBinHi = settings.findBin( freqHi, binUnit);
   float selBinCenter = (freqLo < 0 || freqHi < 0)
      ? -1
      : settings.findBin( sqrt(freqLo * freqHi), binUnit );
 
   const bool isSpectral = settings.SpectralSelectionEnabled();
   const bool hidden = (ZoomInfo::HIDDEN == zoomInfo.GetFisheyeState());
   const int begin = hidden
      ? 0
      : std::max(0, (int)(zoomInfo.GetFisheyeLeftBoundary(-leftOffset)));
   const int end = hidden
      ? 0
      : std::min(mid.width, (int)(zoomInfo.GetFisheyeRightBoundary(-leftOffset)));
   const size_t numPixels = std::max(0, end - begin);
 
   SpecCache specCache;
 
   // need explicit resize since specCache.where[] accessed before Populate()
   specCache.Grow(numPixels, settings, -1, t0);
 
   if (numPixels > 0) {
      for (int ii = begin; ii < end; ++ii) {
         const double time = zoomInfo.PositionToTime(ii, -leftOffset) - playStartTime;
         specCache.where[ii - begin] =
            sampleCount(0.5 + sampleRate / stretchRatio * time);
      }
      specCache.Populate(
         settings, clip, 0, 0, numPixels,
         0 // FIXME: PRL -- make reassignment work with fisheye
      );
   }
 
   // build color gradient tables (not thread safe)
   if (!AColor::gradient_inited)
      AColor::PreComputeGradient();
 
   // left pixel column of the fisheye
   int fisheyeLeft = zoomInfo.GetFisheyeLeftBoundary(-leftOffset);
 
   // Bug 2389 - always draw at least one pixel of selection.
   int selectedX = zoomInfo.TimeToPosition(selectedRegion.t0(), -leftOffset);
 
#ifdef _OPENMP
#pragma omp parallel for
#endif
 
   const NumberScale numberScale(settings.GetScale(minFreq, maxFreq));
   int windowSize = mpSpectralData->GetWindowSize();
   int hopSize = mpSpectralData->GetHopSize();
   double sr = mpSpectralData->GetSR();
   auto &dataHistory = mpSpectralData->dataHistory;
 
   // Lazy way to add all hops and bins required for rendering
   dataHistory.push_back(mpSpectralData->dataBuffer);
 
   // Generate combined hops and bins map for rendering
   std::map<long long, std::set<int>> hopBinMap;
   for(auto vecIter = dataHistory.begin(); vecIter != dataHistory.end(); ++vecIter){
      for(const auto &hopMap: *vecIter){
         for(const auto &binNum: hopMap.second)
            hopBinMap[hopMap.first].insert(binNum);
      }
   }
 
   // Lambda for converting yy (not mouse coord!) to respective freq. bins
   auto yyToFreqBin = [&](int yy){
      const double p = double(yy) / hiddenMid.height;
      float convertedFreq = numberScale.PositionToValue(p);
      float convertedFreqBinNum = convertedFreq / (sr / windowSize);
 
      // By default lrintf will round to nearest by default, rounding to even on tie.
      // std::round that was used here before rounds halfway cases away from zero.
      // However, we can probably tolerate rounding issues here, as this will only slightly affect
      // the visuals.
      return static_cast<int>(lrintf(convertedFreqBinNum));
   };
 
   for (int xx = 0; xx < mid.width; ++xx) {
      int correctedX = xx + leftOffset - hiddenLeftOffset;
 
      // in fisheye mode the time scale has changed, so the row values aren't cached
      // in the loop above, and must be fetched from fft cache
      float* uncached;
      if (!zoomInfo.InFisheye(xx, -leftOffset)) {
          uncached = 0;
      }
      else {
          int specIndex = (xx - fisheyeLeft) * nBins;
          wxASSERT(specIndex >= 0 && specIndex < (int)specCache.freq.size());
          uncached = &specCache.freq[specIndex];
      }
 
      // zoomInfo must be queried for each column since with fisheye enabled
      // time between columns is variable
      const auto w0 = sampleCount(
         0.5 + sampleRate / stretchRatio *
                  (zoomInfo.PositionToTime(xx, -leftOffset) - playStartTime));
 
      const auto w1 = sampleCount(
         0.5 + sampleRate / stretchRatio *
                  (zoomInfo.PositionToTime(xx + 1, -leftOffset) - playStartTime));
 
      bool maybeSelected = ssel0 <= w0 && w1 < ssel1;
      maybeSelected = maybeSelected || (xx == selectedX);
 
      // In case the xx matches the hop number, it will be used as iterator for frequency bins
      std::set<int> *pSelectedBins = nullptr;
      std::set<int>::iterator freqBinIter;
      auto advanceFreqBinIter = [&](int nextBinRounded){
         while (freqBinIter != pSelectedBins->end() &&
         *freqBinIter < nextBinRounded)
            ++freqBinIter;
      };
 
      bool hitHopNum = false;
      if (onBrushTool) {
         int convertedHopNum = (w0.as_long_long() + hopSize / 2) / hopSize;
         hitHopNum = (hopBinMap.find(convertedHopNum) != hopBinMap.end());
         if(hitHopNum) {
            pSelectedBins = &hopBinMap[convertedHopNum];
            freqBinIter = pSelectedBins->begin();
            advanceFreqBinIter(yyToFreqBin(0));
         }
      }
 
      for (int yy = 0; yy < hiddenMid.height; ++yy) {
         if(onBrushTool)
            maybeSelected = false;
         const float bin     = bins[yy];
         const float nextBin = bins[yy+1];
         auto binRounded = yyToFreqBin(yy);
         auto nextBinRounded = yyToFreqBin(yy + 1);
 
         if(hitHopNum
            && freqBinIter != pSelectedBins->end()
            && binRounded == *freqBinIter)
            maybeSelected = true;
 
         if (hitHopNum)
            advanceFreqBinIter(nextBinRounded);
 
         // For spectral selection, determine what colour
         // set to use.  We use a darker selection if
         // in both spectral range and time range.
 
         AColor::ColorGradientChoice selected = AColor::ColorGradientUnselected;
 
         // If we are in the time selected range, then we may use a different color set.
         if (maybeSelected) {
            selected =
               ChooseColorSet(bin, nextBin, selBinLo, selBinCenter, selBinHi,
                  (xx + leftOffset - hiddenLeftOffset) / DASH_LENGTH, isSpectral);
            if ( onBrushTool && selected != AColor::ColorGradientUnselected )
               // use only two sets of colors
               selected = AColor::ColorGradientTimeAndFrequencySelected;
         }
 
         const float value = uncached
            ? findValue(uncached, bin, nextBin, nBins, autocorrelation, gain, range)
            : specPxCache->values[correctedX * hiddenMid.height + yy];
 
         unsigned char rv, gv, bv;
         GetColorGradient(value, selected, colorScheme, &rv, &gv, &bv);
 
#ifdef EXPERIMENTAL_FFT_Y_GRID
         if (fftYGrid && yGrid[yy]) {
            rv /= 1.1f;
            gv /= 1.1f;
            bv /= 1.1f;
         }
#endif //EXPERIMENTAL_FFT_Y_GRID
         int px = ((mid.height - 1 - yy) * mid.width + xx);
#ifdef EXPERIMENTAL_SPECTROGRAM_OVERLAY
         // More transparent the closer to zero intensity.
         alpha[px]= wxMin( 200, (value+0.3) * 500) ;
#endif
         px *=3;
         data[px++] = rv;
         data[px++] = gv;
         data[px] = bv;
      } // each yy
   } // each xx
 
   dataHistory.pop_back();
   wxBitmap converted = wxBitmap(image);
 
   wxMemoryDC memDC;
 
   memDC.SelectObject(converted);
 
   dc.Blit(mid.x, mid.y, mid.width, mid.height, &memDC, 0, 0, wxCOPY, FALSE);
 
   // Draw clip edges, as also in waveform view, which improves the appearance
   // of split views
   {
      auto clipRect = ClipParameters::GetClipRect(clip, zoomInfo, rect);
      TrackArt::DrawClipEdges(dc, clipRect, selected);
   }
}

References SpectrogramSettings::algPitchEAC, details::begin(), NumberScale::begin(), ChooseColorSet(), WaveChannelView::ClipDetailsVisible(), AColor::ColorGradientTimeAndFrequencySelected, AColor::ColorGradientUnselected, TrackPanelDrawingContext::dc, TrackArt::DrawClipEdges(), TrackArt::DrawClipFolded(), details::end(), findValue(), SpecCache::freq, WaveClipSpectrumCache::Get(), SpectrogramSettings::Get(), TrackArtist::Get(), SpectrogramBounds::Get(), SpectrogramBounds::GetBounds(), WaveClipChannel::GetChannelIndex(), ClipParameters::GetClipRect(), GetColorGradient(), WaveClipChannel::GetPlayStartTime(), WaveClipChannel::GetRate(), Track::GetSelected(), GetSelectedSampleIndices(), WaveClipSpectrumCache::GetSpectrogram(), WaveClipChannel::GetStretchRatio(), WaveChannel::GetTrack(), AColor::gradient_inited, SpecCache::Grow(), ZoomInfo::HIDDEN, lrintf, min(), params, SpecCache::Populate(), NumberScale::PositionToValue(), AColor::PreComputeGradient(), anonymous_namespace{ClipSegmentTest.cpp}::sampleRate, settings(), staffpad::audio::simd::sqrt(), SpectrogramSettings::stLogarithmic, SelectedRegion::UndefinedFrequency, SpecCache::where, and wxImage().

Referenced by SpectrumView::DoDraw().

Here is the call graph for this function:

Here is the caller graph for this function:

findCommandHandler()

static CommandHandlerObject & anonymous_namespace{SpectrumView.cpp}::findCommandHandler ( AudacityProject &  project )

static

Definition at line 1175 of file SpectrumView.cpp.

                                                                          {
   return project.AttachedObjects::Get< Handler >( key );
};

References key, and project.

Referenced by SpectralSelectionMenu().

Here is the caller graph for this function:

findValue()

static float anonymous_namespace{SpectrumView.cpp}::findValue ( const float *  spectrum, float  bin0, float  bin1, unsigned  nBins, bool  autocorrelation, int  gain, int  range  )

inlinestatic

Definition at line 249 of file SpectrumView.cpp.

{
   float value;
 
 
#if 0
   // Averaging method
   if ((int)(bin1) == (int)(bin0)) {
      value = spectrum[(int)(bin0)];
   } else {
      float binwidth= bin1 - bin0;
      value = spectrum[(int)(bin0)] * (1.f - bin0 + (int)bin0);
 
      bin0 = 1 + (int)(bin0);
      while (bin0 < (int)(bin1)) {
         value += spectrum[(int)(bin0)];
         bin0 += 1.0;
      }
      // Do not reference past end of freq array.
      if ((int)(bin1) >= (int)nBins) {
         bin1 -= 1.0;
      }
 
      value += spectrum[(int)(bin1)] * (bin1 - (int)(bin1));
      value /= binwidth;
   }
#else
   // Maximum method, and no apportionment of any single bins over multiple pixel rows
   // See Bug971
   int index, limitIndex;
   if (autocorrelation) {
      // bin = 2 * nBins / (nBins - 1 - array_index);
      // Solve for index
      index = std::max(0.0f, std::min(float(nBins - 1),
         (nBins - 1) - (2 * nBins) / (std::max(1.0f, bin0))
      ));
      limitIndex = std::max(0.0f, std::min(float(nBins - 1),
         (nBins - 1) - (2 * nBins) / (std::max(1.0f, bin1))
      ));
   }
   else {
      index = std::min<int>(nBins - 1, (int)(floor(0.5 + bin0)));
      limitIndex = std::min<int>(nBins, (int)(floor(0.5 + bin1)));
   }
   value = spectrum[index];
   while (++index < limitIndex)
      value = std::max(value, spectrum[index]);
#endif
   if (!autocorrelation) {
      // Last step converts dB to a 0.0-1.0 range
      value = (value + range + gain) / (double)range;
   }
   value = std::min(1.0f, std::max(0.0f, value));
   return value;
}

References min().

Referenced by DrawClipSpectrum(), and anonymous_namespace{WaveTrackControls.cpp}::initFn().

Here is the call graph for this function:

Here is the caller graph for this function:

GetSelectedSampleIndices()

std::pair< sampleCount, sampleCount > anonymous_namespace{SpectrumView.cpp}::GetSelectedSampleIndices	(	const SelectedRegion &	selectedRegion,
		const WaveChannelInterval &	clip,
		bool	trackIsSelected
	)

Definition at line 327 of file SpectrumView.cpp.

{
   if (!trackIsSelected)
      return { 0, 0 };
   const double t0 = selectedRegion.t0(); // left selection bound
   const double t1 = selectedRegion.t1(); // right selection bound
   const auto startTime = clip.GetPlayStartTime();
   const auto s0 = std::max(sampleCount(0), clip.TimeToSamples(t0 - startTime));
   auto s1 = std::clamp(
      clip.TimeToSamples(t1 - startTime), sampleCount { 0 },
      clip.GetVisibleSampleCount());
   return { s0, s1 };
}

References WaveClipChannel::GetPlayStartTime(), WaveClipChannel::GetVisibleSampleCount(), SelectedRegion::t0(), SelectedRegion::t1(), and WaveClipChannel::TimeToSamples().

Referenced by DrawClipSpectrum().

Here is the call graph for this function:

Here is the caller graph for this function:

SpectralSelectionMenu()

auto anonymous_namespace{SpectrumView.cpp}::SpectralSelectionMenu

(

)

Definition at line 1182 of file SpectrumView.cpp.

{
   static auto menu = std::shared_ptr{
   ( FinderScope{ findCommandHandler },
   Menu( wxT("Spectral"), XXO("S&pectral"),
      Command( wxT("ToggleSpectralSelection"),
         XXO("To&ggle Spectral Selection"), FN(OnToggleSpectralSelection),
         TracksExistFlag(), wxT("Q") ),
      Command( wxT("NextHigherPeakFrequency"),
         XXO("Next &Higher Peak Frequency"), FN(OnNextHigherPeakFrequency),
         TracksExistFlag() ),
      Command( wxT("NextLowerPeakFrequency"),
         XXO("Next &Lower Peak Frequency"), FN(OnNextLowerPeakFrequency),
         TracksExistFlag() )
   ) ) };
   return menu;
}

References MenuRegistry::Command, findCommandHandler(), FN, MenuRegistry::Menu, TracksExistFlag(), wxT(), and XXO().

Here is the call graph for this function:

Variable Documentation

key

const AttachedProjectObjects::RegisteredFactory anonymous_namespace{SpectrumView.cpp}::key

static

Initial value:

{
   [](AudacityProject&) {
      return std::make_unique< Handler >(); } }

Definition at line 1171 of file SpectrumView.cpp.

sAttachment

PopupMenuTable::AttachedItem anonymous_namespace{SpectrumView.cpp}::sAttachment

Definition at line 1013 of file SpectrumView.cpp.

sAttachment2

AttachedItem anonymous_namespace{SpectrumView.cpp}::sAttachment2

Initial value:

{ Indirect(SpectralSelectionMenu()),
   Placement{ wxT("Select/Basic"), { OrderingHint::After, wxT("Region") } }
}

Definition at line 1202 of file SpectrumView.cpp.