Reading SleepyHead Binary Files

PHP Code:
   header.setByteOrder(QDataStream::LittleEndian); // set the byte-order to little endian <-- important!

    header << (quint32)magic;      // New Magic Number
    header << (quint16)events_version; // File Version
    header << (quint16)filetype_data;  // File type 1 == Event
    header << (quint32)s_machine->id();// Machine Type 
    header << (quint32)s_session;      // This session's ID
    header << s_first; // int64 - starttime in miliseconds since 1970-01-01 00:00
    header << s_last; // int64 - endtime

    if (p_profile->session->compressSessionData()) { // check if compression is enabled in the preferences
        compress = compress_method;
    }

    header << (quint16)compress; // if you have NOT checked in the preferences to compress session data this does not concern you - otherwise you have to decompress first: ONLY the data-part is compressed - NOT the header!

    header << (quint16)s_machine->type();// Machine Type --> I believe 2 is for oxymeters

    header << datasize; // the size of the actual data AFTER the header in bytes.
    header << chk; // checksum - should 0 - if it is not it is the checksum for the compression

 // header is written to file
 
 // the data part starts from here on:
 
    out.setByteOrder(QDataStream::LittleEndian); // little endian again!

    out << (qint16)eventlist.size(); // Number of event categories

    qint16 ev_size; // it just defines the variable so we can use it frome here on

    for (i = eventlist.begin(); i != i_end; i++) { // loop through the categories (as in oxydata, CPAP-data ...)
 
        out << i.key(); // ChannelID ... as in "pulse rate, SPO2, SPO2-drops, Pulserate-changes, ...." --> it should be uint32 --> look in "machine_common.h"
 //if the events_version is below 8 this is stored as string / text
 
        ev_size=i.value().size(); // store the number of data-lists in the current category in the variable 
        out << (qint16)ev_size; // write that to file as int16


        for (int j = 0; j < ev_size; j++) { // loop through the data-lists in that category
            EventList &e = *i.value()[j]; // declaring the variable and assigning it the current data-list
            out << e.first(); // int64 - starttime in miliseconds since 1970-01-01 00:00
            out << e.last(); // int64 - endtime
            out << (qint32)e.count(); // int32 - number of records / data-points
            out << (qint8)e.type(); // int8 - if it's 0 it's a waveform / 1 for event-format
            out << e.rate(); // float - time between data-points of the raw-data on import (should be in milliseconds or maybe seconds)
            out << e.gain(); // float - multiplier to convert the stored data back to its original value
            out << e.offset(); // float - what it says^^
            out << e.Min(); // float
            out << e.Max(); // float
            out << e.dimension(); // string - the dimension in "plain text" ... it should be 0x00 terminated - meaning this are "chars" and the string ends with 0x00
            out << e.hasSecondField(); // if it has a 2nd field (don't know for sure but I believe Oxy-data has NOT)

            if (e.hasSecondField()) {
                out << e.min2();
                out << e.max2();
            }
        }
    }

 // the "meta-information" for each channel is now written to file
 
 // now the actual data-points are written to file:
    for (i = eventlist.begin(); i != i_end; i++) { // once again loop through the categories
        ev_size=i.value().size(); // number of data-lists within the current category - see above

        for (int j = 0; j < ev_size; j++) { // loop through the data-lists 
 //here the data gets stored as 16bit values ... you have to tinker around if its int16 or uint16 - you also have to find out the byte-coding - I would first assume big-endian - but maybe it really is little endian.

            if (e.hasSecondField()) {
            //if it has a second field that data is stored as well - read above on the format - it's the very same.
            }

            // Store the time delta fields for non-waveform EventLists
            if (e.type() != EVL_Waveform) {
            // if the type is waveform this does NOT apply as all waveform data is written value by value to the file.
            // but if it is event-format it is stored in a time-delta-format (to save space)
            // this means: that if there are data-points in a row with the same value just 1 data-value is stored and the time how long that was.
            // looks like the milliseconds between them 
 
            // format is: uint32 - the byte-order you have to find out.
            }
        }
    }