comparison data/model/WaveFileModel.cpp @ 232:03a24547cf3c

* Fix crash in short spectrogram paint
* Fix incorrect apparent end point for waveforms

 	size_t endIndex = end / cacheBlock;
 
 	float max = 0.0, min = 0.0, total = 0.0;
 	size_t i = 0, count = 0;
 
-	//cerr << "blockSize is " << blockSize << ", cacheBlock " << cacheBlock << ", start " << start << ", end " << end << ", power is " << power << ", div is " << div << ", startIndex " << startIndex << ", endIndex " << endIndex << endl;
+	cerr << "blockSize is " << blockSize << ", cacheBlock " << cacheBlock << ", start " << start << ", end " << end << " (frame count " << getFrameCount() << "), power is " << power << ", div is " << div << ", startIndex " << startIndex << ", endIndex " << endIndex << endl;
 
 	for (i = 0; i < endIndex - startIndex; ) {
         
 	    size_t index = (i + startIndex) * channels + channel;
 	    if (index >= cache.size()) break;

 	if (count > 0) {
             ranges.push_back(Range(min, max, total / count));
 	}
     }
 
-    //cerr << "returning " << ranges.size() << " ranges" << endl;
+    cerr << "returning " << ranges.size() << " ranges" << endl;
     return;
 }
 
 WaveFileModel::Range
 WaveFileModel::getRange(size_t channel, size_t start, size_t end) const

 
             m_model.m_reader->getInterleavedFrames(frame, readBlockSize, block);
 
             for (size_t i = 0; i < readBlockSize; ++i) {
 		
+                if (channels * i + channels > block.size()) break;
+
                 for (size_t ch = 0; ch < size_t(channels); ++ch) {
 
                     size_t index = channels * i + ch;
-                    if (index >= block.size()) continue;
                     float sample = block[index];
                     
-                    for (size_t ct = 0; ct < 2; ++ct) {
+                    for (size_t ct = 0; ct < 2; ++ct) { // cache type
                         
                         size_t rangeIndex = ch * 2 + ct;
                         
                         if (sample > range[rangeIndex].max || count[ct] == 0) {
                             range[rangeIndex].max = sample;

                         range[rangeIndex].absmean += fabsf(sample);
                     }
                 }
                 
                 QMutexLocker locker(&m_model.m_mutex);
+
                 for (size_t ct = 0; ct < 2; ++ct) {
+
                     if (++count[ct] == cacheBlockSize[ct]) {
+
                         for (size_t ch = 0; ch < size_t(channels); ++ch) {
                             size_t rangeIndex = ch * 2 + ct;
                             range[rangeIndex].absmean /= count[ct];
                             m_model.m_cache[ct].push_back(range[rangeIndex]);
                             range[rangeIndex] = Range();
                         }
+
                         count[ct] = 0;
                     }
                 }
                 
                 ++frame;

     }
 
     if (!m_model.m_exiting) {
 
         QMutexLocker locker(&m_model.m_mutex);
+
         for (size_t ct = 0; ct < 2; ++ct) {
+
             if (count[ct] > 0) {
+
                 for (size_t ch = 0; ch < size_t(channels); ++ch) {
                     size_t rangeIndex = ch * 2 + ct;
                     range[rangeIndex].absmean /= count[ct];
                     m_model.m_cache[ct].push_back(range[rangeIndex]);
                     range[rangeIndex] = Range();
                 }
+
                 count[ct] = 0;
             }
             
             const Range &rr = *m_model.m_cache[ct].begin();
             MUNLOCK(&rr, m_model.m_cache[ct].capacity() * sizeof(Range));