comparison layer/WaveformLayer.cpp @ 67:c4fff27cd651

* Add auto-normalize option to waveform layer
* Various fixes to display of dB/metered levels in waveform layer.  Still need
  to fix to ensure they don't waste half the display
* Add mix channels option to waveform layer
* Use multiple transforms menus, one per transform type -- not sure about this
* Give centroid plugin two outputs, for log and linear frequency weightings
* Show scale units from plugin in time-value display

 
 WaveformLayer::WaveformLayer() :
     Layer(),
     m_model(0),
     m_gain(1.0f),
+    m_autoNormalize(false),
     m_colour(Qt::black),
     m_showMeans(true),
     m_greyscale(true),
     m_channelMode(SeparateChannels),
     m_channel(-1),

 {
     PropertyList list;
     list.push_back(tr("Colour"));
     list.push_back(tr("Scale"));
     list.push_back(tr("Gain"));
-    list.push_back(tr("Merge Channels"));
+    list.push_back(tr("Normalize Visible Area"));
+    list.push_back(tr("Channels"));
     return list;
 }
 
 Layer::PropertyType
 WaveformLayer::getPropertyType(const PropertyName &name) const
 {
     if (name == tr("Gain")) return RangeProperty;
+    if (name == tr("Normalize Visible Area")) return ToggleProperty;
     if (name == tr("Colour")) return ValueProperty;
-    if (name == tr("Merge Channels")) return ToggleProperty;
+    if (name == tr("Channels")) return ValueProperty;
     if (name == tr("Scale")) return ValueProperty;
     return InvalidProperty;
 }
 
 QString
 WaveformLayer::getPropertyGroupName(const PropertyName &name) const
 {
     if (name == tr("Gain") ||
+        name == tr("Normalize Visible Area") ||
 	name == tr("Scale")) return tr("Scale");
     return QString();
 }
 
 int
 WaveformLayer::getPropertyRangeAndValue(const PropertyName &name,
-					 int *min, int *max) const
+                                        int *min, int *max) const
 {
     int deft = 0;
 
     int garbage0, garbage1;
     if (!min) min = &garbage0;

 	*max = 50;
 
 	deft = lrint(log10(m_gain) * 20.0);
 	if (deft < *min) deft = *min;
 	if (deft > *max) deft = *max;
+
+    } else if (name == tr("Normalize Visible Area")) {
+
+        deft = (m_autoNormalize ? 1 : 0);
 
     } else if (name == tr("Colour")) {
 
 	*min = 0;
 	*max = 5;

 	else if (m_colour == Qt::darkBlue) deft = 2;
 	else if (m_colour == Qt::darkGreen) deft = 3;
 	else if (m_colour == QColor(200, 50, 255)) deft = 4;
 	else if (m_colour == QColor(255, 150, 50)) deft = 5;
 
-    } else if (name == tr("Merge Channels")) {
-
-	deft = ((m_channelMode == MergeChannels) ? 1 : 0);
+    } else if (name == tr("Channels")) {
+
+        *min = 0;
+        *max = 2;
+        if (m_channelMode == MixChannels) deft = 1;
+        else if (m_channelMode == MergeChannels) deft = 2;
+        else deft = 0;
 
     } else if (name == tr("Scale")) {
 
 	*min = 0;
 	*max = 2;

 	case 0: return tr("Linear");
 	case 1: return tr("Meter");
 	case 2: return tr("dB");
 	}
     }
+    if (name == tr("Channels")) {
+        switch (value) {
+        default:
+        case 0: return tr("Separate");
+        case 1: return tr("Mean");
+        case 2: return tr("Butterfly");
+        }
+    }
     return tr("<unknown>");
 }
 
 void
 WaveformLayer::setProperty(const PropertyName &name, int value)
 {
     if (name == tr("Gain")) {
 	setGain(pow(10, float(value)/20.0));
+    } else if (name == tr("Normalize Visible Area")) {
+        setAutoNormalize(value ? true : false);
     } else if (name == tr("Colour")) {
 	switch (value) {
 	default:
 	case 0:	setBaseColour(Qt::black); break;
 	case 1: setBaseColour(Qt::darkRed); break;
 	case 2: setBaseColour(Qt::darkBlue); break;
 	case 3: setBaseColour(Qt::darkGreen); break;
 	case 4: setBaseColour(QColor(200, 50, 255)); break;
 	case 5: setBaseColour(QColor(255, 150, 50)); break;
 	}
-    } else if (name == tr("Merge Channels")) {
-	setChannelMode(value ? MergeChannels : SeparateChannels);
+    } else if (name == tr("Channels")) {
+        if (value == 1) setChannelMode(MixChannels);
+        else if (value == 2) setChannelMode(MergeChannels);
+        else setChannelMode(SeparateChannels);
     } else if (name == tr("Scale")) {
 	switch (value) {
 	default:
 	case 0: setScale(LinearScale); break;
 	case 1: setScale(MeterScale); break;
 	case 2: setScale(dBScale); break;
 	}
     }
 }
 
-/*
-
-int
-WaveformLayer::getProperty(const PropertyName &name)
-{
-    if (name == "Gain") {
-	return int((getGain() - 1.0) * 10.0 + 0.01);
-    }
-    if (name == "Colour") {
-	
-*/
-
-void
-WaveformLayer::setGain(float gain) //!!! inadequate for floats!
+void
+WaveformLayer::setGain(float gain)
 {
     if (m_gain == gain) return;
     m_gain = gain;
     m_cacheValid = false;
     emit layerParametersChanged();
 }
 
 void
+WaveformLayer::setAutoNormalize(bool autoNormalize)
+{
+    if (m_autoNormalize == autoNormalize) return;
+    m_autoNormalize = autoNormalize;
+    m_cacheValid = false;
+    emit layerParametersChanged();
+}
+
+void
 WaveformLayer::setBaseColour(QColor colour)
 {
     if (m_colour == colour) return;
     m_colour = colour;
     m_cacheValid = false;

 }
 
 int
 WaveformLayer::dBscale(float sample, int m) const
 {
-    if (sample < 0.0) return -dBscale(-sample, m);
+//!!!    if (sample < 0.0) return -dBscale(-sample, m);
+    if (sample < 0.0) return dBscale(-sample, m);
     float dB = AudioLevel::multiplier_to_dB(sample);
     if (dB < -50.0) return 0;
     if (dB > 0.0) return m;
     return int(((dB + 50.0) * m) / 50.0 + 0.1);
 }
 
 size_t
-WaveformLayer::getChannelArrangement(size_t &min, size_t &max, bool &merging)
+WaveformLayer::getChannelArrangement(size_t &min, size_t &max,
+                                     bool &merging, bool &mixing)
     const
 {
     if (!m_model || !m_model->isOK()) return 0;
 
     size_t channels = m_model->getChannelCount();

 
     size_t rawChannels = channels;
 
     if (m_channel == -1) {
 	min = 0;
-	if (m_channelMode == MergeChannels) {
+	if (m_channelMode == MergeChannels ||
+            m_channelMode == MixChannels) {
 	    max = 0;
 	    channels = 1;
 	} else {
 	    max = channels - 1;
 	}

 	rawChannels = 1;
 	channels = 1;
     }
 
     merging = (m_channelMode == MergeChannels && rawChannels > 1);
+    mixing = (m_channelMode == MixChannels && rawChannels > 1);
 
 //    std::cerr << "WaveformLayer::getChannelArrangement: min " << min << ", max " << max << ", merging " << merging << ", channels " << channels << std::endl;
 
     return channels;
 }    
+
+bool
+WaveformLayer::isLayerScrollable(const View *) const
+{
+    return !m_autoNormalize;
+}
 
 void
 WaveformLayer::paint(View *v, QPainter &viewPainter, QRect rect) const
 {
     if (!m_model || !m_model->isOK()) {

     std::cerr << "WaveformLayer::paint (" << rect.x() << "," << rect.y()
 	      << ") [" << rect.width() << "x" << rect.height() << "]: zoom " << zoomLevel << ", start " << startFrame << std::endl;
 #endif
 
     size_t channels = 0, minChannel = 0, maxChannel = 0;
-    bool mergingChannels = false;
-
-    channels = getChannelArrangement(minChannel, maxChannel, mergingChannels);
+    bool mergingChannels = false, mixingChannels = false;
+
+    channels = getChannelArrangement(minChannel, maxChannel,
+                                     mergingChannels, mixingChannels);
     if (channels == 0) return;
 
     int w = v->width();
     int h = v->height();
 

 	midColour = midColour.light(150);
     } else {
 	midColour = midColour.light(50);
     }
 
+    while (m_effectiveGains.size() <= maxChannel) {
+        m_effectiveGains.push_back(m_gain);
+    }
+
     for (size_t ch = minChannel; ch <= maxChannel; ++ch) {
 
 	int prevRangeBottom = -1, prevRangeTop = -1;
 	QColor prevRangeBottomColour = m_colour, prevRangeTopColour = m_colour;
 

 	size_t modelZoomLevel = zoomLevel;
 
 	ranges = m_model->getRanges
 	    (ch, frame0 < 0 ? 0 : frame0, frame1, modelZoomLevel);
         
-	if (mergingChannels) {
+	if (mergingChannels || mixingChannels) {
 	    otherChannelRanges = m_model->getRanges
 		(1, frame0 < 0 ? 0 : frame0, frame1, modelZoomLevel);
 	}
+
+        m_effectiveGains[ch] = m_gain;
+
+        if (m_autoNormalize) {
+            RangeSummarisableTimeValueModel::Range range =
+                m_model->getRange(ch, startFrame < 0 ? 0 : startFrame,
+                                  v->getEndFrame());
+            if (mergingChannels || mixingChannels) {
+                RangeSummarisableTimeValueModel::Range otherRange =
+                    m_model->getRange(1, startFrame < 0 ? 0 : startFrame,
+                                      v->getEndFrame());
+                range.max = std::max(range.max, otherRange.max);
+                range.min = std::min(range.min, otherRange.min);
+                range.absmean = std::min(range.absmean, otherRange.absmean);
+            }
+            m_effectiveGains[ch] = 1.0 / std::max(fabsf(range.max),
+                                                  fabsf(range.min));
+        }
+
+        float gain = m_effectiveGains[ch];
 
 	for (int x = x0; x <= x1; ++x) {
 
 	    range = RangeSummarisableTimeValueModel::Range();
 	    size_t index = x - x0;

 			range.min = std::min
 			    (range.min,
 			     -fabsf(otherChannelRanges[maxIndex].max));
 		    }
 		}
-	    }
+
+	    } else if (mixingChannels) {
+
+		if (index < otherChannelRanges.size()) {
+
+                    range.max = (range.max + otherChannelRanges[index].max) / 2;
+                    range.min = (range.min + otherChannelRanges[index].min) / 2;
+                    range.absmean = (range.absmean + otherChannelRanges[index].absmean) / 2;
+                }
+            }
 
 	    int greyLevels = 1;
 	    if (m_greyscale && (m_scale == LinearScale)) greyLevels = 4;
 
 	    switch (m_scale) {
 
 	    case LinearScale:
-		rangeBottom = int( m * greyLevels * range.min * m_gain);
-		rangeTop    = int( m * greyLevels * range.max * m_gain);
-		meanBottom  = int(-m * range.absmean * m_gain);
-		meanTop     = int( m * range.absmean * m_gain);
+		rangeBottom = int( m * greyLevels * range.min * gain);
+		rangeTop    = int( m * greyLevels * range.max * gain);
+		meanBottom  = int(-m * range.absmean * gain);
+		meanTop     = int( m * range.absmean * gain);
 		break;
 
 	    case dBScale:
-		rangeBottom =  dBscale(range.min * m_gain, m * greyLevels);
-		rangeTop    =  dBscale(range.max * m_gain, m * greyLevels);
-		meanBottom  = -dBscale(range.absmean * m_gain, m);
-		meanTop     =  dBscale(range.absmean * m_gain, m);
+                if (!mergingChannels) {
+                    int db0 = dBscale(range.min * gain, m);
+                    int db1 = dBscale(range.max * gain, m);
+                    rangeTop    = std::max(db0, db1);
+                    meanTop     = std::min(db0, db1);
+                    if (mixingChannels) rangeBottom = meanTop;
+                    else rangeBottom = dBscale(range.absmean * gain, m);
+                    meanBottom  = rangeBottom;
+                } else {
+                    rangeBottom = -dBscale(range.min * gain, m * greyLevels);
+                    rangeTop    =  dBscale(range.max * gain, m * greyLevels);
+                    meanBottom  = -dBscale(range.absmean * gain, m);
+                    meanTop     =  dBscale(range.absmean * gain, m);
+                }
 		break;
 
 	    case MeterScale:
-		rangeBottom =  AudioLevel::multiplier_to_preview(range.min * m_gain, m * greyLevels);
-		rangeTop    =  AudioLevel::multiplier_to_preview(range.max * m_gain, m * greyLevels);
-		meanBottom  = -AudioLevel::multiplier_to_preview(range.absmean * m_gain, m);
-		meanTop     =  AudioLevel::multiplier_to_preview(range.absmean * m_gain, m);
+                if (!mergingChannels) {
+                    int r0 = abs(AudioLevel::multiplier_to_preview(range.min * gain, m));
+                    int r1 = abs(AudioLevel::multiplier_to_preview(range.max * gain, m));
+                    rangeTop    = std::max(r0, r1);
+                    meanTop     = std::min(r0, r1);
+                    if (mixingChannels) rangeBottom = meanTop;
+                    else rangeBottom = AudioLevel::multiplier_to_preview(range.absmean * gain, m);
+                    meanBottom  = rangeBottom;
+                } else {
+                    rangeBottom =  AudioLevel::multiplier_to_preview(range.min * gain, m * greyLevels);
+                    rangeTop    =  AudioLevel::multiplier_to_preview(range.max * gain, m * greyLevels);
+                    meanBottom  = -AudioLevel::multiplier_to_preview(range.absmean * gain, m);
+                    meanTop     =  AudioLevel::multiplier_to_preview(range.absmean * gain, m);
+                }
+                break;
 	    }
 
 	    rangeBottom = my * greyLevels - rangeBottom;
 	    rangeTop    = my * greyLevels - rangeTop;
 	    meanBottom  = my - meanBottom;

 	    if (rangeTop < my - m) { rangeTop = my - m; }
 	    if (rangeTop > my + m) { rangeTop = my + m; }
 	    if (rangeBottom < my - m) { rangeBottom = my - m; }
 	    if (rangeBottom > my + m) { rangeBottom = my + m; }
 
-	    if (range.max * m_gain <= -1.0 ||
-		range.max * m_gain >= 1.0) clipped = true;
+	    if (range.max <= -1.0 ||
+		range.max >= 1.0) clipped = true;
 	    
 	    if (meanBottom > rangeBottom) meanBottom = rangeBottom;
 	    if (meanTop < rangeTop) meanTop = rangeTop;
 
 	    bool drawMean = m_showMeans;
 	    if (meanTop == rangeTop) {
 		if (meanTop < meanBottom) ++meanTop;
 		else drawMean = false;
 	    }
-	    if (meanBottom == rangeBottom) {
+	    if (meanBottom == rangeBottom && m_scale == LinearScale) {
 		if (meanBottom > meanTop) --meanBottom;
 		else drawMean = false;
 	    }
 
 	    if (x != x0 && prevRangeBottom != -1) {

 		    paint->drawPoint(x-1, prevRangeBottom);
 		}
 	    }
 
 	    if (ready) {
-		if (clipped ||
-		    range.min * m_gain <= -1.0 ||
-		    range.max * m_gain >=  1.0) {
+		if (clipped /*!!! ||
+		    range.min * gain <= -1.0 ||
+		    range.max * gain >=  1.0 */) {
 		    paint->setPen(Qt::red);
 		} else {
 		    paint->setPen(m_colour);
 		}
 	    } else {

 	text += tr("Time:\t%1")
 	    .arg(rt0.toText(true).c_str());
     }
 
     size_t channels = 0, minChannel = 0, maxChannel = 0;
-    bool mergingChannels = false;
-
-    channels = getChannelArrangement(minChannel, maxChannel, mergingChannels);
+    bool mergingChannels = false, mixingChannels = false;
+
+    channels = getChannelArrangement(minChannel, maxChannel,
+                                     mergingChannels, mixingChannels);
     if (channels == 0) return "";
 
     for (size_t ch = minChannel; ch <= maxChannel; ++ch) {
 
 	size_t blockSize = v->getZoomLevel();

     if (!m_model || !m_model->isOK()) {
 	return;
     }
 
     size_t channels = 0, minChannel = 0, maxChannel = 0;
-    bool mergingChannels = false;
-
-    channels = getChannelArrangement(minChannel, maxChannel, mergingChannels);
+    bool mergingChannels = false, mixingChannels = false;
+
+    channels = getChannelArrangement(minChannel, maxChannel,
+                                     mergingChannels, mixingChannels);
     if (channels == 0) return;
 
     int h = rect.height(), w = rect.width();
     int textHeight = paint.fontMetrics().height();
     int toff = -textHeight/2 + paint.fontMetrics().ascent() + 1;
 
+    float gain = m_gain;
+
     for (size_t ch = minChannel; ch <= maxChannel; ++ch) {
 
 	int m = (h / channels) / 2;
 	int my = m + (((ch - minChannel) * h) / channels);
 	int py = -1;
 
+        if (ch < m_effectiveGains.size()) gain = m_effectiveGains[ch];
+
 	for (int i = 0; i <= 10; ++i) {
 
 	    int vy = 0;
 	    QString text = "";
 
 	    if (m_scale == LinearScale) {
 
-		vy = int((m * i * m_gain) / 10);
+		vy = int((m * i * gain) / 10);
 
 		text = QString("%1").arg(float(i) / 10.0);
 		if (i == 0) text = "0.0";
 		if (i == 10) text = "1.0";
 

 		    static int dbs[] = { -50, -40, -30, -20, -15,
 					 -10, -5, -3, -2, -1, 0 };
 		    db = dbs[i];
 		    if (db == -50) minvalue = true;
 		    vy = AudioLevel::multiplier_to_preview
-			(AudioLevel::dB_to_multiplier(db) * m_gain, m);
+			(AudioLevel::dB_to_multiplier(db) * gain, m);
 		} else {
 		    db = -100 + i * 10;
 		    if (db == -100) minvalue = true;
 		    vy = dBscale
-			(AudioLevel::dB_to_multiplier(db) * m_gain, m);
+			(AudioLevel::dB_to_multiplier(db) * gain, m);
 		}
 
 		text = QString("%1").arg(db);
 		if (db == 0) text = tr("0dB");
 		if (minvalue) {

 		    vy = 0;
 		}
 	    }
 
 	    if (vy < 0) vy = -vy;
-	    if (vy >= m - 1) continue;
+//	    if (vy >= m - 1) continue;
 
 	    if (py >= 0 && (vy - py) < textHeight - 1) {
 		paint.drawLine(w - 4, my - vy, w, my - vy);
 		if (vy > 0) paint.drawLine(w - 4, my + vy, w, my + vy);
 		continue;

 	    int tx = 3;
 	    if (m_scale != LinearScale) {
 		tx = w - 10 - paint.fontMetrics().width(text);
 	    }
 	    
+	    if (vy >= m - 1) continue;
+
 	    paint.drawText(tx, my - vy + toff, text);
 	    if (vy > 0) paint.drawText(tx, my + vy + toff, text);
 		
 	    py = vy;
 	}

 		 "showMeans=\"%3\" "
 		 "greyscale=\"%4\" "
 		 "channelMode=\"%5\" "
 		 "channel=\"%6\" "
 		 "scale=\"%7\" "
-		 "aggressive=\"%8\"")
+		 "aggressive=\"%8\" "
+                 "autoNormalize=\"%9\"")
 	.arg(m_gain)
 	.arg(encodeColour(m_colour))
 	.arg(m_showMeans)
 	.arg(m_greyscale)
 	.arg(m_channelMode)
 	.arg(m_channel)
 	.arg(m_scale)
-	.arg(m_aggressive);
+	.arg(m_aggressive)
+        .arg(m_autoNormalize);
 
     return Layer::toXmlString(indent, extraAttributes + " " + s);
 }
 
 void

     if (ok) setScale(scale);
 
     bool aggressive = (attributes.value("aggressive") == "1" ||
 		       attributes.value("aggressive") == "true");
     setUseGreyscale(aggressive);
+
+    bool autoNormalize = (attributes.value("autoNormalize") == "1" ||
+                          attributes.value("autoNormalize") == "true");
+    setAutoNormalize(autoNormalize);
 }
 
 #ifdef INCLUDE_MOCFILES
 #include "WaveformLayer.moc.cpp"
 #endif