comparison runner/FeatureExtractionManager.cpp @ 99:526feaad5820 start-duration

Start time and duration now working

 }
 
 bool FeatureExtractionManager::addFeatureExtractorFromFile
 (QString transformXmlFile, const vector<FeatureWriter*> &writers)
 {
-    RDFTransformFactory factory
-        (QUrl::fromLocalFile(QFileInfo(transformXmlFile).absoluteFilePath())
-         .toString());
-    ProgressPrinter printer("Parsing transforms RDF file");
-    std::vector<Transform> transforms = factory.getTransforms(&printer);
-    if (!factory.isOK()) {
-        cerr << "WARNING: FeatureExtractionManager::addFeatureExtractorFromFile: Failed to parse transforms file: " << factory.getErrorString().toStdString() << endl;
-        if (factory.isRDF()) {
-            return false; // no point trying it as XML
-        }
-    }
-    if (!transforms.empty()) {
-        bool success = true;
-        for (int i = 0; i < (int)transforms.size(); ++i) {
-            if (!addFeatureExtractor(transforms[i], writers)) {
-                success = false;
-            }
-        }
-        return success;
+    bool tryRdf = true;
+
+    if (transformXmlFile.endsWith(".xml") || transformXmlFile.endsWith(".XML")) {
+        // We don't support RDF-XML (and nor does the underlying
+        // parser library) so skip the RDF parse if the filename
+        // suggests XML, to avoid puking out a load of errors from
+        // feeding XML to a Turtle parser
+        tryRdf = false;
+    }
+
+    if (tryRdf) {
+        RDFTransformFactory factory
+            (QUrl::fromLocalFile(QFileInfo(transformXmlFile).absoluteFilePath())
+             .toString());
+        ProgressPrinter printer("Parsing transforms RDF file");
+        std::vector<Transform> transforms = factory.getTransforms(&printer);
+        if (!factory.isOK()) {
+            cerr << "WARNING: FeatureExtractionManager::addFeatureExtractorFromFile: Failed to parse transforms file: " << factory.getErrorString().toStdString() << endl;
+            if (factory.isRDF()) {
+                return false; // no point trying it as XML
+            }
+        }
+        if (!transforms.empty()) {
+            bool success = true;
+            for (int i = 0; i < (int)transforms.size(); ++i) {
+                if (!addFeatureExtractor(transforms[i], writers)) {
+                    success = false;
+                }
+            }
+            return success;
+        }
     }
 
     QFile file(transformXmlFile);
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
         cerr << "ERROR: Failed to open transform XML file \""

 
     size_t frameCount = reader->getFrameCount();
     
 //    cerr << "file has " << frameCount << " frames" << endl;
 
+    int earliestStartFrame = 0;
+    int latestEndFrame = frameCount;
+    bool haveExtents = false;
+
     for (PluginMap::iterator pi = m_plugins.begin();
          pi != m_plugins.end(); ++pi) {
 
         Plugin *plugin = pi->first;
 

         for (TransformWriterMap::iterator ti = pi->second.begin();
              ti != pi->second.end(); ++ti) {
 
             const Transform &transform = ti->first;
 
-            //!!! we may want to set the start and duration times for extraction
-            // in the transform record (defaults of zero indicate extraction
-            // from the whole file)
-//            transform.setStartTime(RealTime::zeroTime);
-//            transform.setDuration
-//                (RealTime::frame2RealTime(reader->getFrameCount(), m_sampleRate));
+            int startFrame = RealTime::realTime2Frame
+                (transform.getStartTime(), m_sampleRate);
+            int duration = RealTime::realTime2Frame
+                (transform.getDuration(), m_sampleRate);
+            if (duration == 0) {
+                duration = frameCount - startFrame;
+            }
+
+            if (!haveExtents || startFrame < earliestStartFrame) {
+                earliestStartFrame = startFrame;
+            }
+            if (!haveExtents || startFrame + duration > latestEndFrame) {
+                latestEndFrame = startFrame + duration;
+            }
+
+            haveExtents = true;
 
             string outputId = transform.getOutput().toStdString();
             if (m_pluginOutputs[plugin].find(outputId) ==
                 m_pluginOutputs[plugin].end()) {
                 //!!! throw?

 */
             }
         }
     }
     
-    long startFrame = 0;
-    long endFrame = frameCount;
-
-/*!!! No -- there is no single transform to pull this stuff from --
- * the transforms may have various start and end times, need to be far
- * cleverer about this if we're going to support them
-
-    RealTime trStartRT = transform.getStartTime();
-    RealTime trDurationRT = transform.getDuration();
-
-    long trStart = RealTime::realTime2Frame(trStartRT, m_sampleRate);
-    long trDuration = RealTime::realTime2Frame(trDurationRT, m_sampleRate);
-
-    if (trStart == 0 || trStart < startFrame) {
-        trStart = startFrame;
-    }
-
-    if (trDuration == 0) {
-        trDuration = endFrame - trStart;
-    }
-    if (trStart + trDuration > endFrame) {
-        trDuration = endFrame - trStart;
-    }
-
-    startFrame = trStart;
-    endFrame = trStart + trDuration;
-*/
+    int startFrame = earliestStartFrame;
+    int endFrame = latestEndFrame;
     
     for (PluginMap::iterator pi = m_plugins.begin();
          pi != m_plugins.end(); ++pi) { 
 
         for (TransformWriterMap::const_iterator ti = pi->second.begin();

     }
 
     ProgressPrinter extractionProgress("Extracting and writing features...");
     int progress = 0;
 
-    for (long i = startFrame; i < endFrame; i += m_blockSize) {
+    for (int i = startFrame; i < endFrame; i += m_blockSize) {
         
         //!!! inefficient, although much of the inefficiency may be
-        // susceptible to optimisation
+        // susceptible to compiler optimisation
         
         SampleBlock frames;
         reader->getInterleavedFrames(i, m_blockSize, frames);
         
         // We have to do our own channel handling here; we can't just