comparison layer/WaveformLayer.cpp @ 1367:f5566f7271fe waverevision

Rework waveform renderer to use smooth paths, aiming to get near-pixel-identical results when zoomed out far enough for a single path not to be relevant

     SingleColourLayer(),
     m_model(0),
     m_gain(1.0f),
     m_autoNormalize(false),
     m_showMeans(true),
-    m_greyscale(true),
     m_channelMode(SeparateChannels),
     m_channel(-1),
     m_scale(LinearScale),
     m_middleLineHeight(0.5),
     m_aggressive(false),

     m_cacheValid = false;
     emit layerParametersChanged();
 }
 
 void
-WaveformLayer::setUseGreyscale(bool useGreyscale)
-{
-    if (m_greyscale == useGreyscale) return;
-    m_greyscale = useGreyscale;
-    m_cacheValid = false;
-    emit layerParametersChanged();
-}
-
-void
 WaveformLayer::setChannelMode(ChannelMode channelMode)
 {
     if (m_channelMode == channelMode) return;
     m_channelMode = channelMode;
     m_cacheValid = false;

         unit = "dB";
     }
     return true;
 }
 
-int
+double
 WaveformLayer::dBscale(double sample, int m) const
 {
     if (sample < 0.0) return dBscale(-sample, m);
     double 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);
+    return ((dB + 50.0) * m) / 50.0;
 }
 
 int
 WaveformLayer::getChannelArrangement(int &min, int &max,
                                      bool &merging, bool &mixing)

 
     } else {
         paint = &viewPainter;
     }
 
-    paint->setRenderHint(QPainter::Antialiasing, false);
+    paint->setRenderHint(QPainter::Antialiasing, true);
 
     if (m_middleLineHeight != 0.5) {
         paint->save();
         double space = m_middleLineHeight * 2;
         if (space > 1.0) space = 2.0 - space;

     channels = getChannelArrangement(minChannel, maxChannel,
                                      mergingChannels, mixingChannels);
     if (channels == 0) return;
 
     QColor baseColour = getBaseQColor();
-    vector<QColor> greys = getPartialShades(v);
-        
     QColor midColour = baseColour;
+    
     if (midColour == Qt::black) {
         midColour = Qt::gray;
     } else if (v->hasLightBackground()) {
         midColour = midColour.light(150);
     } else {
         midColour = midColour.light(50);
     }
 
-    int prevRangeBottom = -1, prevRangeTop = -1;
-    QColor prevRangeBottomColour = baseColour, prevRangeTopColour = baseColour;
-
     double gain = m_effectiveGains[ch];
 
     int m = (h / channels) / 2;
     int my = m + (((ch - minChannel) * h) / channels);
 

         m_channelMode != MergeChannels) {
         m = (h / channels);
         my = m + (((ch - minChannel) * h) / channels);
     }
 
-    paint->setPen(greys[1]);
+    // Horizontal axis along middle
+    paint->setPen(QPen(midColour, 0));
     paint->drawLine(x0, my, x1, my);
 
     paintChannelScaleGuides(v, paint, rect, ch);
   
     int rangeix = ch - minChannel;

     SVCERR << "paint channel " << ch << ": frame0 = " << frame0 << ", frame1 = " << frame1 << ", blockSize = " << blockSize << ", have " << ranges.size() << " range blocks of which ours is index " << rangeix << " with " << ranges[rangeix].size() << " ranges in it" << endl;
 #else
     (void)frame1; // not actually used
 #endif
 
+    QPainterPath waveformPath;
+    QPainterPath meanPath;
+    QPainterPath clipPath;
+    vector<QPointF> individualSamplePoints;
+
+    bool firstPoint = true;
+    
     for (int x = x0; x <= x1; ++x) {
 
         sv_frame_t f0, f1;
         sv_frame_t i0, i1;
 

             SVCERR << "No (or not enough) ranges for index i0 = " << i0 << " (there are " << r.size() << " range(s))" << endl;
 #endif
             continue;
         }
 
-        int rangeBottom = 0, rangeTop = 0, meanBottom = 0, meanTop = 0;
+        double rangeBottom = 0, rangeTop = 0, meanBottom = 0, meanTop = 0;
 
         if (mergingChannels && ranges.size() > 1) {
 
             const auto &other = ranges[1];
             

                 range.setMin((range.min() + other[i0].min()) / 2);
                 range.setAbsmean((range.absmean() + other[i0].absmean()) / 2);
             }
         }
 
-        int greyLevels = 1;
-        if (m_greyscale && (m_scale == LinearScale)) greyLevels = 4;
-
         switch (m_scale) {
 
         case LinearScale:
-            rangeBottom = int(double(m * greyLevels) * range.min() * gain);
-            rangeTop    = int(double(m * greyLevels) * range.max() * gain);
-            meanBottom  = int(double(-m) * range.absmean() * gain);
-            meanTop     = int(double(m) * range.absmean() * gain);
+            rangeBottom = range.min() * gain * m;
+            rangeTop    = range.max() * gain * m;
+            meanBottom  = range.absmean() * gain * (-m);
+            meanTop     = range.absmean() * gain * m;
             break;
 
         case dBScale:
             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);
+                double db0 = dBscale(range.min() * gain, m);
+                double 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);
+                rangeTop = dBscale(range.max() * gain, m);
+                meanBottom = -dBscale(range.absmean() * gain, m);
+                meanTop = dBscale(range.absmean() * gain, m);
+            }
+            break;
+
+        case MeterScale:
+            if (!mergingChannels) {
+                double r0 = fabs(AudioLevel::multiplier_to_preview
+                                 (range.min() * gain, m));
+                double r1 = fabs(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 = -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);
+                rangeBottom = -AudioLevel::multiplier_to_preview
+                    (range.min() * gain, m);
+                rangeTop = AudioLevel::multiplier_to_preview
+                    (range.max() * gain, m);
+                meanBottom = -AudioLevel::multiplier_to_preview
+                    (range.absmean() * gain, m);
+                meanTop = AudioLevel::multiplier_to_preview
+                    (range.absmean() * gain, m);
             }
             break;
-
-        case MeterScale:
-            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;
-        meanTop     = my - meanTop;
-
-        int topFill = (rangeTop % greyLevels);
-        if (topFill > 0) topFill = greyLevels - topFill;
-
-        int bottomFill = (rangeBottom % greyLevels);
-
-        rangeTop = rangeTop / greyLevels;
-        rangeBottom = rangeBottom / greyLevels;
+        }
+
+        rangeBottom = my - rangeBottom;
+        rangeTop = my - rangeTop;
+        meanBottom = my - meanBottom;
+        meanTop = my - meanTop;
 
         bool clipped = false;
 
         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() <= -1.0 ||
-            range.max() >= 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 && m_scale == LinearScale) {
-            if (meanBottom > meanTop) --meanBottom;
-            else drawMean = false;
-        }
-
-        if (showIndividualSample) {
-            paint->setPen(baseColour);
-            paint->drawRect(x-1, rangeTop-1, 2, 2);
-            if (rangeTop != rangeBottom) { // e.g. for "butterfly" merging mode
-                paint->drawRect(x-1, rangeBottom-1, 2, 2);
-            }
-        }
+
+        meanTop = meanTop - 0.5;
+        meanBottom = meanBottom + 0.5;
         
-        if (x != x0 && prevRangeBottom != -1) {
-            if (prevRangeBottom > rangeBottom + 1 &&
-                prevRangeTop    > rangeBottom + 1) {
-//                    paint->setPen(midColour);
-                paint->setPen(baseColour);
-                paint->drawLine(x-1, prevRangeTop, x, rangeBottom + 1);
-                paint->setPen(prevRangeTopColour);
-                paint->drawPoint(x-1, prevRangeTop);
-            } else if (prevRangeBottom < rangeTop - 1 &&
-                       prevRangeTop    < rangeTop - 1) {
-//                    paint->setPen(midColour);
-                paint->setPen(baseColour);
-                paint->drawLine(x-1, prevRangeBottom, x, rangeTop - 1);
-                paint->setPen(prevRangeBottomColour);
-                paint->drawPoint(x-1, prevRangeBottom);
-            }
-        }
-
-        if (m_model->isReady()) {
-            if (clipped /*!!! ||
-                          range.min() * gain <= -1.0 ||
-                          range.max() * gain >=  1.0 */) {
-                paint->setPen(Qt::red); //!!! getContrastingColour
-            } else {
-                paint->setPen(baseColour);
-            }
-        } else {
-            paint->setPen(midColour);
+        if (meanTop <= rangeTop + 1.0) {
+            meanTop = rangeTop + 1.0;
+        }
+        if (meanBottom >= rangeBottom - 1.0 && m_scale == LinearScale) {
+            meanBottom = rangeBottom - 1.0;
+        }
+        if (meanTop > meanBottom - 1.0) {
+            drawMean = false;
         }
 
 #ifdef DEBUG_WAVEFORM_PAINT_BY_PIXEL
         SVCERR << "range " << rangeBottom << " -> " << rangeTop << ", means " << meanBottom << " -> " << meanTop << ", raw range " << range.min() << " -> " << range.max() << endl;
 #endif
 
-        if (rangeTop == rangeBottom) {
-            paint->drawPoint(x, rangeTop);
+        double rangeMiddle = (rangeTop + rangeBottom) / 2.0;
+        bool trivialRange = (fabs(rangeTop - rangeBottom) < 1.0);
+        double px = x + 0.5;
+        
+        if (showIndividualSample) {
+            individualSamplePoints.push_back(QPointF(px, rangeTop));
+            if (!trivialRange) {
+                // common e.g. in "butterfly" merging mode
+                individualSamplePoints.push_back(QPointF(px, rangeBottom));
+            }
+        }
+        
+        if (firstPoint) {
+            waveformPath = QPainterPath(QPointF(px, rangeMiddle));
+            firstPoint = false;
         } else {
-            paint->drawLine(x, rangeBottom, x, rangeTop);
-        }
-
-        prevRangeTopColour = baseColour;
-        prevRangeBottomColour = baseColour;
-
-        if (m_greyscale && (m_scale == LinearScale) && m_model->isReady()) {
-            if (!clipped) {
-                if (rangeTop < rangeBottom) {
-                    if (topFill > 0 &&
-                        (!drawMean || (rangeTop < meanTop - 1))) {
-                        paint->setPen(greys[topFill - 1]);
-                        paint->drawPoint(x, rangeTop);
-                        prevRangeTopColour = greys[topFill - 1];
-                    }
-                    if (bottomFill > 0 && 
-                        (!drawMean || (rangeBottom > meanBottom + 1))) {
-                        paint->setPen(greys[bottomFill - 1]);
-                        paint->drawPoint(x, rangeBottom);
-                        prevRangeBottomColour = greys[bottomFill - 1];
-                    }
-                }
-            }
-        }
-        
+            waveformPath.lineTo(QPointF(px, rangeMiddle));
+        }
+
+        if (!trivialRange) {
+            waveformPath.lineTo(QPointF(px, rangeTop));
+            waveformPath.lineTo(QPointF(px, rangeBottom));
+            waveformPath.lineTo(QPointF(px, rangeMiddle));
+        }
+
         if (drawMean) {
-            paint->setPen(midColour);
-            paint->drawLine(x, meanBottom, x, meanTop);
-        }
-        
-        prevRangeBottom = rangeBottom;
-        prevRangeTop = rangeTop;
+            meanPath.moveTo(QPointF(px, meanBottom));
+            meanPath.lineTo(QPointF(px, meanTop));
+        }
+
+        if (clipped) {
+            if (trivialRange) {
+                clipPath.moveTo(QPointF(px, rangeMiddle));
+                clipPath.lineTo(QPointF(px+1, rangeMiddle));
+            } else {
+                clipPath.moveTo(QPointF(px, rangeBottom));
+                clipPath.lineTo(QPointF(px, rangeTop));
+            }
+        }
+    }
+
+    double penWidth = 1.0;
+    
+    if (m_model->isReady()) {
+        paint->setPen(QPen(baseColour, penWidth));
+    } else {
+        paint->setPen(QPen(midColour, penWidth));
+    }
+    paint->drawPath(waveformPath);
+
+    if (!clipPath.isEmpty()) {
+        paint->save();
+        paint->setPen(QPen(ColourDatabase::getInstance()->
+                           getContrastingColour(m_colour), penWidth));
+        paint->drawPath(clipPath);
+        paint->restore();
+    }
+
+    if (!meanPath.isEmpty()) {
+        paint->save();
+        paint->setPen(QPen(midColour, penWidth));
+        paint->drawPath(meanPath);
+        paint->restore();
+    }
+    
+    if (!individualSamplePoints.empty()) {
+        paint->save();
+        paint->setPen(QPen(baseColour, penWidth));
+        double sz = ViewManager::scalePixelSize(2.0);
+        for (QPointF p: individualSamplePoints) {
+            paint->drawRect(QRectF(p.x() - sz/2, p.y() - sz/2, sz, sz));
+        }
+        paint->restore();
     }
 }
 
 void
 WaveformLayer::paintChannelScaleGuides(LayerGeometryProvider *v,

     case MeterScale:
         vy = AudioLevel::multiplier_to_preview(value, m);
         break;
 
     case dBScale:
-        vy = dBscale(value, m);
+        vy = int(dBscale(value, m));
         break;
     }
 
 //    SVCERR << "mergingChannels= " << mergingChannels << ", channel  = " << channel << ", value = " << value << ", vy = " << vy << endl;
 

                  "middleLineHeight=\"%7\" "
                  "aggressive=\"%8\" "
                  "autoNormalize=\"%9\"")
         .arg(m_gain)
         .arg(m_showMeans)
-        .arg(m_greyscale)
+        .arg(true) // Option removed, but effectively always on, so
+                   // retained in the session file for compatibility
         .arg(m_channelMode)
         .arg(m_channel)
         .arg(m_scale)
         .arg(m_middleLineHeight)
         .arg(m_aggressive)

 
     bool showMeans = (attributes.value("showMeans") == "1" ||
                       attributes.value("showMeans") == "true");
     setShowMeans(showMeans);
 
-    bool greyscale = (attributes.value("greyscale") == "1" ||
-                      attributes.value("greyscale") == "true");
-    setUseGreyscale(greyscale);
-
     ChannelMode channelMode = (ChannelMode)
         attributes.value("channelMode").toInt(&ok);
     if (ok) setChannelMode(channelMode);
 
     int channel = attributes.value("channel").toInt(&ok);

     float middleLineHeight = attributes.value("middleLineHeight").toFloat(&ok);
     if (ok) setMiddleLineHeight(middleLineHeight);
 
     bool aggressive = (attributes.value("aggressive") == "1" ||
                        attributes.value("aggressive") == "true");
-    setUseGreyscale(aggressive);
+    setAggressiveCacheing(aggressive);
 
     bool autoNormalize = (attributes.value("autoNormalize") == "1" ||
                           attributes.value("autoNormalize") == "true");
     setAutoNormalize(autoNormalize);
 }