comparison rdf/RDFFeatureWriter.cpp @ 594:f3bb7a3ffd89

* Add rdf-track-uri and rdf-maker-uri options

 
     p.name = "audiofile-uri";
     p.description = "Link the output RDF to the given audio file URI instead of its actual location.";
     p.hasArg = true;
     pl.push_back(p);
+
+    p.name = "track-uri";
+    p.description = "Link the output RDF to the given track URI.";
+    p.hasArg = true;
+    pl.push_back(p);
+
+    p.name = "maker-uri";
+    p.description = "Link the track in the output RDF to the given foaf:maker URI.";
+    p.hasArg = true;
+    pl.push_back(p);
     
     return pl;
 }
 
 void

          i != params.end(); ++i) {
         if (i->first == "plain") {
             m_plain = true;
         }
         if (i->first == "audiofile-uri") {
-            m_suri = i->second.c_str();
+            m_userAudioFileUri = i->second.c_str();
+        }
+        if (i->first == "track-uri") {
+            m_userTrackUri = i->second.c_str();
+        }
+        if (i->first == "maker-uri") {
+            m_userMakerUri = i->second.c_str();
         }
     }
 }
 
 void
 RDFFeatureWriter::setTrackMetadata(QString trackId,
                                    TrackMetadata metadata)
 {
+//    cerr << "setTrackMetadata: title = " << metadata.title.toStdString() << ", maker = " << metadata.maker.toStdString() << endl;
     m_metadata[trackId] = metadata;
 }
 
 void
 RDFFeatureWriter::setFixedEventTypeURI(QString uri)

         exit(1);
     }
 
     if (m_startedStreamTransforms.find(stream) ==
         m_startedStreamTransforms.end()) {
-        cerr << "This stream is new, writing prefixes" << endl;
+//        cerr << "This stream is new, writing prefixes" << endl;
         writePrefixes(stream);
         if (m_singleFileName == "" && !m_stdout) {
             writeSignalDescription(stream, trackId);
         }
     }

     // Appending to an RDF file is tricky, because we need to ensure
     // that our URIs differ from any already in the file.  This is a
     // dirty grubby low-rent way of doing that.  This function is
     // called by FileFeatureWriter::getOutputFile when in append mode.
 
-    std::cerr << "reviewFileForAppending(" << filename.toStdString() << ")" << std::endl;
+//    std::cerr << "reviewFileForAppending(" << filename.toStdString() << ")" << std::endl;
 
     QFile file(filename);
 
     // just return, don't report failure -- function that called us will do that
     if (!file.open(QIODevice::ReadOnly)) return;

 
 void
 RDFFeatureWriter::writeSignalDescription(QTextStream *sptr,
                                          QString trackId)
 {
-    std::cerr << "RDFFeatureWriter::writeSignalDescription" << std::endl;
+//    std::cerr << "RDFFeatureWriter::writeSignalDescription" << std::endl;
 
     QTextStream &stream = *sptr;
 
     /*
      * Describe signal we're analysing (AudioFile, Signal, TimeLine, etc.)

    
     if (m_trackTrackURIs.find(trackId) == m_trackTrackURIs.end()) {
         m_trackTrackURIs[trackId] = QString(":track_%1").arg(signalCount);
     }
     QString trackURI = m_trackTrackURIs[trackId];
+
+    bool userSpecifiedTrack = false;
+    if (m_userTrackUri != "") {
+        trackURI = "<" + m_userTrackUri + ">";
+        m_trackTrackURIs[trackId] = trackURI;
+        userSpecifiedTrack = true;
+    }
     
     if (m_trackTimelineURIs.find(trackId) == m_trackTimelineURIs.end()) {
         m_trackTimelineURIs[trackId] = QString(":signal_timeline_%1").arg(signalCount);
     }
     QString timelineURI = m_trackTimelineURIs[trackId];
 
     QString afURI = url.toEncoded().data();
-    if (m_suri != NULL) afURI = m_suri;
-
-    if (m_metadata.find(trackId) != m_metadata.end()) {
-        TrackMetadata tm = m_metadata[trackId];
-        if (tm.title != "" || tm.maker != "") {
-            // We only write a Track at all if we have some
-            // title/artist metadata to put in it.  Otherwise we can't
-            // be sure that what we have is a Track, in the
-            // publication sense -- it may just be a fragment, a test
-            // file, whatever.  Since we'd have no metadata to
-            // associate with our Track, the only effect of including
-            // a Track would be to assert that this was one, which is
-            // the one thing we wouldn't know...
-            stream << trackURI << " a mo:Track ";
-            if (tm.title != "") {
-                stream << ";\n    dc:title \"\"\"" << tm.title << "\"\"\" ";
-            }
-            if (tm.maker != "") {
-                stream << ";\n    foaf:maker [ a mo:MusicArtist; foaf:name \"\"\"" << tm.maker << "\"\"\" ] ";
-            }
-            if (trackId != "") {
-                stream << ";\n    mo:available_as <" << afURI << "> ";
-            }
-            stream << ".\n\n";
-        }
-    }
-
-    if (trackId != "") {
+    if (m_userAudioFileUri != "") afURI = m_userAudioFileUri;
+
+    bool wantTrack = (userSpecifiedTrack ||
+                      (m_userMakerUri != "") ||
+                      (m_metadata.find(trackId) != m_metadata.end()));
+
+//    cerr << "wantTrack = " << wantTrack << " (userSpecifiedTrack = "
+//         << userSpecifiedTrack << ", m_userMakerUri = " << m_userMakerUri.toStdString() << ", have metadata = " << (m_metadata.find(trackId) != m_metadata.end()) << ")" << endl;
+
+    if (wantTrack) {
+        // We only write a Track at all if we have some title/artist
+        // metadata to put in it, or if the user has requested a
+        // specific track URI.  Otherwise we can't be sure that what
+        // we have is a Track, in the publication sense -- it may just
+        // be a fragment, a test file, whatever.  Since we'd have no
+        // metadata to associate with our Track, the only effect of
+        // including a Track would be to assert that this was one,
+        // which is the one thing we wouldn't know...
+        TrackMetadata tm;
+        if (m_metadata.find(trackId) != m_metadata.end()) {
+            tm = m_metadata[trackId];
+        }
+        stream << trackURI << " a mo:Track ";
+        if (tm.title != "") {
+            stream << ";\n    dc:title \"\"\"" << tm.title << "\"\"\" ";
+        }
+        if (m_userMakerUri != "") {
+            stream << ";\n    foaf:maker <" << m_userMakerUri << "> ";
+        } else if (tm.maker != "") {
+            stream << ";\n    foaf:maker [ a mo:MusicArtist; foaf:name \"\"\"" << tm.maker << "\"\"\" ] ";
+        }
+        if (afURI != "") {
+            stream << ";\n    mo:available_as <" << afURI << "> ";
+        }
+        stream << ".\n\n";
+    }
+
+    if (afURI != "") {
         stream << "<" << afURI << "> a mo:AudioFile ;\n";
         stream << "    mo:encodes " << signalURI << ".\n\n";
     }
 
     stream << signalURI << " a mo:Signal ;\n";