comparison transform/FeatureExtractionModelTransformer.cpp @ 1368:d163b04c3ec4

Set abandoned flag when bailing out of run() because init failed at the start; then check that flag in awaitOutputModels() so as not to get stuck on a wait condition

     // first check that they are actually similar as promised)
 
     for (int j = 1; j < (int)m_transforms.size(); ++j) {
         if (!areTransformsSimilar(m_transforms[0], m_transforms[j])) {
             m_message = tr("Transforms supplied to a single FeatureExtractionModelTransformer instance must be similar in every respect except plugin output");
+            SVCERR << m_message << endl;
             return false;
         }
     }
 
     Transform primaryTransform = m_transforms[0];

     FeatureExtractionPluginFactory *factory =
         FeatureExtractionPluginFactory::instance();
 
     if (!factory) {
         m_message = tr("No factory available for feature extraction plugin id \"%1\" (unknown plugin type, or internal error?)").arg(pluginId);
+        SVCERR << m_message << endl;
 	return false;
     }
 
     DenseTimeValueModel *input = getConformingInput();
     if (!input) {
         m_message = tr("Input model for feature extraction plugin \"%1\" is of wrong type (internal error?)").arg(pluginId);
+        SVCERR << m_message << endl;
         return false;
     }
 
     SVDEBUG << "FeatureExtractionModelTransformer: Instantiating plugin for transform in thread "
             << QThread::currentThreadId() << endl;
     
     m_plugin = factory->instantiatePlugin(pluginId, input->getSampleRate());
     if (!m_plugin) {
         m_message = tr("Failed to instantiate plugin \"%1\"").arg(pluginId);
+        SVCERR << m_message << endl;
 	return false;
     }
 
     TransformFactory::getInstance()->makeContextConsistentWithPlugin
         (primaryTransform, m_plugin);
-
+    
     TransformFactory::getInstance()->setPluginParameters
         (primaryTransform, m_plugin);
-
+    
     int channelCount = input->getChannelCount();
     if ((int)m_plugin->getMaxChannelCount() < channelCount) {
 	channelCount = 1;
     }
     if ((int)m_plugin->getMinChannelCount() > channelCount) {
         m_message = tr("Cannot provide enough channels to feature extraction plugin \"%1\" (plugin min is %2, max %3; input model has %4)")
             .arg(pluginId)
             .arg(m_plugin->getMinChannelCount())
             .arg(m_plugin->getMaxChannelCount())
             .arg(input->getChannelCount());
+        SVCERR << m_message << endl;
 	return false;
     }
-
+    
     SVDEBUG << "Initialising feature extraction plugin with channels = "
             << channelCount << ", step = " << primaryTransform.getStepSize()
             << ", block = " << primaryTransform.getBlockSize() << endl;
 
     if (!m_plugin->initialise(channelCount,

                                       primaryTransform.getBlockSize())) {
 
                 SVDEBUG << "Initialisation failed again" << endl;
                 
                 m_message = tr("Failed to initialise feature extraction plugin \"%1\"").arg(pluginId);
+                SVCERR << m_message << endl;
                 return false;
 
             } else {
                 
                 SVDEBUG << "Initialisation succeeded this time" << endl;

                     .arg(pluginId)
                     .arg(pstep)
                     .arg(pblock)
                     .arg(primaryTransform.getStepSize())
                     .arg(primaryTransform.getBlockSize());
+                SVCERR << m_message << endl;
             }
 
         } else {
 
             SVDEBUG << "Initialisation failed" << endl;
                 
             m_message = tr("Failed to initialise feature extraction plugin \"%1\"").arg(pluginId);
+            SVCERR << m_message << endl;
             return false;
         }
     } else {
         SVDEBUG << "Initialisation succeeded" << endl;
     }

             if (m_message != "") {
                 m_message = QString("%1; %2").arg(vm).arg(m_message);
             } else {
                 m_message = vm;
             }
+            SVCERR << m_message << endl;
         }
     }
 
     Vamp::Plugin::OutputList outputs = m_plugin->getOutputDescriptors();
 
     if (outputs.empty()) {
         m_message = tr("Plugin \"%1\" has no outputs").arg(pluginId);
+        SVCERR << m_message << endl;
 	return false;
     }
 
     for (int j = 0; j < (int)m_transforms.size(); ++j) {
 

 
         if ((int)m_descriptors.size() <= j) {
             m_message = tr("Plugin \"%1\" has no output named \"%2\"")
                 .arg(pluginId)
                 .arg(m_transforms[j].getOutput());
+            SVCERR << m_message << endl;
             return false;
         }
     }
 
     for (int j = 0; j < (int)m_transforms.size(); ++j) {

 
 void
 FeatureExtractionModelTransformer::awaitOutputModels()
 {
     m_outputMutex.lock();
-    while (!m_haveOutputs) {
-        m_outputsCondition.wait(&m_outputMutex);
+    while (!m_haveOutputs && !m_abandoned) {
+        m_outputsCondition.wait(&m_outputMutex, 500);
     }
     m_outputMutex.unlock();
 }
 
 FeatureExtractionModelTransformer::~FeatureExtractionModelTransformer()

 }
 
 void
 FeatureExtractionModelTransformer::run()
 {
-    initialise();
+    if (initialise()) {
+        abandon();
+        return;
+    }
     
     DenseTimeValueModel *input = getConformingInput();
-    if (!input) return;
-
-    if (m_outputs.empty()) return;
+    if (!input) {
+        abandon();
+        return;
+    }
+
+    if (m_outputs.empty()) {
+        abandon();
+        return;
+    }
 
     Transform primaryTransform = m_transforms[0];
 
     while (!input->isReady() && !m_abandoned) {
         cerr << "FeatureExtractionModelTransformer::run: Waiting for input model to be ready..." << endl;