comparison transform/FeatureExtractionPluginTransform.cpp @ 182:21a76c9ed5c3

* Merge transform directory from sv-match-alignment branch
  (the previous comment included notes for this stuff, but I missed it
  in the actual merge)
* Fix crash when a transform fails to create an output model and the
  thread that created the transform then deletes its input model thinking
  it's no longer needed, even though the transform run thread is still
  using it -- fix is to wait() on the transform before returning the
  null output model

     }
 }
 
 FeatureExtractionPluginTransform::~FeatureExtractionPluginTransform()
 {
+    std::cerr << "FeatureExtractionPluginTransform::~FeatureExtractionPluginTransform()" << std::endl;
     delete m_plugin;
     delete m_descriptor;
 }
 
 DenseTimeValueModel *

 void
 FeatureExtractionPluginTransform::run()
 {
     DenseTimeValueModel *input = getInput();
     if (!input) return;
+
+    if (!m_output) return;
 
     while (!input->isReady()) {
 /*
         if (dynamic_cast<WaveFileModel *>(input)) {
             std::cerr << "FeatureExtractionPluginTransform::run: Model is not ready, but it's not a WaveFileModel (it's a " << typeid(input).name() << "), so that's OK" << std::endl;

         }
 */
         std::cerr << "FeatureExtractionPluginTransform::run: Waiting for input model to be ready..." << std::endl;
         sleep(1);
     }
-
-    if (!m_output) return;
 
     size_t sampleRate = m_input->getSampleRate();
 
     size_t channelCount = input->getChannelCount();
     if (m_plugin->getMaxChannelCount() < channelCount) {

         }
     }
 
     long startFrame = m_input->getStartFrame();
     long   endFrame = m_input->getEndFrame();
-    long blockFrame = startFrame;
+
+    long contextStart = m_context.startFrame;
+    long contextDuration = m_context.duration;
+
+    if (contextStart == 0 || contextStart < startFrame) {
+        contextStart = startFrame;
+    }
+
+    if (contextDuration == 0) {
+        contextDuration = endFrame - contextStart;
+    }
+    if (contextStart + contextDuration > endFrame) {
+        contextDuration = endFrame - contextStart;
+    }
+
+    long blockFrame = contextStart;
 
     long prevCompletion = 0;
 
+    setCompletion(0);
+
     while (!m_abandoned) {
 
         if (frequencyDomain) {
-            if (blockFrame - int(m_context.blockSize)/2 > endFrame) break;
+            if (blockFrame - int(m_context.blockSize)/2 >
+                contextStart + contextDuration) break;
         } else {
-            if (blockFrame >= endFrame) break;
+            if (blockFrame >= 
+                contextStart + contextDuration) break;
         }
 
 //	std::cerr << "FeatureExtractionPluginTransform::run: blockFrame "
 //		  << blockFrame << ", endFrame " << endFrame << ", blockSize "
 //                  << m_context.blockSize << std::endl;
 
 	long completion =
-	    (((blockFrame - startFrame) / m_context.stepSize) * 99) /
-	    (   (endFrame - startFrame) / m_context.stepSize);
+	    (((blockFrame - contextStart) / m_context.stepSize) * 99) /
+	    (contextDuration / m_context.stepSize);
 
 	// channelCount is either m_input->channelCount or 1
 
         for (size_t ch = 0; ch < channelCount; ++ch) {
             if (frequencyDomain) {

 	    Vamp::Plugin::Feature feature =
 		features[m_outputFeatureNo][fi];
 	    addFeature(blockFrame, feature);
 	}
 
-	if (blockFrame == startFrame || completion > prevCompletion) {
+	if (blockFrame == contextStart || completion > prevCompletion) {
 	    setCompletion(completion);
 	    prevCompletion = completion;
 	}
 
 	blockFrame += m_context.stepSize;

     int binCount = 1;
     if (m_descriptor->hasFixedBinCount) {
 	binCount = m_descriptor->binCount;
     }
 
-//    std::cerr << "FeatureExtractionPluginTransform::setCompletion("
-//              << completion << ")" << std::endl;
+    std::cerr << "FeatureExtractionPluginTransform::setCompletion("
+              << completion << ")" << std::endl;
 
     if (binCount == 0) {
 
 	SparseOneDimensionalModel *model = getOutput<SparseOneDimensionalModel>();
 	if (!model) return;