comparison data/fileio/QuickTimeFileReader.cpp @ 297:c022976d18e8

* Merge from sv-match-alignment branch (excluding alignment-specific document).
  - add aggregate wave model (not yet complete enough to be added as a true
    model in a layer, but there's potential)
  - add play solo mode
  - add alignment model -- unused in plain SV
  - fix two plugin leaks
  - add m3u playlist support (opens all files at once, potentially hazardous)
  - fix retrieval of pre-encoded URLs
  - add ability to resample audio files on import, so as to match rates with
    other files previously loaded; add preference for same
  - add preliminary support in transform code for range and rate of transform
    input
  - reorganise preferences dialog, move dark-background option to preferences,
    add option for temporary directory location

 };
 
 
 QuickTimeFileReader::QuickTimeFileReader(QString path,
                                          DecodeMode decodeMode,
-                                         CacheMode mode) :
-    CodedAudioFileReader(mode),
+                                         CacheMode mode,
+                                         size_t targetRate) :
+    CodedAudioFileReader(mode, targetRate),
     m_path(path),
     m_d(new D),
     m_progress(0),
     m_cancelled(false),
     m_completion(0),
     m_decodeThread(0)
 {
-    m_frameCount = 0;
     m_channelCount = 0;
-    m_sampleRate = 0;
+    m_fileRate = 0;
 
     Profiler profiler("QuickTimeFileReader::QuickTimeFileReader", true);
 
 std::cerr << "QuickTimeFileReader: path is \"" << path.toStdString() << "\"" << std::endl;
 

         m_error = QString("Error in QuickTime decoder property get: code %1").arg(m_d->err);
         return;
     }
 	
     m_channelCount = m_d->asbd.mChannelsPerFrame;
-    m_sampleRate = m_d->asbd.mSampleRate;
-
-    std::cerr << "QuickTime: " << m_channelCount << " channels, " << m_sampleRate << " kHz" << std::endl;
+    m_fileRate = m_d->asbd.mSampleRate;
+
+    std::cerr << "QuickTime: " << m_channelCount << " channels, " << m_fileRate << " kHz" << std::endl;
 
     m_d->asbd.mFormatFlags =
         kAudioFormatFlagIsFloat |
         kAudioFormatFlagIsPacked |
         kAudioFormatFlagsNativeEndian;

                 break;
             }
 
 //    std::cerr << "Read " << framesRead << " frames (block size " << m_d->blockSize << ")" << std::endl;
 
-            m_frameCount += framesRead;
-
             // QuickTime buffers are interleaved unless specified otherwise
-            for (UInt32 i = 0; i < framesRead * m_channelCount; ++i) {
-                addSampleToDecodeCache(m_d->data[i]);
-            }
+            addSamplesToDecodeCache(m_d->data, framesRead);
 
             if (framesRead < m_d->blockSize) break;
         }
         
         finishDecodeCache();

 }
 
 void
 QuickTimeFileReader::DecodeThread::run()
 {
+    if (m_reader->m_cacheMode == CacheInTemporaryFile) {
+        m_reader->m_completion = 1;
+        m_reader->startSerialised("QuickTimeFileReader::Decode");
+    }
+
     while (1) {
             
         UInt32 framesRead = m_reader->m_d->blockSize;
         UInt32 extractionFlags = 0;
         m_reader->m_d->err = MovieAudioExtractionFillBuffer

             m_reader->m_error = QString("Error in QuickTime decoding: code %1")
                 .arg(m_reader->m_d->err);
             break;
         }
        
-        m_reader->m_frameCount += framesRead;
- 
         // QuickTime buffers are interleaved unless specified otherwise
-        for (UInt32 i = 0; i < framesRead * m_reader->m_channelCount; ++i) {
-            m_reader->addSampleToDecodeCache(m_reader->m_d->data[i]);
-        }
+        addSamplesToDecodeCache(m_d->data, framesRead);
         
         if (framesRead < m_reader->m_d->blockSize) break;
     }
         
     m_reader->finishDecodeCache();

     if (m_reader->m_d->err) {
         m_reader->m_error = QString("Error ending QuickTime extraction session: code %1").arg(m_reader->m_d->err);
     }
     
     m_reader->m_completion = 100;
+    m_reader->endSerialised();
 } 
 
 void
 QuickTimeFileReader::getSupportedExtensions(std::set<QString> &extensions)
 {

     extensions.insert("mp4");
     extensions.insert("wav");
 }
 
 #endif
+