comparison framework/SVFileReader.cpp @ 100:22bf057ea151 1.2-stable

* merge from trunk (1.2 ended up being tracked from trunk, but we may want
  this branch for fixes later)

 #include "data/model/SparseOneDimensionalModel.h"
 #include "data/model/SparseTimeValueModel.h"
 #include "data/model/NoteModel.h"
 #include "data/model/TextModel.h"
 #include "data/model/ImageModel.h"
+
+#include "plugin/transform/TransformFactory.h"
 
 #include "view/Pane.h"
 
 #include "Document.h"
 

     m_currentPane(0),
     m_currentDataset(0),
     m_currentDerivedModel(0),
     m_currentDerivedModelId(-1),
     m_currentPlayParameters(0),
+    m_currentTransformSource(0),
     m_datasetSeparator(" "),
     m_inRow(false),
     m_inLayer(false),
     m_inView(false),
     m_rowNumber(0),

     // model
     // point
     // row
     // view
     // window
+    // plugin
+    // transform
+    // selections
+    // selection
+    // measurement
 
     if (name == "sv") {
 
 	// nothing needed
 	ok = true;

 	ok = readSelection(attributes);
 
     } else if (name == "measurement") {
 
         ok = readMeasurement(attributes);
+
+    } else if (name == "transform") {
+        
+        ok = readTransform(attributes);
+
+    } else if (name == "parameter") {
+
+        ok = readParameter(attributes);
 
     } else {
         std::cerr << "WARNING: SV-XML: Unexpected element \""
                   << name.toLocal8Bit().data() << "\"" << std::endl;
     }

             } else if (haveModel(m_currentDerivedModelId)) {
                 std::cerr << "WARNING: SV-XML: Derivation has existing model "
                           << m_currentDerivedModelId
                           << " as target, not regenerating" << std::endl;
             } else {
+                QString message;
                 m_currentDerivedModel = m_models[m_currentDerivedModelId] =
-                    m_document->addDerivedModel(m_currentTransformer,
-                                                m_currentTransformerSource,
-                                                m_currentTransformerContext,
-                                                m_currentTransformerConfiguration);
+                    m_document->addDerivedModel
+                    (m_currentTransform,
+                     ModelTransformer::Input(m_currentTransformSource,
+                                             m_currentTransformChannel),
+                     message);
+                if (!m_currentDerivedModel) {
+                    emit modelRegenerationFailed(tr("(derived model in SV-XML)"),
+                                                 m_currentTransform.getIdentifier(),
+                                                 message);
+                } else if (message != "") {
+                    emit modelRegenerationWarning(tr("(derived model in SV-XML)"),
+                                                  m_currentTransform.getIdentifier(),
+                                                  message);
+                }                    
             }
         } else {
-            m_document->addDerivedModel(m_currentTransformer,
-                                        m_currentTransformerSource,
-                                        m_currentTransformerContext,
-                                        m_currentDerivedModel,
-                                        m_currentTransformerConfiguration);
+            m_document->addDerivedModel
+                (m_currentTransform,
+                 ModelTransformer::Input(m_currentTransformSource,
+                                         m_currentTransformChannel),
+                 m_currentDerivedModel);
         }
 
         m_addedModels.insert(m_currentDerivedModel);
         m_currentDerivedModel = 0;
         m_currentDerivedModelId = -1;
-        m_currentTransformer = "";
-        m_currentTransformerConfiguration = "";
+        m_currentTransformSource = 0;
+        m_currentTransform = Transform();
+        m_currentTransformChannel = -1;
 
     } else if (name == "row") {
 	m_inRow = false;
     } else if (name == "layer") {
         m_inLayer = false;

         FileFinder *ff = FileFinder::getInstance();
         QString originalPath = attributes.value("file");
         QString path = ff->find(FileFinder::AudioFile,
                                 originalPath, m_location);
 
-        FileSource file(path, true);
+        FileSource file(path, FileSource::ProgressDialog);
         file.waitForStatus();
 
         if (!file.isOK()) {
             std::cerr << "SVFileReader::readModel: Failed to retrieve file \"" << path.toStdString() << "\" for wave file model: " << file.getErrorString().toStdString() << std::endl;
         } else if (!file.isAvailable()) {

     if (isNewLayer) {
 
 	QString name = attributes.value("name");
 	layer->setObjectName(name);
 
+        QString presentationName = attributes.value("presentationName");
+        layer->setPresentationName(presentationName);
+
 	int modelId;
 	bool modelOk = false;
 	modelId = attributes.value("model").trimmed().toInt(&modelOk);
 
 	if (modelOk) {

     if (!modelOk) {
 	std::cerr << "WARNING: SV-XML: No model id specified for derivation" << std::endl;
 	return false;
     }
 
-    QString transform = attributes.value("transform");
-
     if (haveModel(modelId)) {
         m_currentDerivedModel = m_models[modelId];
     } else {
         // we'll regenerate the model when the derivation element ends
         m_currentDerivedModel = 0;

     int sourceId = 0;
     bool sourceOk = false;
     sourceId = attributes.value("source").trimmed().toInt(&sourceOk);
 
     if (sourceOk && haveModel(sourceId)) {
-        m_currentTransformerSource = m_models[sourceId];
+        m_currentTransformSource = m_models[sourceId];
     } else {
-        m_currentTransformerSource = m_document->getMainModel();
-    }
-
-    m_currentTransformer = transform;
-    m_currentTransformerConfiguration = "";
-
-    m_currentTransformerContext = PluginTransformer::ExecutionContext();
+        m_currentTransformSource = m_document->getMainModel();
+    }
+
+    m_currentTransform = Transform();
 
     bool ok = false;
     int channel = attributes.value("channel").trimmed().toInt(&ok);
-    if (ok) m_currentTransformerContext.channel = channel;
-
-    int domain = attributes.value("domain").trimmed().toInt(&ok);
-    if (ok) m_currentTransformerContext.domain = Vamp::Plugin::InputDomain(domain);
+    if (ok) m_currentTransformChannel = channel;
+    else m_currentTransformChannel = -1;
+
+    QString type = attributes.value("type");
+
+    if (type == "transform") {
+        m_currentTransformIsNewStyle = true;
+        return true;
+    } else {
+        m_currentTransformIsNewStyle = false;
+        std::cerr << "NOTE: SV-XML: Reading old-style derivation element"
+                  << std::endl;
+    }
+
+    QString transformId = attributes.value("transform");
+
+    m_currentTransform.setIdentifier(transformId);
 
     int stepSize = attributes.value("stepSize").trimmed().toInt(&ok);
-    if (ok) m_currentTransformerContext.stepSize = stepSize;
+    if (ok) m_currentTransform.setStepSize(stepSize);
 
     int blockSize = attributes.value("blockSize").trimmed().toInt(&ok);
-    if (ok) m_currentTransformerContext.blockSize = blockSize;
+    if (ok) m_currentTransform.setBlockSize(blockSize);
 
     int windowType = attributes.value("windowType").trimmed().toInt(&ok);
-    if (ok) m_currentTransformerContext.windowType = WindowType(windowType);
+    if (ok) m_currentTransform.setWindowType(WindowType(windowType));
+
+    if (!m_currentTransformSource) return true;
 
     QString startFrameStr = attributes.value("startFrame");
     QString durationStr = attributes.value("duration");
 
     size_t startFrame = 0;

     if (durationStr != "") {
         duration = durationStr.trimmed().toInt(&ok);
         if (!ok) duration = 0;
     }
 
-    m_currentTransformerContext.startFrame = startFrame;
-    m_currentTransformerContext.duration = duration;
+    m_currentTransform.setStartTime
+        (RealTime::frame2RealTime
+         (startFrame, m_currentTransformSource->getSampleRate()));
+
+    m_currentTransform.setDuration
+        (RealTime::frame2RealTime
+         (duration, m_currentTransformSource->getSampleRate()));
 
     return true;
 }
 
 bool

     if (m_currentDerivedModelId < 0 && !m_currentPlayParameters) {
         std::cerr << "WARNING: SV-XML: Plugin found outside derivation or play parameters" << std::endl;
         return false;
     }
 
+    if (!m_currentPlayParameters && m_currentTransformIsNewStyle) {
+        return true;
+    }
+
     QString configurationXml = "<plugin";
     
     for (int i = 0; i < attributes.length(); ++i) {
         configurationXml += QString(" %1=\"%2\"")
             .arg(attributes.qName(i))

     configurationXml += "/>";
 
     if (m_currentPlayParameters) {
         m_currentPlayParameters->setPlayPluginConfiguration(configurationXml);
     } else {
-        m_currentTransformerConfiguration += configurationXml;
-    }
-
+        TransformFactory::getInstance()->
+            setParametersFromPluginConfigurationXml(m_currentTransform,
+                                                    configurationXml);
+    }
+
+    return true;
+}
+
+bool
+SVFileReader::readTransform(const QXmlAttributes &attributes)
+{
+    if (m_currentDerivedModelId < 0) {
+        std::cerr << "WARNING: SV-XML: Transform found outside derivation" << std::endl;
+        return false;
+    }
+
+    m_currentTransform = Transform();
+    m_currentTransform.setFromXmlAttributes(attributes);
+    return true;
+}
+
+bool
+SVFileReader::readParameter(const QXmlAttributes &attributes)
+{
+    if (m_currentDerivedModelId < 0) {
+        std::cerr << "WARNING: SV-XML: Parameter found outside derivation" << std::endl;
+        return false;
+    }
+
+    QString name = attributes.value("name");
+    if (name == "") {
+        std::cerr << "WARNING: SV-XML: Ignoring nameless transform parameter"
+                  << std::endl;
+        return false;
+    }
+
+    float value = attributes.value("value").trimmed().toFloat();
+
+    m_currentTransform.setParameter(name, value);
     return true;
 }
 
 bool
 SVFileReader::readSelection(const QXmlAttributes &attributes)