comparison data/model/ReadOnlyWaveFileModel.cpp @ 1527:710e6250a401 zoom

Merge from default branch

 {
     m_exiting = true;
     if (m_fillThread) m_fillThread->wait();
     if (m_myReader) delete m_reader;
     m_reader = 0;
+
+    SVDEBUG << "ReadOnlyWaveFileModel: Destructor exiting; we had caches of "
+            << (m_cache[0].size() * sizeof(Range)) << " and "
+            << (m_cache[1].size() * sizeof(Range)) << " bytes" << endl;
 }
 
 bool
 ReadOnlyWaveFileModel::isOK() const
 {

 {
     if (m_reader) return m_reader->getLocalFilename();
     return "";
 }
     
-vector<float>
-ReadOnlyWaveFileModel::getData(int channel, sv_frame_t start, sv_frame_t count) const
-{
-    // Read directly from the file.  This is used for e.g. audio
-    // playback or input to transforms.
-
+floatvec_t
+ReadOnlyWaveFileModel::getData(int channel,
+                               sv_frame_t start,
+                               sv_frame_t count)
+    const
+{
+    // Read a single channel (if channel >= 0) or a mixdown of all
+    // channels (if channel == -1) directly from the file.  This is
+    // used for e.g. audio playback or input to transforms.
+
+    Profiler profiler("ReadOnlyWaveFileModel::getData");
+    
 #ifdef DEBUG_WAVE_FILE_MODEL
     cout << "ReadOnlyWaveFileModel::getData[" << this << "]: " << channel << ", " << start << ", " << count << endl;
 #endif
 
     int channels = getChannelCount();
 
     if (channel >= channels) {
-        cerr << "ERROR: WaveFileModel::getData: channel ("
+        SVCERR << "ERROR: WaveFileModel::getData: channel ("
              << channel << ") >= channel count (" << channels << ")"
              << endl;
         return {};
     }
 

             count -= (m_startFrame - start);
             start = 0;
         }
     }
 
-    vector<float> interleaved = m_reader->getInterleavedFrames(start, count);
+    floatvec_t interleaved = m_reader->getInterleavedFrames(start, count);
     if (channels == 1) return interleaved;
 
     sv_frame_t obtained = interleaved.size() / channels;
     
-    vector<float> result(obtained, 0.f);
+    floatvec_t result(obtained, 0.f);
     
     if (channel != -1) {
         // get a single channel
         for (int i = 0; i < obtained; ++i) {
             result[i] = interleaved[i * channels + channel];

     }
 
     return result;
 }
 
-vector<vector<float>>
+vector<floatvec_t>
 ReadOnlyWaveFileModel::getMultiChannelData(int fromchannel, int tochannel,
                                            sv_frame_t start, sv_frame_t count) const
 {
-    // Read directly from the file.  This is used for e.g. audio
-    // playback or input to transforms.
+    // Read a set of channels directly from the file.  This is used
+    // for e.g. audio playback or input to transforms.
+
+    Profiler profiler("ReadOnlyWaveFileModel::getMultiChannelData");
 
 #ifdef DEBUG_WAVE_FILE_MODEL
     cout << "ReadOnlyWaveFileModel::getData[" << this << "]: " << fromchannel << "," << tochannel << ", " << start << ", " << count << endl;
 #endif
 
     int channels = getChannelCount();
 
     if (fromchannel > tochannel) {
-        cerr << "ERROR: ReadOnlyWaveFileModel::getData: fromchannel ("
-                  << fromchannel << ") > tochannel (" << tochannel << ")"
-                  << endl;
+        SVCERR << "ERROR: ReadOnlyWaveFileModel::getMultiChannelData: "
+               << "fromchannel (" << fromchannel
+               << ") > tochannel (" << tochannel << ")"
+               << endl;
         return {};
     }
 
     if (tochannel >= channels) {
-        cerr << "ERROR: ReadOnlyWaveFileModel::getData: tochannel ("
-                  << tochannel << ") >= channel count (" << channels << ")"
-                  << endl;
+        SVCERR << "ERROR: ReadOnlyWaveFileModel::getMultiChannelData: "
+               << "tochannel (" << tochannel
+               << ") >= channel count (" << channels << ")"
+               << endl;
         return {};
     }
 
     if (!m_reader || !m_reader->isOK() || count == 0) {
         return {};

             count -= (m_startFrame - start);
             start = 0;
         }
     }
 
-    vector<float> interleaved = m_reader->getInterleavedFrames(start, count);
+    floatvec_t interleaved = m_reader->getInterleavedFrames(start, count);
     if (channels == 1) return { interleaved };
 
     sv_frame_t obtained = interleaved.size() / channels;
-    vector<vector<float>> result(reqchannels, vector<float>(obtained, 0.f));
+    vector<floatvec_t> result(reqchannels, floatvec_t(obtained, 0.f));
 
     for (int c = fromchannel; c <= tochannel; ++c) {
         int destc = c - fromchannel;
         for (int i = 0; i < obtained; ++i) {
             result[destc][i] = interleaved[i * channels + c];

 
     int channels = getChannelCount();
 
     if (cacheType != 0 && cacheType != 1) {
 
-	// We need to read directly from the file.  We haven't got
-	// this cached.  Hope the requested area is small.  This is
-	// not optimal -- we'll end up reading the same frames twice
-	// for stereo files, in two separate calls to this method.
-	// We could fairly trivially handle this for most cases that
-	// matter by putting a single cache in getInterleavedFrames
-	// for short queries.
+        // We need to read directly from the file.  We haven't got
+        // this cached.  Hope the requested area is small.  This is
+        // not optimal -- we'll end up reading the same frames twice
+        // for stereo files, in two separate calls to this method.
+        // We could fairly trivially handle this for most cases that
+        // matter by putting a single cache in getInterleavedFrames
+        // for short queries.
 
         m_directReadMutex.lock();
 
         if (m_lastDirectReadStart != start ||
             m_lastDirectReadCount != count ||

             m_directRead = m_reader->getInterleavedFrames(start, count);
             m_lastDirectReadStart = start;
             m_lastDirectReadCount = count;
         }
 
-	float max = 0.0, min = 0.0, total = 0.0;
-	sv_frame_t i = 0, got = 0;
-
-	while (i < count) {
-
-	    sv_frame_t index = i * channels + channel;
-	    if (index >= (sv_frame_t)m_directRead.size()) break;
+        float max = 0.0, min = 0.0, total = 0.0;
+        sv_frame_t i = 0, got = 0;
+
+        while (i < count) {
+
+            sv_frame_t index = i * channels + channel;
+            if (index >= (sv_frame_t)m_directRead.size()) break;
             
-	    float sample = m_directRead[index];
+            float sample = m_directRead[index];
             if (sample > max || got == 0) max = sample;
-	    if (sample < min || got == 0) min = sample;
+            if (sample < min || got == 0) min = sample;
             total += fabsf(sample);
 
-	    ++i;
+            ++i;
             ++got;
             
             if (got == blockSize) {
                 ranges.push_back(Range(min, max, total / float(got)));
                 min = max = total = 0.0f;
                 got = 0;
-	    }
-	}
+            }
+        }
 
         m_directReadMutex.unlock();
 
-	if (got > 0) {
+        if (got > 0) {
             ranges.push_back(Range(min, max, total / float(got)));
-	}
-
-	return;
+        }
+
+        return;
 
     } else {
 
-	QMutexLocker locker(&m_mutex);
-    
-	const RangeBlock &cache = m_cache[cacheType];
+        QMutexLocker locker(&m_mutex);
+    
+        const RangeBlock &cache = m_cache[cacheType];
 
         blockSize = roundedBlockSize;
 
-	sv_frame_t cacheBlock, div;
+        sv_frame_t cacheBlock, div;
 
         cacheBlock = (sv_frame_t(1) << m_zoomConstraint.getMinCachePower());
-	if (cacheType == 1) {
-	    cacheBlock = sv_frame_t(double(cacheBlock) * sqrt(2.) + 0.01);
-	}
+        if (cacheType == 1) {
+            cacheBlock = sv_frame_t(double(cacheBlock) * sqrt(2.) + 0.01);
+        }
         div = blockSize / cacheBlock;
 
-	sv_frame_t startIndex = start / cacheBlock;
-	sv_frame_t endIndex = (start + count) / cacheBlock;
-
-	float max = 0.0, min = 0.0, total = 0.0;
-	sv_frame_t i = 0, got = 0;
-
-#ifdef DEBUG_WAVE_FILE_MODEL
-	cerr << "blockSize is " << blockSize << ", cacheBlock " << cacheBlock << ", start " << start << ", count " << count << " (frame count " << getFrameCount() << "), power is " << power << ", div is " << div << ", startIndex " << startIndex << ", endIndex " << endIndex << endl;
-#endif
-
-	for (i = 0; i <= endIndex - startIndex; ) {
+        sv_frame_t startIndex = start / cacheBlock;
+        sv_frame_t endIndex = (start + count) / cacheBlock;
+
+        float max = 0.0, min = 0.0, total = 0.0;
+        sv_frame_t i = 0, got = 0;
+
+#ifdef DEBUG_WAVE_FILE_MODEL
+        cerr << "blockSize is " << blockSize << ", cacheBlock " << cacheBlock << ", start " << start << ", count " << count << " (frame count " << getFrameCount() << "), power is " << power << ", div is " << div << ", startIndex " << startIndex << ", endIndex " << endIndex << endl;
+#endif
+
+        for (i = 0; i <= endIndex - startIndex; ) {
         
-	    sv_frame_t index = (i + startIndex) * channels + channel;
-	    if (!in_range_for(cache, index)) break;
+            sv_frame_t index = (i + startIndex) * channels + channel;
+            if (!in_range_for(cache, index)) break;
             
             const Range &range = cache[index];
             if (range.max() > max || got == 0) max = range.max();
             if (range.min() < min || got == 0) min = range.min();
             total += range.absmean();
             
-	    ++i;
+            ++i;
             ++got;
             
-	    if (got == div) {
-		ranges.push_back(Range(min, max, total / float(got)));
+            if (got == div) {
+                ranges.push_back(Range(min, max, total / float(got)));
                 min = max = total = 0.0f;
                 got = 0;
-	    }
-	}
-		
-	if (got > 0) {
+            }
+        }
+                
+        if (got > 0) {
             ranges.push_back(Range(min, max, total / float(got)));
-	}
+        }
     }
 
 #ifdef DEBUG_WAVE_FILE_MODEL
     cerr << "returning " << ranges.size() << " ranges" << endl;
 #endif

 
 void
 ReadOnlyWaveFileModel::fillTimerTimedOut()
 {
     if (m_fillThread) {
-	sv_frame_t fillExtent = m_fillThread->getFillExtent();
+        sv_frame_t fillExtent = m_fillThread->getFillExtent();
 #ifdef DEBUG_WAVE_FILE_MODEL
         SVDEBUG << "ReadOnlyWaveFileModel::fillTimerTimedOut: extent = " << fillExtent << endl;
 #endif
-	if (fillExtent > m_lastFillExtent) {
-	    emit modelChangedWithin(m_lastFillExtent, fillExtent);
-	    m_lastFillExtent = fillExtent;
-	}
+        if (fillExtent > m_lastFillExtent) {
+            emit modelChangedWithin(m_lastFillExtent, fillExtent);
+            m_lastFillExtent = fillExtent;
+        }
     } else {
 #ifdef DEBUG_WAVE_FILE_MODEL
         SVDEBUG << "ReadOnlyWaveFileModel::fillTimerTimedOut: no thread" << endl;
 #endif
-	emit modelChanged();
+        emit modelChanged();
     }
 }
 
 void
 ReadOnlyWaveFileModel::cacheFilled()

     cacheBlockSize[1] = (int((1 << m_model.m_zoomConstraint.getMinCachePower()) *
                                         sqrt(2.) + 0.01));
     
     sv_frame_t frame = 0;
     const sv_frame_t readBlockSize = 32768;
-    vector<float> block;
+    floatvec_t block;
 
     if (!m_model.isOK()) return;
     
     int channels = m_model.getChannelCount();
     bool updating = m_model.m_reader->isUpdating();

             sv_frame_t gotBlockSize = block.size() / channels;
 
             m_model.m_mutex.lock();
 
             for (sv_frame_t i = 0; i < gotBlockSize; ++i) {
-		
+                
                 for (int ch = 0; ch < channels; ++ch) {
 
                     sv_frame_t index = channels * i + ch;
                     float sample = block[index];