comparison layer/SpectrogramLayer.cpp @ 130:10eec0da9efe last-cc-copyright

* Move the current DenseThreeDimensionalModel to EditableDenseThreeDimensionalModel
  (wow!), and make DTDM an abstract base
* Move FFTFuzzyAdapter to FFTModel as a new subclass of DTDM

 SpectrogramLayer::~SpectrogramLayer()
 {
     delete m_updateTimer;
     m_updateTimer = 0;
     
-    invalidateFFTAdapters();
+    invalidateFFTModels();
 }
 
 void
 SpectrogramLayer::setModel(const DenseTimeValueModel *model)
 {
 //    std::cerr << "SpectrogramLayer(" << this << "): setModel(" << model << ")" << std::endl;
 
     if (model == m_model) return;
 
     m_model = model;
-    invalidateFFTAdapters();
+    invalidateFFTModels();
 
     if (!m_model || !m_model->isOK()) return;
 
     connect(m_model, SIGNAL(modelChanged()), this, SIGNAL(modelChanged()));
     connect(m_model, SIGNAL(modelChanged(size_t, size_t)),

 {
     if (m_channel == ch) return;
 
     invalidatePixmapCaches();
     m_channel = ch;
-    invalidateFFTAdapters();
+    invalidateFFTModels();
 
     emit layerParametersChanged();
 }
 
 int

     invalidatePixmapCaches();
     
     m_windowSize = ws;
     m_fftSize = ws * (m_zeroPadLevel + 1);
     
-    invalidateFFTAdapters();
+    invalidateFFTModels();
 
     emit layerParametersChanged();
 }
 
 size_t

 
     invalidatePixmapCaches();
     
     m_windowHopLevel = v;
     
-    invalidateFFTAdapters();
+    invalidateFFTModels();
 
     emit layerParametersChanged();
 
 //    fillCache();
 }

     invalidatePixmapCaches();
     
     m_zeroPadLevel = v;
     m_fftSize = m_windowSize * (v + 1);
 
-    invalidateFFTAdapters();
+    invalidateFFTModels();
 
     emit layerParametersChanged();
 }
 
 size_t

 
     invalidatePixmapCaches();
     
     m_windowType = w;
 
-    invalidateFFTAdapters();
+    invalidateFFTModels();
 
     emit layerParametersChanged();
 }
 
 WindowType

 	m_dormancy[v] = true;
 
 	invalidatePixmapCaches();
         m_pixmapCaches.erase(v);
 
-        if (m_fftAdapters.find(v) != m_fftAdapters.end()) {
-            delete m_fftAdapters[v].first;
-            m_fftAdapters.erase(v);
+        if (m_fftModels.find(v) != m_fftModels.end()) {
+            delete m_fftModels[v].first;
+            m_fftModels.erase(v);
         }
 	
     } else {
 
 	m_dormancy[v] = false;

 {
     if (!m_model) return;
 
     bool allDone = true;
 
-    for (ViewFFTMap::iterator i = m_fftAdapters.begin();
-         i != m_fftAdapters.end(); ++i) {
+    for (ViewFFTMap::iterator i = m_fftModels.begin();
+         i != m_fftModels.end(); ++i) {
 
         const View *v = i->first;
-        const FFTFuzzyAdapter *adapter = i->second.first;
+        const FFTModel *model = i->second.first;
         size_t lastFill = i->second.second;
 
-        if (adapter) {
-
-            size_t fill = adapter->getFillExtent();
+        if (model) {
+
+            size_t fill = model->getFillExtent();
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-            std::cerr << "SpectrogramLayer::fillTimerTimedOut: extent for " << adapter << ": " << fill << ", last " << lastFill << ", total " << m_model->getEndFrame() << std::endl;
+            std::cerr << "SpectrogramLayer::fillTimerTimedOut: extent for " << model << ": " << fill << ", last " << lastFill << ", total " << m_model->getEndFrame() << std::endl;
 #endif
 
             if (fill >= lastFill) {
                 if (fill >= m_model->getEndFrame() && lastFill > 0) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT

     float minf = getEffectiveMinFrequency();
     float maxf = getEffectiveMaxFrequency();
 
     bool logarithmic = (m_frequencyScale == LogFrequencyScale);
 
-    //!!! wrong for smoothing -- wrong fft size for fft adapter
+    //!!! wrong for smoothing -- wrong fft size for fft model
 
     q0 = v->getFrequencyForY(y, minf, maxf, logarithmic);
     q1 = v->getFrequencyForY(y - 1, minf, maxf, logarithmic);
 
     // Now map these on to actual bins

 SpectrogramLayer::getAdjustedYBinSourceRange(View *v, int x, int y,
 					     float &freqMin, float &freqMax,
 					     float &adjFreqMin, float &adjFreqMax)
 const
 {
-    FFTFuzzyAdapter *fft = getFFTAdapter(v);
+    FFTModel *fft = getFFTModel(v);
     if (!fft) return false;
 
     float s0 = 0, s1 = 0;
     if (!getXBinRange(v, x, s0, s1)) return false;
 

 
     size_t zp = getZeroPadLevel(v);
     q0i *= zp + 1;
     q1i *= zp + 1;
 
-    FFTFuzzyAdapter *fft = getFFTAdapter(v);
+    FFTModel *fft = getFFTModel(v);
 
     if (fft) {
 
         int cw = fft->getWidth();
         int ch = fft->getHeight();

 SpectrogramLayer::getFFTSize(const View *v) const
 {
     return m_fftSize * (getZeroPadLevel(v) + 1);
 }
 	
-FFTFuzzyAdapter *
-SpectrogramLayer::getFFTAdapter(const View *v) const
+FFTModel *
+SpectrogramLayer::getFFTModel(const View *v) const
 {
     if (!m_model) return 0;
 
     size_t fftSize = getFFTSize(v);
 
-    if (m_fftAdapters.find(v) != m_fftAdapters.end()) {
-        if (m_fftAdapters[v].first->getHeight() != fftSize / 2) {
-            delete m_fftAdapters[v].first;
-            m_fftAdapters.erase(v);
+    if (m_fftModels.find(v) != m_fftModels.end()) {
+        if (m_fftModels[v].first->getHeight() != fftSize / 2) {
+            delete m_fftModels[v].first;
+            m_fftModels.erase(v);
         }
     }
 
-    if (m_fftAdapters.find(v) == m_fftAdapters.end()) {
-        m_fftAdapters[v] = FFTFillPair
-            (new FFTFuzzyAdapter(m_model,
+    if (m_fftModels.find(v) == m_fftModels.end()) {
+        m_fftModels[v] = FFTFillPair
+            (new FFTModel(m_model,
                                  m_channel,
                                  m_windowType,
                                  m_windowSize,
                                  getWindowIncrement(),
                                  fftSize,

         connect(m_updateTimer, SIGNAL(timeout()),
                 this, SLOT(fillTimerTimedOut()));
         m_updateTimer->start(200);
     }
 
-    return m_fftAdapters[v].first;
-}
-
-void
-SpectrogramLayer::invalidateFFTAdapters()
-{
-    for (ViewFFTMap::iterator i = m_fftAdapters.begin();
-         i != m_fftAdapters.end(); ++i) {
+    return m_fftModels[v].first;
+}
+
+void
+SpectrogramLayer::invalidateFFTModels()
+{
+    for (ViewFFTMap::iterator i = m_fftModels.begin();
+         i != m_fftModels.end(); ++i) {
         delete i->second.first;
     }
     
-    m_fftAdapters.clear();
+    m_fftModels.clear();
 }
 
 void
 SpectrogramLayer::invalidateMagnitudes()
 {

     // and accountable for when determining whether we need the cache
     // in the cache-fill thread above.
     m_dormancy[v] = false;
 
     size_t fftSize = getFFTSize(v);
-    FFTFuzzyAdapter *fft = getFFTAdapter(v);
+    FFTModel *fft = getFFTModel(v);
     if (!fft) {
-	std::cerr << "ERROR: SpectrogramLayer::paint(): No FFT adapter, returning" << std::endl;
+	std::cerr << "ERROR: SpectrogramLayer::paint(): No FFT model, returning" << std::endl;
 	return;
     }
 
     PixmapCache &cache = m_pixmapCaches[v];
 

 
 int
 SpectrogramLayer::getCompletion(View *v) const
 {
     if (m_updateTimer == 0) return 100;
-    if (m_fftAdapters.find(v) == m_fftAdapters.end()) return 100;
-
-    size_t completion = m_fftAdapters[v].first->getFillCompletion();
+    if (m_fftModels.find(v) == m_fftModels.end()) return 100;
+
+    size_t completion = m_fftModels[v].first->getCompletion();
     std::cerr << "SpectrogramLayer::getCompletion: completion = " << completion << std::endl;
     return completion;
 }
 
 bool