comparison layer/WaveformLayer.cpp @ 200:17f8d9cf60d7

* Return ranges from RangeSummarisableTimeValueModel::getRanges by references
  instead of by return value.  Trying to isolate a Win32 problem.

      
 #ifdef DEBUG_WAVEFORM_PAINT
     std::cerr << "Painting waveform from " << frame0 << " to " << frame1 << " (" << (x1-x0+1) << " pixels at zoom " << zoomLevel << ")" <<  std::endl;
 #endif
 
-    RangeSummarisableTimeValueModel::RangeBlock ranges;
-    RangeSummarisableTimeValueModel::RangeBlock otherChannelRanges;
+    RangeSummarisableTimeValueModel::RangeBlock *ranges = 
+        new RangeSummarisableTimeValueModel::RangeBlock;
+
+    RangeSummarisableTimeValueModel::RangeBlock *otherChannelRanges = 0;
     RangeSummarisableTimeValueModel::Range range;
     
     QColor greys[3];
     if (m_colour == Qt::black) {
 	for (int i = 0; i < 3; ++i) { // 0 lightest, 2 darkest

 
 	if (frame1 <= 0) continue;
 
 	size_t modelZoomLevel = zoomLevel;
 
-	ranges = m_model->getRanges
-	    (ch, frame0 < 0 ? 0 : frame0, frame1, modelZoomLevel);
+	m_model->getRanges
+	    (ch, frame0 < 0 ? 0 : frame0, frame1, *ranges, modelZoomLevel);
         
 	if (mergingChannels || mixingChannels) {
             if (m_model->getChannelCount() > 1) {
-                otherChannelRanges = m_model->getRanges
-                    (1, frame0 < 0 ? 0 : frame0, frame1, modelZoomLevel);
+                if (!otherChannelRanges) {
+                    otherChannelRanges =
+                        new RangeSummarisableTimeValueModel::RangeBlock;
+                }
+                m_model->getRanges
+                    (1, frame0 < 0 ? 0 : frame0, frame1, *otherChannelRanges,
+                     modelZoomLevel);
             } else {
+                if (otherChannelRanges != ranges) delete otherChannelRanges;
                 otherChannelRanges = ranges;
             }
 	}
 
 	for (int x = x0; x <= x1; ++x) {

 		    maxIndex = size_t((double(index + 1) * zoomLevel)
 				      / modelZoomLevel) - 1;
 		}
 	    }
 
-	    if (index < ranges.size()) {
-
-		range = ranges[index];
-
-		if (maxIndex > index && maxIndex < ranges.size()) {
-		    range.max = std::max(range.max, ranges[maxIndex].max);
-		    range.min = std::min(range.min, ranges[maxIndex].min);
+	    if (ranges && index < ranges->size()) {
+
+		range = (*ranges)[index];
+
+		if (maxIndex > index && maxIndex < ranges->size()) {
+		    range.max = std::max(range.max, (*ranges)[maxIndex].max);
+		    range.min = std::min(range.min, (*ranges)[maxIndex].min);
 		    range.absmean = (range.absmean +
-				     ranges[maxIndex].absmean) / 2;
+				     (*ranges)[maxIndex].absmean) / 2;
 		}
 
 	    } else {
 		continue;
 	    }
 
 	    int rangeBottom = 0, rangeTop = 0, meanBottom = 0, meanTop = 0;
 
 	    if (mergingChannels) {
 
-		if (index < otherChannelRanges.size()) {
+		if (otherChannelRanges && index < otherChannelRanges->size()) {
 
 		    range.max = fabsf(range.max);
-		    range.min = -fabsf(otherChannelRanges[index].max);
+		    range.min = -fabsf((*otherChannelRanges)[index].max);
 		    range.absmean = (range.absmean +
-				     otherChannelRanges[index].absmean) / 2;
-
-		    if (maxIndex > index && maxIndex < ranges.size()) {
+				     (*otherChannelRanges)[index].absmean) / 2;
+
+		    if (maxIndex > index && maxIndex < otherChannelRanges->size()) {
 			// let's not concern ourselves about the mean
 			range.min = std::min
 			    (range.min,
-			     -fabsf(otherChannelRanges[maxIndex].max));
+			     -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;
+		if (otherChannelRanges && 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;

 	}
 	paint->end();
 	delete paint;
 	viewPainter.drawPixmap(rect, *m_cache, rect);
     }
+
+    if (otherChannelRanges != ranges) delete otherChannelRanges;
+    delete ranges;
 }
 
 QString
 WaveformLayer::getFeatureDescription(View *v, QPoint &pos) const
 {

     if (channels == 0) return "";
 
     for (size_t ch = minChannel; ch <= maxChannel; ++ch) {
 
 	size_t blockSize = v->getZoomLevel();
-	RangeSummarisableTimeValueModel::RangeBlock ranges =
-	    m_model->getRanges(ch, f0, f1, blockSize);
+	RangeSummarisableTimeValueModel::RangeBlock ranges;
+        m_model->getRanges(ch, f0, f1, ranges, blockSize);
 
 	if (ranges.empty()) continue;
 	
 	RangeSummarisableTimeValueModel::Range range = ranges[0];