comparison runner/main.cpp @ 288:fd4a6183482f kapoor_1202

Merge from branch piper-nopiper. The next release will be based on this.

 #include "../version.h"
 
 #include "base/Exceptions.h"
 #include "base/TempDirectory.h"
 #include "base/ProgressPrinter.h"
+#include "base/Debug.h"
 
 #include "data/fileio/AudioFileReaderFactory.h"
 #include "data/fileio/PlaylistFileReader.h"
 
 #include "transform/Transform.h"

              << wrapCol("Normalise each input audio file to signal abs max = 1.f.")
              << endl << endl;
         cerr << "  -f, --force         "
              << wrapCol("Continue with subsequent files following an error.")
              << endl << endl;
+        cerr << "  -q, --quiet         "
+             << wrapCol("Suppress informational output that would otherwise be printed to stderr and to a log file. Sonic Annotator may run faster with this option, especially if the application data directory is on a shared storage resource, but no diagnostic information will be available except for the application's return code.")
+             << endl << endl;
         cerr << "Housekeeping options:"
              << endl << endl;
         cerr << "  -l, --list          List available transform ids to standard output." << endl;
         cerr << "      --list-writers  List supported writer types to standard output." << endl;
         cerr << "      --list-formats  List supported input audio formats to standard output." << endl;

 findSourcesRecursive(QString dirname, QStringList &addTo, int &found)
 {
     QDir dir(dirname);
 
     QString printable = dir.dirName().left(20);
-    cerr << "\rScanning \"" << printable << "\"..."
+    SVCERR << "\rScanning \"" << printable << "\"..."
          << QString("                    ").left(20 - printable.length())
          << " [" << found << " audio file(s)]";
 
     QString extensions = AudioFileReaderFactory::getKnownExtensions();
     QStringList extlist = extensions.split(" ", QString::SkipEmptyParts);

 expandPlaylists(QStringList sources)
 {
     QStringList expanded;
     foreach (QString path, sources) {
         if (QFileInfo(path).suffix().toLower() == "m3u") {
+            SVDEBUG << "Expanding m3u playlist file \"" << path << "\"" << endl;
             ProgressPrinter retrievalProgress("Opening playlist file...");
             FileSource source(path, &retrievalProgress);
             if (!source.isAvailable()) {
                 // Don't fail or throw an exception here, just keep
                 // the file in the list -- it will be tested again

             if (reader.isOK()) {
                 vector<QString> files = reader.load();
                 for (int i = 0; i < (int)files.size(); ++i) {
                     expanded.push_back(files[i]);
                 }
+                SVDEBUG << "Done, m3u playlist references "
+                        << files.size() << " file(s)" << endl;
             }
         } else {
             // not a playlist
             expanded.push_back(path);
         }

 readSegmentBoundaries(QString url, 
                       Vamp::HostExt::PluginSummarisingAdapter::SegmentBoundaries &boundaries)
 {
     FileSource source(url);
     if (!source.isAvailable()) {
-        cerr << "File or URL \"" << url << "\" could not be retrieved" << endl;
+        SVCERR << "File or URL \"" << url << "\" could not be retrieved" << endl;
         return false;
     }
     source.waitForData();
 
     QString filename = source.getLocalFilename();
     QFile file(filename);
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
-        cerr << "File \"" << filename << "\" could not be read" << endl;
+        SVCERR << "File \"" << filename << "\" could not be read" << endl;
         return false;
     }
 
     QTextStream in(&file);
     int lineNo = 0;

         }
         if (!bits.empty()) {
             importantBit = bits[0];
         }
         if (importantBit == QString()) {
-            cerr << "WARNING: Skipping line " << lineNo << " (no content found)"
+            SVCERR << "WARNING: Skipping line " << lineNo << " (no content found)"
                  << endl;
             continue;
         }
         bool good = false;
         boundaries.insert(Vamp::RealTime::fromSeconds
                           (importantBit.toDouble(&good)));
         if (!good) {
-            cerr << "Unparseable or non-numeric segment boundary at line "
+            SVCERR << "Unparseable or non-numeric segment boundary at line "
                  << lineNo << endl;
             return false;
         }
     }
 

     set<string> requestedSummaryTypes;
     bool force = false;
     bool multiplex = false;
     bool recursive = false;
     bool normalise = false;
+    bool quiet = false;
     bool list = false;
     bool listWriters = false;
     bool listFormats = false;
     bool summaryOnly = false;
     QString skeletonFor = "";

             normalise = true;
             continue;
         } else if (arg == "-f" || arg == "--force") {
             force = true;
             continue;
+        } else if (arg == "-q" || arg == "--quiet") {
+            quiet = true;
+            continue;
         } else if (arg == "--list-writers") {
             listWriters = true;
             continue;
         } else if (arg == "--list-formats") {
             listFormats = true;

         } else {
             otherArgs.push_back(args[i]);
         }
     }
 
+    if (quiet) {
+        SVDebug::silence();
+        SVCerr::silence();
+    }
+    
     if (list) {
         if (!requestedWriterTags.empty() || skeletonFor != "") {
             cerr << helpStr << endl;
             exit(2);
         }

         }
     }
 
     QSettings settings;
 
-#ifdef HAVE_FFTW3
-    settings.beginGroup("FFTWisdom");
-    QString wisdom = settings.value("wisdom").toString();
-    if (wisdom != "") {
-        fftw_import_wisdom_from_string(wisdom.toLocal8Bit().data());
-    }
-    settings.endGroup();
-#endif
-
     settings.beginGroup("RDF");
     if (!settings.contains("rdf-indices")) {
         QStringList list;
         list << "http://www.vamp-plugins.org/rdf/plugins/index.txt";
         settings.setValue("rdf-indices", list);
     }
     settings.endGroup();
 
-    FeatureExtractionManager manager;
+    FeatureExtractionManager manager(!quiet);
 
     manager.setNormalise(normalise);
 
     if (!requestedSummaryTypes.empty()) {
         if (!manager.setSummaryTypes(requestedSummaryTypes,

         exit(2);
     }    
 
     for (set<string>::const_iterator i = requestedTransformListFiles.begin();
          i != requestedTransformListFiles.end(); ++i) {
+        SVDEBUG << "Reading transform list file \"" << *i << "\"" << endl;
         PlaylistFileReader reader(i->c_str());
         if (reader.isOK()) {
             vector<QString> files = reader.load();
             for (int j = 0; j < (int)files.size(); ++j) {
                 requestedTransformFiles.insert(files[j].toStdString());
             }
         } else {
-            cerr << myname << ": failed to read template list file \"" << *i << "\"" << endl;
+            SVCERR << myname << ": failed to read transform list file \"" << *i << "\"" << endl;
             exit(2);
         }
     }
 
     QStringList sources;

         sources = otherArgs;
     } else {
         for (QStringList::const_iterator i = otherArgs.begin();
              i != otherArgs.end(); ++i) {
             if (QDir(*i).exists()) {
-                cerr << "Directory found and recursive flag set, scanning for audio files..." << endl;
+                SVCERR << "Directory found and recursive flag set, scanning for audio files..." << endl;
                 int found = 0;
                 findSourcesRecursive(*i, sources, found);
-                cerr << "\rDone, found " << found << " supported audio file(s)                    " << endl;
+                SVCERR << "\rDone, found " << found << " supported audio file(s)                    " << endl;
             } else {
                 sources.push_back(*i);
             }
         }
     }

          i != sources.end(); ++i) {
         try {
             manager.addSource(*i, multiplex);
         } catch (const std::exception &e) {
             badSources.insert(*i);
-            cerr << "ERROR: Failed to process file \"" << i->toStdString()
+            SVCERR << "ERROR: Failed to process file \"" << i->toStdString()
                  << "\": " << e.what() << endl;
             if (force) {
                 // print a note only if we have more files to process
                 QStringList::const_iterator j = i;
                 if (++j != sources.end()) {
-                    cerr << "NOTE: \"--force\" option was provided, continuing (more errors may occur)" << endl;
+                    SVCERR << "NOTE: \"--force\" option was provided, continuing (more errors may occur)" << endl;
                 }
             } else {
-                cerr << "NOTE: If you want to continue with processing any further files after an" << endl
+                SVCERR << "NOTE: If you want to continue with processing any further files after an" << endl
                      << "error like this, use the --force option" << endl;
                 good = false;
                 break;
             }
         }

         for (set<string>::const_iterator i = requestedTransformFiles.begin();
              i != requestedTransformFiles.end(); ++i) {
             if (manager.addFeatureExtractorFromFile(i->c_str(), writers)) {
                 haveFeatureExtractor = true;
             } else {
-                cerr << "ERROR: Failed to add feature extractor from transform file \"" << *i << "\"" << endl;
+                SVCERR << "ERROR: Failed to add feature extractor from transform file \"" << *i << "\"" << endl;
                 good = false;
             }
         }
 
         for (set<string>::const_iterator i = requestedDefaultTransforms.begin();
              i != requestedDefaultTransforms.end(); ++i) {
             if (manager.addDefaultFeatureExtractor(i->c_str(), writers)) {
                 haveFeatureExtractor = true;
             } else {
-                cerr << "ERROR: Failed to add default feature extractor for transform \"" << *i << "\"" << endl;
+                SVCERR << "ERROR: Failed to add default feature extractor for transform \"" << *i << "\"" << endl;
                 good = false;
             }
         }
 
         if (!haveFeatureExtractor) {
-            cerr << myname << ": no feature extractors added" << endl;
+            SVCERR << myname << ": no feature extractors added" << endl;
             good = false;
         }
     }
 
     if (good) {

                 for (int i = 0; i < (int)writers.size(); ++i) {
                     writers[i]->setNofM(1, 1);
                 }
                 manager.extractFeaturesMultiplexed(goodSources);
             } catch (const std::exception &e) {
-                cerr << "ERROR: Feature extraction failed: "
+                SVCERR << "ERROR: Feature extraction failed: "
                      << e.what() << endl;
             }
         } else {
             int n = 0;
             for (QStringList::const_iterator i = goodSources.begin();
                  i != goodSources.end(); ++i) {
-                std::cerr << "Extracting features for: \"" << i->toStdString()
-                          << "\"" << std::endl;
+                SVCERR << "Extracting features for: \"" << *i << "\"" << endl;
                 ++n;
                 try {
                     for (int j = 0; j < (int)writers.size(); ++j) {
                         writers[j]->setNofM(n, goodSources.size());
                     }
                     manager.extractFeatures(*i);
                 } catch (const std::exception &e) {
-                    cerr << "ERROR: Feature extraction failed for \""
-                         << i->toStdString() << "\": " << e.what() << endl;
+                    SVCERR << "ERROR: Feature extraction failed for \""
+                           << i->toStdString() << "\": " << e.what() << endl;
                     if (force) {
                         // print a note only if we have more files to process
                         QStringList::const_iterator j = i;
                         if (++j != sources.end()) {
-                            cerr << "NOTE: \"--force\" option was provided, continuing (more errors may occur)" << endl;
+                            SVCERR << "NOTE: \"--force\" option was provided, continuing (more errors may occur)" << endl;
                         }
                     } else {
-                        cerr << "NOTE: If you want to continue with processing any further files after an" << endl
-                             << "error like this, use the --force option" << endl;
+                        SVCERR << "NOTE: If you want to continue with processing any further files after an" << endl
+                               << "error like this, use the --force option" << endl;
                         good = false;
                         break;
                     }
                 }
             }
         }
     }
     
     for (int i = 0; i < (int)writers.size(); ++i) delete writers[i];
-
-#ifdef HAVE_FFTW3
-    settings.beginGroup("FFTWisdom");
-    char *cwisdom = fftw_export_wisdom_to_string();
-    if (cwisdom) {
-        settings.setValue("wisdom", cwisdom);
-        fftw_free(cwisdom);
-    }
-    settings.endGroup();
-#endif
 
     TempDirectory::getInstance()->cleanup();
     
     if (good) return 0;
     else return 1;