Merge branch 'master' into Database

oscar/SleepLib/common.cpp

@@ -181,8 +181,12 @@ QString getBranchVersion()
     if (GIT_BRANCH != "master") {
         version += GIT_BRANCH+"-";
     }
-    version += GIT_REVISION +" ";
-    version += getGraphicsEngine()+"]";
+    version += GIT_REVISION;
+#ifndef UNITTEST_MODE
+    // There is no graphics engine on the console.
+    version += QString(" ") + getGraphicsEngine();
+#endif
+    version += "]";
 
     return version;
 }

oscar/SleepLib/loader_plugins/prs1_loader.h

@@ -62,35 +62,80 @@ class PRS1DataChunk
     friend class PRS1DataGroup;
 public:
     PRS1DataChunk() {
-        timestamp = 0;
-        ext = 255;
-        sessionid = 0;
+        fileVersion = 0;
+        blockSize = 0;
         htype = 0;
         family = 0;
         familyVersion = 0;
+        ext = 255;
+        sessionid = 0;
+        timestamp = 0;
+        
         duration = 0;
 
+        m_filepos = -1;
+        m_index = -1;
     }
+    PRS1DataChunk(class QFile & f);
     ~PRS1DataChunk() {
     }
     inline int size() const { return m_data.size(); }
 
+    QByteArray m_header;
     QByteArray m_data;
     QByteArray m_headerblock;
 
-    SessionID sessionid;
+    QString m_path;
+    qint64 m_filepos;  // file offset
+    int m_index;  // nth chunk in file
+    inline void SetIndex(int index) { m_index = index; }
 
+    // Common fields
     quint8 fileVersion;
-    quint8 ext;
+    quint16 blockSize;
     quint8 htype;
     quint8 family;
     quint8 familyVersion;
+    quint8 ext;
+    SessionID sessionid;
     quint32 timestamp;
 
-    quint16 duration;
-
+    // Waveform-specific fields
+    quint16 interval_count;
+    quint8 interval_seconds;
+    int duration;
     QList<PRS1Waveform> waveformInfo;
+    
+    // V3 normal/non-waveform fields
     QMap<unsigned char, short> hblock;
+    
+    // Trailing common fields
+    quint8 storedChecksum;  // header checksum stored in file, last byte of m_header
+    quint8 calcChecksum;    // header checksum as calculated when parsing
+    quint32 storedCrc;      // header + data CRC stored in file, last 2-4 bytes of chunk
+    quint32 calcCrc;        // header + data CRC as calculated when parsing
+
+    //! \brief Parse and return the next chunk from a PRS1 file
+    static PRS1DataChunk* ParseNext(class QFile & f);
+
+    //! \brief Read and parse the next chunk header from a PRS1 file
+    bool ReadHeader(class QFile & f);
+
+    //! \brief Read the chunk's data from a PRS1 file and calculate its CRC, must be called after ReadHeader
+    bool ReadData(class QFile & f);
+    
+protected:
+    //! \brief Read and parse the non-waveform header data from a V2 PRS1 file
+    bool ReadNormalHeaderV2(class QFile & f);
+
+    //! \brief Read and parse the non-waveform header data from a V3 PRS1 file
+    bool ReadNormalHeaderV3(class QFile & f);
+
+    //! \brief Read and parse the waveform-specific header data from a PRS1 file
+    bool ReadWaveformHeader(class QFile & f);
+
+    //! \brief Extract the stored CRC from the end of the data of a PRS1 chunk
+    bool ExtractStoredCrc(int size);
 };
 
 class PRS1Loader;
@@ -138,6 +183,9 @@ public:
     //! \brief Figures out which Event Parser to call, based on machine family/version and calls it.
     bool ParseEvents();
 
+    //! \brief Coalesce contiguous .005 or .006 waveform chunks from the file into larger chunks for import.
+    QList<PRS1DataChunk *> CoalesceWaveformChunks(QList<PRS1DataChunk *> & allchunks);
+
     //! \brief Takes the parsed list of Flow/MaskPressure waveform chunks and adds them to the database
     bool ParseWaveforms();
 

oscar/daily.cpp

@@ -1558,10 +1558,11 @@ void Daily::Load(QDate date)
     const int maxcolors=sizeof(cols)/sizeof(QColor);
     QList<Session *>::iterator i;
 
+    sessionbar->clear();    // clear sessionbar as some days don't have sessions
+
     if (cpap) {
         int c=0;
 
-        sessionbar->clear();
         for (i=day->begin();i!=day->end();++i) {
             Session * s=*i;
             if ((*s).type() == MT_CPAP)

oscar/mainwindow.cpp

@@ -1345,37 +1345,25 @@ void MainWindow::on_actionCheck_for_Updates_triggered()
 bool toolbox_visible = false;
 void MainWindow::on_action_Screenshot_triggered()
 {
-    daily->hideSpaceHogs();
+    if (daily)
+        daily->hideSpaceHogs();
     toolbox_visible = ui->toolBox->isVisible();
     ui->toolBox->hide();
     QTimer::singleShot(250, this, SLOT(DelayedScreenshot()));
 }
+
 void MainWindow::DelayedScreenshot()
 {
     // Make sure to scale for high resolution displays (like Retina)
    // qreal pr = devicePixelRatio();
 
-
-    QScreen * screen = QApplication::primaryScreen();
-
-
-    int titleBarHeight = -QApplication::style()->pixelMetric(QStyle::PM_TitleBarHeight);
-#ifdef Q_OS_WIN
-    titleBarHeight += 6;
-#endif
-
-    QPixmap pixmap = screen->grabWindow(winId(),0,titleBarHeight);
-
-/*#if defined(Q_OS_WIN) || defined(Q_OS_LINUX) || defined(Q_OS_HAIKU)
-     // grab the whole screen
-    grab()
-     QPixmap desktop = QPixmap::grabWindow(QApplication::desktop()->winId());
-
-     QPixmap pixmap = desktop.copy(x() * pr, y() * pr, (width()+6) * pr, (height()+22) * pr);
-
-#elif defined(Q_OS_MAC)
-    QPixmap pixmap = QPixmap::grabWindow(this->winId(), x(), y(), width() / pr, (height() / pr) + 10);
-#endif */
+    auto screenshotRect = geometry();
+    auto titleBarHeight = QApplication::style()->pixelMetric(QStyle::PM_TitleBarHeight);
+    auto pixmap = QApplication::primaryScreen()->grabWindow(QDesktopWidget().winId(),
+                                                            screenshotRect.left(),
+                                                            screenshotRect.top() - titleBarHeight,
+                                                            screenshotRect.width(),
+                                                            screenshotRect.height() + titleBarHeight);
 
     QString a = p_pref->Get("{home}/Screenshots");
     QDir dir(a);
@@ -1393,7 +1381,8 @@ void MainWindow::DelayedScreenshot()
     } else {
         Notify(tr("Screenshot saved to file \"%1\"").arg(QDir::toNativeSeparators(a)));
     }
-    daily->showSpaceHogs();
+    if (daily)
+        daily->showSpaceHogs();
     ui->toolBox->setVisible(toolbox_visible);
 
 }

oscar/tests/prs1tests.cpp

@@ -13,10 +13,13 @@
 
 static PRS1Loader* s_loader = nullptr;
 static void iterateTestCards(const QString & root, void (*action)(const QString &));
+static QString prs1OutputPath(const QString & inpath, const QString & serial, const QString & basename, const QString & suffix);
 static QString prs1OutputPath(const QString & inpath, const QString & serial, int session, const QString & suffix);
 
 void PRS1Tests::initTestCase(void)
 {
+    initializeStrings();
+    qDebug() << STR_TR_OSCAR + " " + getBranchVersion();
     QString profile_path = TESTDATA_PATH "profile/";
     Profiles::Create("test", &profile_path);
 
@@ -74,9 +77,166 @@ void PRS1Tests::testSessionsToYaml()
 }
 
 
+// ====================================================================================================
+
+static QString ts(qint64 msecs)
+{
+    return QDateTime::fromMSecsSinceEpoch(msecs).toString(Qt::ISODate);
+}
+
+static QString byteList(QByteArray data)
+{
+    QStringList l;
+    for (int i = 0; i < data.size(); i++) {
+        l.push_back(QString( "%1" ).arg((int) data[i] & 0xFF, 2, 16, QChar('0') ).toUpper());
+    }
+    QString s = l.join("");
+    return s;
+}
+
+void ChunkToYaml(QFile & file, PRS1DataChunk* chunk)
+{
+    QTextStream out(&file);
+
+    // chunk header
+    out << "chunk:" << endl;
+    out << "  at: " << hex << chunk->m_filepos << endl;
+    out << "  version: " << dec << chunk->fileVersion << endl;
+    out << "  size: " << chunk->blockSize << endl;
+    out << "  htype: " << chunk->htype << endl;
+    out << "  family: " << chunk->family << endl;
+    out << "  familyVersion: " << chunk->familyVersion << endl;
+    out << "  ext: " << chunk->ext << endl;
+    out << "  session: " << chunk->sessionid << endl;
+    out << "  start: " << ts(chunk->timestamp * 1000L) << endl;
+
+    // hblock for V3 non-waveform chunks
+    if (chunk->fileVersion == 3 && chunk->htype == 0) {
+        out << "  hblock:" << endl;
+        QMapIterator<unsigned char, short> i(chunk->hblock);
+        while (i.hasNext()) {
+            i.next();
+            out << "    " << (int) i.key() << ": " << i.value() << endl;
+        }
+    }
+
+    // waveform chunks
+    if (chunk->htype == 1) {
+        out << "  intervals: " << chunk->interval_count << endl;
+        out << "  intervalSeconds: " << (int) chunk->interval_seconds << endl;
+        out << "  interleave:" << endl;
+        for (int i=0; i < chunk->waveformInfo.size(); i++) {
+            const PRS1Waveform & w = chunk->waveformInfo.at(i);
+            out << "    " << i << ": " << w.interleave << endl;
+        }
+        out << "  end: " << ts((chunk->timestamp + chunk->duration) * 1000L) << endl;
+    }
+    
+    // header checksum
+    out << "  checksum: " << hex << chunk->storedChecksum << endl;
+    if (chunk->storedChecksum != chunk->calcChecksum) {
+        out << "  calcChecksum: " << hex << chunk->calcChecksum << endl;
+    }
+    
+    // data
+    out << "  data: " << byteList(chunk->m_data) << endl;
+    
+    // data CRC
+    out << "  crc: " << hex << chunk->storedCrc << endl;
+    if (chunk->storedCrc != chunk->calcCrc) {
+        out << "  calcCrc: " << hex << chunk->calcCrc << endl;
+    }
+    out << endl;
+}
+
+void parseAndEmitChunkYaml(const QString & path)
+{
+    qDebug() << path;
+
+    QStringList paths;
+    QString propertyfile;
+    int sessionid_base;
+    sessionid_base = s_loader->FindSessionDirsAndProperties(path, paths, propertyfile);
+
+    Machine *m = s_loader->CreateMachineFromProperties(propertyfile);
+    Q_ASSERT(m != nullptr);
+
+    // This mirrors the functional bits of PRS1Loader::ScanFiles.
+    
+    QDir dir;
+    dir.setFilter(QDir::NoDotAndDotDot | QDir::Dirs | QDir::Files | QDir::Hidden | QDir::NoSymLinks);
+    dir.setSorting(QDir::Name);
+
+    int size = paths.size();
+
+    // for each p0/p1/p2/etc... folder
+    for (int p=0; p < size; ++p) {
+        dir.setPath(paths.at(p));
+        if (!dir.exists() || !dir.isReadable()) {
+            qWarning() << dir.canonicalPath() << "can't read directory";
+            continue;
+        }
+        QFileInfoList flist = dir.entryInfoList();
+
+        // Scan for individual .00X files
+        for (int i = 0; i < flist.size(); i++) {
+            QFileInfo fi = flist.at(i);
+            QString inpath = fi.canonicalFilePath();
+            bool ok;
+
+            QString ext_s = fi.fileName().section(".", -1);
+            ext_s.toInt(&ok);
+            if (!ok) {
+                // not a numerical extension
+                qWarning() << inpath << "unexpected filename";
+                continue;
+            }
+
+            QString session_s = fi.fileName().section(".", 0, -2);
+            session_s.toInt(&ok, sessionid_base);
+            if (!ok) {
+                // not a numerical session ID
+                qWarning() << inpath << "unexpected filename";
+                continue;
+            }
+            
+            // Create the YAML file.
+            QString outpath = prs1OutputPath(path, m->serial(), fi.fileName(), "-chunks.yml");
+            QFile file(outpath);
+            if (!file.open(QFile::WriteOnly | QFile::Truncate)) {
+                qDebug() << outpath;
+                Q_ASSERT(false);
+            }
+
+            // Parse the chunks in the file.
+            QList<PRS1DataChunk *> chunks = s_loader->ParseFile(inpath);
+            for (int i=0; i < chunks.size(); i++) {
+                // Emit the YAML.
+                PRS1DataChunk * chunk = chunks.at(i);
+                ChunkToYaml(file, chunk);
+                delete chunk;
+            }
+            
+            file.close();
+        }
+    }
+}
+
+void PRS1Tests::testChunksToYaml()
+{
+    iterateTestCards(TESTDATA_PATH "prs1/input/", parseAndEmitChunkYaml);
+}
+
+
 // ====================================================================================================
 
 QString prs1OutputPath(const QString & inpath, const QString & serial, int session, const QString & suffix)
+{
+    QString basename = QString("%1").arg(session, 8, 10, QChar('0'));
+    return prs1OutputPath(inpath, serial, basename, suffix);
+}
+
+QString prs1OutputPath(const QString & inpath, const QString & serial, const QString & basename, const QString & suffix)
 {
     // Output to prs1/output/FOLDER/SERIAL-000000(-session.yml, etc.)
     QDir path(inpath);
@@ -90,7 +250,7 @@ QString prs1OutputPath(const QString & inpath, const QString & serial, int sessi
     
     QString filename = QString("%1-%2%3")
                         .arg(serial)
-                        .arg(session, 6, 10, QChar('0'))
+                        .arg(basename)
                         .arg(suffix);
     return outdir.path() + QDir::separator() + filename;
 }

oscar/tests/prs1tests.h

@@ -18,6 +18,7 @@ class PRS1Tests : public QObject
  
 private slots:
     void initTestCase();
+    void testChunksToYaml();
     void testSessionsToYaml();
     // void test2();
     void cleanupTestCase();

oscar/tests/sessiontests.cpp

@@ -162,10 +162,6 @@ void SessionToYaml(QString filepath, Session* session)
     }
     QTextStream out(&file);
 
-    // TODO: We sometimes see invalid session IDs. Either memory is getting trampled or the file
-    // header has the wrong ID (or isn't getting parsed right). Track this down once we can test parsing.
-    if (session->session() > 2000) qDebug() << "memory trampled? session ID" << session->session();
-    
     out << "session:" << endl;
     out << "  id: " << session->session() << endl;
     out << "  start: " << ts(session->first()) << endl;