comparison layer/SpectrogramLayer.cpp @ 44:ad214997dddb

* Refactor Layer classes so as no longer to store a single View pointer;
  instead they need to be able to draw themselves on any View on demand.
  Layers with caches (e.g. spectrogram) will need to be further refactored
  so as to maintain a per-View cache

* Begin refactoring MainWindow by pulling out the document stuff (set of
  layers, models etc) into a Document class.  Not yet in use.

This revision is fairly unstable.

 #include <cmath>
 
 //#define DEBUG_SPECTROGRAM_REPAINT 1
 
 
-SpectrogramLayer::SpectrogramLayer(View *w, Configuration config) :
-    Layer(w),
+SpectrogramLayer::SpectrogramLayer(Configuration config) :
+    Layer(),
     m_model(0),
     m_channel(0),
     m_windowSize(1024),
     m_windowType(HanningWindow),
     m_windowOverlap(50),

     m_cacheInvalid(true),
     m_pixmapCache(0),
     m_pixmapCacheInvalid(true),
     m_fillThread(0),
     m_updateTimer(0),
+    m_candidateFillStartFrame(0),
     m_lastFillExtent(0),
     m_exiting(false)
 {
     if (config == MelodicRange) {
 	setWindowSize(8192);

 	setFrequencyScale(LogFrequencyScale);
 	setColourScale(MeterColourScale);
 	setBinDisplay(PeakFrequencies);
 	setNormalizeColumns(true);
     }
-
-    if (m_view) m_view->setLightBackground(false);
-    m_view->addLayer(this);
 }
 
 SpectrogramLayer::~SpectrogramLayer()
 {
     delete m_updateTimer;

 	if (value == -50) setThreshold(0.0);
 	else setThreshold(AudioLevel::dB_to_multiplier(value));
     } else if (name == tr("Colour Rotation")) {
 	setColourRotation(value);
     } else if (name == tr("Colour")) {
-	if (m_view) m_view->setLightBackground(value == 2);
+//!!!	if (v) v->setLightBackground(value == 2);
 	switch (value) {
 	default:
 	case 0:	setColourScheme(DefaultColours); break;
 	case 1: setColourScheme(WhiteOnBlack); break;
 	case 2: setColourScheme(BlackOnWhite); break;

 {
     return m_normalizeColumns;
 }
 
 void
-SpectrogramLayer::setLayerDormant(bool dormant)
+SpectrogramLayer::setLayerDormant(const bool dormant)
 {
     if (dormant == m_dormant) return;
 
     if (dormant) {
 

 		emit modelChanged(m_lastFillExtent, fillExtent);
 		m_pixmapCacheInvalid = true;
 		m_lastFillExtent = fillExtent;
 	    }
 	} else {
-	    if (m_view) {
+//	    if (v) {
 		size_t sf = 0;
-		if (m_view->getStartFrame() > 0) sf = m_view->getStartFrame();
+//!!!		if (v->getStartFrame() > 0) sf = v->getStartFrame();
 #ifdef DEBUG_SPECTROGRAM_REPAINT
 		std::cerr << "SpectrogramLayer: going backwards, emitting modelChanged("
-			  << sf << "," << m_view->getEndFrame() << ")" << std::endl;
+			  << sf << "," << m_model->getEndFrame() << ")" << std::endl;
 #endif
-		emit modelChanged(sf, m_view->getEndFrame());
+		emit modelChanged(sf, m_model->getEndFrame());
 		m_pixmapCacheInvalid = true;
-	    }
+//	    }
 	    m_lastFillExtent = fillExtent;
 	}
     }
 }
 

 {
 }
 
 SpectrogramLayer::Cache::~Cache()
 {
-    for (size_t i = 0; i < m_height; ++i) {
+    for (size_t i = 0; i < m_width; ++i) {
 	if (m_magnitude && m_magnitude[i]) free(m_magnitude[i]);
 	if (m_phase && m_phase[i]) free(m_phase[i]);
     }
 
     if (m_magnitude) free(m_magnitude);

 }
 
 void
 SpectrogramLayer::Cache::resize(uint16_t **&array, size_t width, size_t height)
 {
-    for (size_t i = height; i < m_height; ++i) {
+    for (size_t i = width; i < m_width; ++i) {
 	free(array[i]);
     }
 
-    if (height != m_height) {
-	array = (uint16_t **)realloc(array, height * sizeof(uint16_t *));
+    if (width != m_width) {
+	array = (uint16_t **)realloc(array, width * sizeof(uint16_t *));
 	if (!array) throw std::bad_alloc();
-	MUNLOCK(array, height * sizeof(uint16_t *));
-    }
-
-    for (size_t i = m_height; i < height; ++i) {
+	MUNLOCK(array, width * sizeof(uint16_t *));
+    }
+
+    for (size_t i = m_width; i < width; ++i) {
 	array[i] = 0;
     }
 
-    for (size_t i = 0; i < height; ++i) {
-	array[i] = (uint16_t *)realloc(array[i], width * sizeof(uint16_t));
+    for (size_t i = 0; i < width; ++i) {
+	array[i] = (uint16_t *)realloc(array[i], height * sizeof(uint16_t));
 	if (!array[i]) throw std::bad_alloc();
-	MUNLOCK(array[i], width * sizeof(uint16_t));
+	MUNLOCK(array[i], height * sizeof(uint16_t));
     }
 }
 
 void
 SpectrogramLayer::Cache::reset()
 {
     for (size_t x = 0; x < m_width; ++x) {
 	for (size_t y = 0; y < m_height; ++y) {
-	    m_magnitude[y][x] = 0;
-	    m_phase[y][x] = 0;
+	    m_magnitude[x][y] = 0;
+	    m_phase[x][y] = 0;
 	}
 	m_factor[x] = 1.0;
     }
 }	    
 

 
 	    WindowType windowType = m_layer.m_windowType;
 	    size_t windowSize = m_layer.m_windowSize;
 	    size_t windowIncrement = m_layer.getWindowIncrement();
 
-	    size_t visibleStart = start;
-	    size_t visibleEnd = end;
-
-	    if (m_layer.m_view) {
-		if (m_layer.m_view->getStartFrame() < 0) {
-		    visibleStart = 0;
-		} else {
-		    visibleStart = m_layer.m_view->getStartFrame();
-		    visibleStart = (visibleStart / windowIncrement) *
-			windowIncrement;
-		}
-		visibleEnd = m_layer.m_view->getEndFrame();
-	    }
+	    size_t visibleStart = m_layer.m_candidateFillStartFrame;
+	    visibleStart = (visibleStart / windowIncrement) * windowIncrement;
 
 	    size_t width = (end - start) / windowIncrement + 1;
 	    size_t height = windowSize / 2;
 
 	    if (!m_layer.m_cache) {

 
 	    int counter = 0;
 	    int updateAt = (end / windowIncrement) / 20;
 	    if (updateAt < 100) updateAt = 100;
 
-	    bool doVisibleFirst = (visibleStart != start && visibleEnd != end);
+	    bool doVisibleFirst = (visibleStart != start);
 
 	    if (doVisibleFirst) {
 
-		for (size_t f = visibleStart; f < visibleEnd; f += windowIncrement) {
-	    
-		    m_layer.fillCacheColumn(int((f - start) / windowIncrement),
-					    input, output, plan,
-					    windowSize, windowIncrement,
-					    windower);
-
-		    if (m_layer.m_cacheInvalid || m_layer.m_exiting) {
-			interrupted = true;
-			m_fillExtent = 0;
-			break;
-		    }
-
-		    if (++counter == updateAt ||
-			(f >= visibleEnd - 1 && f < visibleEnd + windowIncrement)) {
-			if (f < end) m_fillExtent = f;
-			m_fillCompletion = size_t(100 * fabsf(float(f - visibleStart) /
-							      float(end - start)));
-			counter = 0;
-		    }
-		}
-
-		std::cerr << "SpectrogramLayer::CacheFillThread::run: visible bit done" << std::endl;
-		m_layer.m_view->update();
-	    }
-
-	    if (!interrupted && doVisibleFirst) {
-		
-		for (size_t f = visibleEnd; f < end; f += windowIncrement) {
+		for (size_t f = visibleStart; f < end; f += windowIncrement) {
 	    
 		    m_layer.fillCacheColumn(int((f - start) / windowIncrement),
 					    input, output, plan,
 					    windowSize, windowIncrement,
 					    windower);

 			interrupted = true;
 			m_fillExtent = 0;
 			break;
 		    }
 		    
-		    if (++counter == updateAt ||
-			(f >= visibleEnd - 1 && f < visibleEnd + windowIncrement)) {
+		    if (++counter == updateAt) {
 			m_fillExtent = f;
 			m_fillCompletion = baseCompletion +
 			    size_t(100 * fabsf(float(f - start) /
 					       float(end - start)));
 			counter = 0;

 
     return maxf;
 }
 
 bool
-SpectrogramLayer::getYBinRange(int y, float &q0, float &q1) const
-{
-    int h = m_view->height();
+SpectrogramLayer::getYBinRange(View *v, int y, float &q0, float &q1) const
+{
+    int h = v->height();
     if (y < 0 || y >= h) return false;
 
     int sr = m_model->getSampleRate();
     float minf = getEffectiveMinFrequency();
     float maxf = getEffectiveMaxFrequency();
 
     bool logarithmic = (m_frequencyScale == LogFrequencyScale);
 
-    q0 = m_view->getFrequencyForY(y, minf, maxf, logarithmic);
-    q1 = m_view->getFrequencyForY(y - 1, minf, maxf, logarithmic);
+    q0 = v->getFrequencyForY(y, minf, maxf, logarithmic);
+    q1 = v->getFrequencyForY(y - 1, minf, maxf, logarithmic);
 
     // Now map these on to actual bins
 
     int b0 = int((q0 * m_windowSize) / sr);
     int b1 = int((q1 * m_windowSize) / sr);

 
     return true;
 }
     
 bool
-SpectrogramLayer::getXBinRange(int x, float &s0, float &s1) const
+SpectrogramLayer::getXBinRange(View *v, int x, float &s0, float &s1) const
 {
     size_t modelStart = m_model->getStartFrame();
     size_t modelEnd = m_model->getEndFrame();
 
     // Each pixel column covers an exact range of sample frames:
-    int f0 = getFrameForX(x) - modelStart;
-    int f1 = getFrameForX(x + 1) - modelStart - 1;
+    int f0 = v->getFrameForX(x) - modelStart;
+    int f1 = v->getFrameForX(x + 1) - modelStart - 1;
 
     if (f1 < int(modelStart) || f0 > int(modelEnd)) {
 	return false;
     }
       

 
     return true;
 }
  
 bool
-SpectrogramLayer::getXBinSourceRange(int x, RealTime &min, RealTime &max) const
+SpectrogramLayer::getXBinSourceRange(View *v, int x, RealTime &min, RealTime &max) const
 {
     float s0 = 0, s1 = 0;
-    if (!getXBinRange(x, s0, s1)) return false;
+    if (!getXBinRange(v, x, s0, s1)) return false;
     
     int s0i = int(s0 + 0.001);
     int s1i = int(s1);
 
     int windowIncrement = getWindowIncrement();

     max = RealTime::frame2RealTime(w1, m_model->getSampleRate());
     return true;
 }
 
 bool
-SpectrogramLayer::getYBinSourceRange(int y, float &freqMin, float &freqMax)
+SpectrogramLayer::getYBinSourceRange(View *v, int y, float &freqMin, float &freqMax)
 const
 {
     float q0 = 0, q1 = 0;
-    if (!getYBinRange(y, q0, q1)) return false;
+    if (!getYBinRange(v, y, q0, q1)) return false;
 
     int q0i = int(q0 + 0.001);
     int q1i = int(q1);
 
     int sr = m_model->getSampleRate();

     }
     return true;
 }
 
 bool
-SpectrogramLayer::getAdjustedYBinSourceRange(int x, int y,
+SpectrogramLayer::getAdjustedYBinSourceRange(View *v, int x, int y,
 					     float &freqMin, float &freqMax,
 					     float &adjFreqMin, float &adjFreqMax)
 const
 {
     float s0 = 0, s1 = 0;
-    if (!getXBinRange(x, s0, s1)) return false;
+    if (!getXBinRange(v, x, s0, s1)) return false;
 
     float q0 = 0, q1 = 0;
-    if (!getYBinRange(y, q0, q1)) return false;
+    if (!getYBinRange(v, y, q0, q1)) return false;
 
     int s0i = int(s0 + 0.001);
     int s1i = int(s1);
 
     int q0i = int(q0 + 0.001);

 
     return haveAdj;
 }
     
 bool
-SpectrogramLayer::getXYBinSourceRange(int x, int y,
+SpectrogramLayer::getXYBinSourceRange(View *v, int x, int y,
 				      float &min, float &max,
 				      float &phaseMin, float &phaseMax) const
 {
     float q0 = 0, q1 = 0;
-    if (!getYBinRange(y, q0, q1)) return false;
+    if (!getYBinRange(v, y, q0, q1)) return false;
 
     float s0 = 0, s1 = 0;
-    if (!getXBinRange(x, s0, s1)) return false;
+    if (!getXBinRange(v, x, s0, s1)) return false;
     
     int q0i = int(q0 + 0.001);
     int q1i = int(q1);
 
     int s0i = int(s0 + 0.001);

 
     return rv;
 }
    
 void
-SpectrogramLayer::paint(QPainter &paint, QRect rect) const
+SpectrogramLayer::paint(View *v, QPainter &paint, QRect rect) const
 {
 //    Profiler profiler("SpectrogramLayer::paint", true);
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-    std::cerr << "SpectrogramLayer::paint(): m_model is " << m_model << ", zoom level is " << m_view->getZoomLevel() << ", m_updateTimer " << m_updateTimer << ", pixmap cache invalid " << m_pixmapCacheInvalid << std::endl;
+    std::cerr << "SpectrogramLayer::paint(): m_model is " << m_model << ", zoom level is " << v->getZoomLevel() << ", m_updateTimer " << m_updateTimer << ", pixmap cache invalid " << m_pixmapCacheInvalid << std::endl;
 #endif
+
+    m_candidateFillStartFrame = v->getStartFrame();
 
     if (!m_model || !m_model->isOK() || !m_model->isReady()) {
 	return;
     }
 

 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
     std::cerr << "SpectrogramLayer::paint(): Still cacheing = " << stillCacheing << std::endl;
 #endif
 
-    long startFrame = m_view->getStartFrame();
-    int zoomLevel = m_view->getZoomLevel();
+    long startFrame = v->getStartFrame();
+    int zoomLevel = v->getZoomLevel();
 
     int x0 = 0;
-    int x1 = m_view->width();
+    int x1 = v->width();
     int y0 = 0;
-    int y1 = m_view->height();
+    int y1 = v->height();
 
     bool recreateWholePixmapCache = true;
 
     if (!m_pixmapCacheInvalid) {
 

 	//scrolling cache in View.  Perhaps experiment with
 	//removing it and see if it makes things even quicker (or else
 	//make it optional)
 
 	if (int(m_pixmapCacheZoomLevel) == zoomLevel &&
-	    m_pixmapCache->width() == m_view->width() &&
-	    m_pixmapCache->height() == m_view->height()) {
-
-	    if (getXForFrame(m_pixmapCacheStartFrame) ==
-		getXForFrame(startFrame)) {
+	    m_pixmapCache->width() == v->width() &&
+	    m_pixmapCache->height() == v->height()) {
+
+	    if (v->getXForFrame(m_pixmapCacheStartFrame) ==
+		v->getXForFrame(startFrame)) {
 	    
 #ifdef DEBUG_SPECTROGRAM_REPAINT
 		std::cerr << "SpectrogramLayer: pixmap cache good" << std::endl;
 #endif
 

 		std::cerr << "SpectrogramLayer: pixmap cache partially OK" << std::endl;
 #endif
 
 		recreateWholePixmapCache = false;
 
-		int dx = getXForFrame(m_pixmapCacheStartFrame) -
-		         getXForFrame(startFrame);
+		int dx = v->getXForFrame(m_pixmapCacheStartFrame) -
+		         v->getXForFrame(startFrame);
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
 		std::cerr << "SpectrogramLayer: dx = " << dx << " (pixmap cache " << m_pixmapCache->width() << "x" << m_pixmapCache->height() << ")" << std::endl;
 #endif
 

 	    ydiv[y] = 0.0;
 	}
 
 	float s0 = 0, s1 = 0;
 
-	if (!getXBinRange(x0 + x, s0, s1)) {
+	if (!getXBinRange(v, x0 + x, s0, s1)) {
 	    assert(x <= scaled.width());
 	    m_mutex.unlock();
 	    continue;
 	}
 

 
 	    float y0 = 0, y1 = 0;
 
 	    if (m_binDisplay != PeakFrequencies ||
 		s1i >= int(m_cache->getWidth())) {
-		y0 = m_view->getYForFrequency(f1, minFreq, maxFreq, logarithmic);
-		y1 = m_view->getYForFrequency(f0, minFreq, maxFreq, logarithmic);
+		y0 = v->getYForFrequency(f1, minFreq, maxFreq, logarithmic);
+		y1 = v->getYForFrequency(f0, minFreq, maxFreq, logarithmic);
 	    }
 
 	    for (int s = s0i; s <= s1i; ++s) {
 
 		if (m_binDisplay == PeakBins ||

 						 sr,
 						 m_cache->getPhaseAt(s, q),
 						 m_cache->getPhaseAt(s+1, q),
 						 steady);
 
-		    y0 = y1 = m_view->getYForFrequency
+		    y0 = y1 = v->getYForFrequency
 			(f0, minFreq, maxFreq, logarithmic);
 		}
 		
 		int y0i = int(y0 + 0.001);
 		int y1i = int(y1);

     std::cerr << "SpectrogramLayer::paint() returning" << std::endl;
 #endif
 }
 
 float
-SpectrogramLayer::getYForFrequency(float frequency) const
-{
-    return m_view->getYForFrequency(frequency,
-				    getEffectiveMinFrequency(),
-				    getEffectiveMaxFrequency(),
-				    m_frequencyScale == LogFrequencyScale);
+SpectrogramLayer::getYForFrequency(View *v, float frequency) const
+{
+    return v->getYForFrequency(frequency,
+			       getEffectiveMinFrequency(),
+			       getEffectiveMaxFrequency(),
+			       m_frequencyScale == LogFrequencyScale);
 }
 
 float
-SpectrogramLayer::getFrequencyForY(int y) const
-{
-    return m_view->getFrequencyForY(y,
-				    getEffectiveMinFrequency(),
-				    getEffectiveMaxFrequency(),
-				    m_frequencyScale == LogFrequencyScale);
+SpectrogramLayer::getFrequencyForY(View *v, int y) const
+{
+    return v->getFrequencyForY(y,
+			       getEffectiveMinFrequency(),
+			       getEffectiveMaxFrequency(),
+			       m_frequencyScale == LogFrequencyScale);
 }
 
 int
 SpectrogramLayer::getCompletion() const
 {

 //    std::cerr << "SpectrogramLayer::getCompletion: completion = " << completion << std::endl;
     return completion;
 }
 
 bool
-SpectrogramLayer::snapToFeatureFrame(int &frame,
+SpectrogramLayer::snapToFeatureFrame(View *v, int &frame,
 				     size_t &resolution,
 				     SnapType snap) const
 {
     resolution = getWindowIncrement();
     int left = (frame / resolution) * resolution;

     
     return true;
 } 
 
 QString
-SpectrogramLayer::getFeatureDescription(QPoint &pos) const
+SpectrogramLayer::getFeatureDescription(View *v, QPoint &pos) const
 {
     int x = pos.x();
     int y = pos.y();
 
     if (!m_model || !m_model->isOK()) return "";

     QString pitchMin, pitchMax;
     RealTime rtMin, rtMax;
 
     bool haveValues = false;
 
-    if (!getXBinSourceRange(x, rtMin, rtMax)) {
+    if (!getXBinSourceRange(v, x, rtMin, rtMax)) {
 	return "";
     }
-    if (getXYBinSourceRange(x, y, magMin, magMax, phaseMin, phaseMax)) {
+    if (getXYBinSourceRange(v, x, y, magMin, magMax, phaseMin, phaseMax)) {
 	haveValues = true;
     }
 
     QString adjFreqText = "", adjPitchText = "";
 
     if (m_binDisplay == PeakFrequencies) {
 
-	if (!getAdjustedYBinSourceRange(x, y, freqMin, freqMax,
+	if (!getAdjustedYBinSourceRange(v, x, y, freqMin, freqMax,
 					adjFreqMin, adjFreqMax)) {
 	    return "";
 	}
 
 	if (adjFreqMin != adjFreqMax) {

 	    adjPitchText = tr("Adjusted Pitch:\t%2\n").arg(pmin);
 	}
 
     } else {
 	
-	if (!getYBinSourceRange(y, freqMin, freqMax)) return "";
+	if (!getYBinSourceRange(v, y, freqMin, freqMax)) return "";
     }
 
     QString text;
 
     if (rtMin != rtMax) {

 
     return cw;
 }
 
 int
-SpectrogramLayer::getVerticalScaleWidth(QPainter &paint) const
+SpectrogramLayer::getVerticalScaleWidth(View *v, QPainter &paint) const
 {
     if (!m_model || !m_model->isOK()) return 0;
 
     int cw = getColourScaleWidth(paint);
 

     
     return cw + tickw + tw + 13;
 }
 
 void
-SpectrogramLayer::paintVerticalScale(QPainter &paint, QRect rect) const
+SpectrogramLayer::paintVerticalScale(View *v, QPainter &paint, QRect rect) const
 {
     if (!m_model || !m_model->isOK()) {
 	return;
     }
 

 
     paint.drawLine(cw + 7, 0, cw + 7, h);
 
     int bin = -1;
 
-    for (int y = 0; y < m_view->height(); ++y) {
+    for (int y = 0; y < v->height(); ++y) {
 
 	float q0, q1;
-	if (!getYBinRange(m_view->height() - y, q0, q1)) continue;
+	if (!getYBinRange(v, v->height() - y, q0, q1)) continue;
 
 	int vy;
 
 	if (int(q0) > bin) {
 	    vy = y;

 	paint.setBrush(paint.pen().color());
 
 	for (int i = 0; i < 128; ++i) {
 
 	    float f = Pitch::getFrequencyForPitch(i);
-	    int y = lrintf(m_view->getYForFrequency(f, minf, maxf, true));
+	    int y = lrintf(v->getYForFrequency(f, minf, maxf, true));
 	    int n = (i % 12);
 	    if (n == 1 || n == 3 || n == 6 || n == 8 || n == 10) {
 		// black notes
 		paint.drawLine(w - pkw, y, w, y);
 		int rh = ((py - y) / 4) * 2;