FitStreamReaderPrivate Class Reference

Provides private implementation for FitStreamReader. More...

Collaboration diagram for FitStreamReaderPrivate:

Public Types
typedef qsizetype	size_t
	Size type for size-related operations.

Public Member Functions
	FitStreamReaderPrivate (FitStreamReader *const q)
	Constructs a FitStreamReaderPrivate object, with public implementation q. More...
virtual	~FitStreamReaderPrivate ()
	Destroys the FitStreamReaderPrivate object.

Public Attributes
QByteArray	data
	FIT File data (alternative to device).
size_t	dataOffset
	Current position within data.
QIODevice *	device
	FIT File IO stream (alternative to data and dataOffset).

Protected Member Functions
template<class T >
size_t	bytesAvailable () const
	Returns the number of bytes currently available for reading. More...
template<class T >
bool	parseFileHeader ()
	Reads and parses the FIT stream's file header. More...
template<class T >
bool	parseDefinitionMessage ()
	Reads and parses a FIT Definition Message. More...
template<class T >
AbstractDataMessage *	parseDataMessage ()
	Reads and parses a FIT Data Message. More...
template<class T >
quint8	peekByte (const int pos=0) const
	Peeks the next pos'th byte in the FIT stream. More...
template<class T >
QByteArray	readBytes (const size_t size)
	Reads the next size bytes from the FIT stream. More...
template<class T >
QByteArray	readFileHeader ()
	Reads all bytes of the FIT stream file header. More...
template<class T >
AbstractDataMessage *	readNextDataMessage ()
	Reads up to, and including, the next FIT Data Message. More...
template<>
FitStreamReaderPrivate::size_t	bytesAvailable () const
	Specialisation for reading from QByteArray objects. More...
template<>
FitStreamReaderPrivate::size_t	bytesAvailable () const
	Specialisation for reading from QIODevice streams. More...
template<>
quint8	peekByte (const int pos) const
	Specialisation for reading from QByteArray objects. More...
template<>
quint8	peekByte (const int pos) const
	Specialisation for reading from QIODevice streams. More...
template<>
QByteArray	readBytes (const size_t size)
	Specialisation for reading from QIODevice streams. More...
template<>
QByteArray	readBytes (const size_t size)
	Specialisation for reading from QIODevice streams. More...

Static Protected Member Functions
static quint16	fitChecksum (const QByteArray &data)
	Calculates a checksum, as per the algorithm used by FIT file headers. More...
static bool	isDefinitionMessage (const quint8 recordHeader)
	Returns true if recordHeader indicates a Definition Message, otherwise false. More...

Protected Attributes
FitStreamReader *const	q_ptr
	Internal q-pointer.

Private Attributes
QVersionNumber	protocolVersion
	Protocol version read from the parsed FIT file header.
QVersionNumber	profileVersion
	Protocol version read from the parsed FIT file header.
quint32	expectedDataSize
	Total size, in bytes, expected to comprise the FIT file.
QHash< int, DataDefinition >	dataDefinitions
	Local message types to current data definitions.
QHash< int, int >	recordSizes
	Local message types to current record sizes.

Detailed Description

Provides private implementation for FitStreamReader.

Definition at line 40 of file fitstreamreader_p.h.

Constructor & Destructor Documentation

FitStreamReaderPrivate()

FitStreamReaderPrivate::FitStreamReaderPrivate ( FitStreamReader *const  q )

explicit

Constructs a FitStreamReaderPrivate object, with public implementation q.

Parameters

q	Pointer to public implementation.

Definition at line 267 of file fitstreamreader.cpp.

    : dataOffset(0), device(nullptr), q_ptr(q)
{
 
}

Member Function Documentation

bytesAvailable() [1/3]

template<>

FitStreamReaderPrivate::size_t FitStreamReaderPrivate::bytesAvailable ( ) const

protected

Specialisation for reading from QByteArray objects.

Returns

the number of bytes available for reading.

Definition at line 294 of file fitstreamreader.cpp.

{
    Q_ASSERT(device == nullptr);
    return data.size() - dataOffset;
}

References data, dataOffset, and device.

bytesAvailable() [2/3]

template<>

FitStreamReaderPrivate::size_t FitStreamReaderPrivate::bytesAvailable ( ) const

protected

Specialisation for reading from QIODevice streams.

Returns

the number of bytes available for reading.

Definition at line 305 of file fitstreamreader.cpp.

{
    Q_ASSERT(device != nullptr);
    return device->bytesAvailable();
}

References device.

bytesAvailable() [3/3]

template<class T >

FitStreamReaderPrivate::bytesAvailable ( ) const

protected

Returns the number of bytes currently available for reading.

Returns

the number of bytes available for reading.

fitChecksum()

quint16 FitStreamReaderPrivate::fitChecksum ( const QByteArray &  data )

inlinestaticprotected

Calculates a checksum, as per the algorithm used by FIT file headers.

Todo:

Move this somewhere appropriate; its not specific to FitStreamReader, but rather would be useful eventually for a FitStreamWriter class too. I guess its safe to keep in a private class for now, so it can then be moved without affecting the library's binary interface.

Parameters

data	FIT file header to calculate the checksum for.

Returns

16-bit checksum for data.

Definition at line 678 of file fitstreamreader.cpp.

{
    quint16 checksum=0;
    for (const auto &byte: data) {
        static const quint16 crcTable[16] = {
            0x0000, 0xCC01, 0xD801, 0x1400, 0xF001, 0x3C00, 0x2800, 0xE401,
            0xA001, 0x6C00, 0x7800, 0xB401, 0x5000, 0x9C01, 0x8801, 0x4400
        };
        for (int byteShift=0; byteShift<=4; byteShift+=4) {
            const quint16 tmp = crcTable[checksum & 0xF];
            checksum = (checksum >> 4) & 0x0FFF;
            checksum = checksum ^ tmp ^ crcTable[(byte >> byteShift) & 0xF];
        }
    }
    return checksum;
}

References data.

Referenced by parseFileHeader().

Here is the caller graph for this function:

isDefinitionMessage()

bool FitStreamReaderPrivate::isDefinitionMessage ( const quint8  recordHeader )

inlinestaticprotected

Returns true if recordHeader indicates a Definition Message, otherwise false.

Parameters

recordHeader

A FIT Data Record header byte.

Returns

true if recordHeader indicates a Definition Message, otherwise false.

Definition at line 702 of file fitstreamreader.cpp.

{
    // For definition messages, bit 7 must be off (bit 7 on would indicate a Compressed Timestamp
    // Data Message, which cannot be a Definition Message), and bit 6 must be on (otherwise this
    // woud be a Normal Data Message, not a Definition Message).
    return ((recordHeader >> 6) == 1); // Match bit 7 on and 6 off; ie 01xxxxxx.
}

Referenced by parseDataMessage(), parseDefinitionMessage(), and readNextDataMessage().

Here is the caller graph for this function:

parseDataMessage()

template<class T >

AbstractDataMessage * FitStreamReaderPrivate::parseDataMessage

protected

Reads and parses a FIT Data Message.

Note, this function assumes that the next item in the FIT stream is indeed a Data Message (the caller should have already determined this). Though it is perfectly acceptable that the message may not be completely available yet (in which case false will be returned).

This fuction will, as part of decoding the message, look-up the Data Message's definition, which must have been stored previously by one or more Definition Messages being processed earlier. If no matching definition is found, false will be returned.

Returns

true if the Data Message was successfully read and parsed, false otherwise.

Todo:

Process timeOffset.

Todo:

Set error code.

Definition at line 493 of file fitstreamreader.cpp.

{
    Q_ASSERT(bytesAvailable<T>());
    qDebug() << "parsing data message";
    const quint8 recordHeader = peekByte<T>();
    qDebug() << __func__ << "recordHeader" << recordHeader;
    Q_ASSERT_X(!isDefinitionMessage(recordHeader), "parseDataMessage",
               "FIT record header does not indiciate a data message");
 
    // Parse the record header.
    quint8 localMessageType;
    if (recordHeader & (1 << 7)) { // Compressed Timestamp Header.
        qDebug() << __func__ << "Compressed Timestamp Header";
        localMessageType = ((recordHeader >> 4) & 0x7);
        const quint8 timeOffset = (recordHeader & 0xF);
        qDebug() << "time offset" << timeOffset;
        /// \todo Process timeOffset.
    } else { // Normal (Data Message) Header
        qDebug() << __func__ << "Normal (Data Message) Header";
        qDebug() << __func__ << "reserved5" << (recordHeader & (1 << 5));
        qDebug() << __func__ << "reserved4" << (recordHeader & (1 << 4));
        localMessageType = (recordHeader & 0xF); // Least significant 4 bits.
    }
    qDebug() << __func__ << "local message type" << localMessageType;
 
    // Lookup the record's field definitions.
    if (!dataDefinitions.contains(localMessageType)) {
        qWarning() << "No definition for local message type" << localMessageType;
        /// \todo Set error code.
        return nullptr; // FIT data is corrupt; we cannot safely continue parsing.
    }
    const DataDefinition defn = dataDefinitions.value(localMessageType);
 
    // Parse record's Data Fields.
    qDebug() << __func__ << "record size" << defn.recordSize;
    if (defn.recordSize == 0) {
        qWarning() << "record size is zero"; // Not really sure what to do here.
        return nullptr;
    }
    const QByteArray record = readBytes<T>(defn.recordSize+1);
    if (record.isEmpty()) {
        return nullptr; // Not enough bytes.
    }
    qDebug() << "record" << record.mid(1);
    return AbstractDataMessage::fromData(&defn, record.mid(1));
}

References dataDefinitions, AbstractDataMessage::fromData(), isDefinitionMessage(), and DataDefinition::recordSize.

Here is the call graph for this function:

parseDefinitionMessage()

template<class T >

bool FitStreamReaderPrivate::parseDefinitionMessage

protected

Reads and parses a FIT Definition Message.

Note, this function assumes that the next item in the FIT stream is indeed a Definition Message (the caller should have already determined this). Though it is perfectly acceptable that the message may not be completely available yet (in which case false will be returned).

Returns

true if the Definition Message was successfully read and parsed, false otherwise.

Definition at line 388 of file fitstreamreader.cpp.

{
    // Parse the record header.
    qDebug() << "parsing definition message";
    Q_ASSERT(bytesAvailable<T>());
    const quint8 recordHeader = peekByte<T>();
    qDebug() << __func__ << "recordHeader" << recordHeader;
    Q_ASSERT_X(isDefinitionMessage(recordHeader), "parseDefinitionMessage",
               "FIT record header does not indiciate a definition message");
    const bool hasDevFields = (recordHeader & (1 << 5));
    qDebug() << __func__ << "has dev fields" << hasDevFields;
    qDebug() << __func__ << "reserved" << (recordHeader & (1 << 4));
    const quint8 localMessageType = (recordHeader & 0xF); // Least significant 4 bits.
    qDebug() << __func__ << "local message type" << localMessageType;
 
    // Read the completed definition record (if available).
    if (bytesAvailable<T>() < 6) {
        return false; // Not enough bytes.
    }
    const quint8 numberOfFields = peekByte<T>(5);
    qDebug() << __func__ << "number of fields" << numberOfFields;
    int numberOfDevFields = 0;
    if (hasDevFields) {
        const int offsetToNumberOfDevFields = 6 + (numberOfFields * 3);
        qDebug() << __func__ << "offset to number of dev fields" << offsetToNumberOfDevFields;
        if (bytesAvailable<T>() < offsetToNumberOfDevFields) {
            return false; // Not enough bytes.
        }
        numberOfDevFields = peekByte<T>(offsetToNumberOfDevFields);
    }
    const int recordSize = 6 + (numberOfFields * 3) + (hasDevFields ? 1 + (numberOfDevFields * 3) : 0);
    qDebug() << __func__ << "number of dev fields" << numberOfDevFields;
    qDebug() << __func__ << "record size" << recordSize;
    const QByteArray record = readBytes<T>(recordSize);
    if (record.isEmpty()) {
        return false; // Not enough bytes.
    }
 
    // Parse the rest of the definition record.
    DataDefinition defn;
    defn.recordSize = 0;
    defn.architecture = static_cast<Architecture>(record.at(2));
    qDebug() << __func__ << "architecture" << (int)defn.architecture;
    qDebug() << record.mid(3,2);
    defn.globalMessageNumber = static_cast<MesgNum>((defn.architecture == Architecture::BigEndian)
        ? qFromBigEndian<quint16>(record.mid(3,2))
        : qFromLittleEndian<quint16>(record.mid(3,2)));
    qDebug() << __func__ << "header" << (quint8)record.at(0);
    qDebug() << __func__ << "reserved" << (quint8)record.at(1);
    qDebug() << __func__ << "msgNum" << (int)defn.globalMessageNumber;
 
    // Parse the definition fields.
    for (int i=0; i < numberOfFields; ++i) {
        const int pos = 6 + (i * 3);
        FieldDefinition field;
        field.number = record.at(pos);
        field.size = record.at(pos+1);
        field.baseType = static_cast<FitBaseType>(record.at(pos+2));
        qDebug() << __func__ << "field" << i << "number" << field.number;
        qDebug() << __func__ << "field" << i << "size" << field.size;
        qDebug() << __func__ << "field" << i << "type" << static_cast<quint8>(field.baseType);
        defn.fieldDefinitions.append(field);
        defn.recordSize += field.size;
    }
    Q_ASSERT(defn.fieldDefinitions.size() == numberOfFields);
    qDebug() << __func__ << "defn record size" << defn.recordSize;
 
    // Parse the definition fields.
    Q_ASSERT(hasDevFields || (numberOfDevFields == 0));
    for (int i=0; i < numberOfDevFields; ++i) {
        const int pos = 6 + (numberOfFields * 3) + 1 + (i * 3);
        DeveloperFieldDefinition field;
        field.fieldNumber = record.at(pos);
        field.size = record.at(pos+1);
        field.devDataIndex = record.at(pos+2);
        qDebug() << __func__ << "dev field" << i << "number" << field.fieldNumber;
        qDebug() << __func__ << "dev field" << i << "size" << field.size;
        qDebug() << __func__ << "dev field" << i << "dataIndex" << field.devDataIndex;
        defn.developerFieldDefinitions.append(field);
        defn.recordSize += field.size;
    }
    Q_ASSERT(defn.developerFieldDefinitions.size() == numberOfDevFields);
    qDebug() << __func__ << "defn record size" << defn.recordSize;
    if (defn.recordSize == 0) {
        qWarning() << "defintion record size is zero";
    }
 
    // Record the definition data for future Data Messages.
    dataDefinitions.insert(localMessageType, defn);
    return true;
}

References DataDefinition::architecture, FieldDefinition::baseType, BigEndian, dataDefinitions, DeveloperFieldDefinition::devDataIndex, DataDefinition::developerFieldDefinitions, DataDefinition::fieldDefinitions, DeveloperFieldDefinition::fieldNumber, DataDefinition::globalMessageNumber, isDefinitionMessage(), FieldDefinition::number, DataDefinition::recordSize, DeveloperFieldDefinition::size, and FieldDefinition::size.

Here is the call graph for this function:

parseFileHeader()

template<class T >

bool FitStreamReaderPrivate::parseFileHeader

protected

Reads and parses the FIT stream's file header.

Todo:

Provide, and document, a way for the caller to distingish errors from simply not-enough- bytes-yet, when false it returned.

Returns

true if the header was successfully read and parsed, false otherwise.

Todo:

set not-enough-bytes; ie might need to wait for more bytes.

Todo:

set invalid header size error; ie FIT stream is corrupt / invalid.

Todo:

set invalid header data type (must be ".FIT").

Todo:

set error, and return false here?

Definition at line 319 of file fitstreamreader.cpp.

{
    Q_ASSERT(protocolVersion.isNull());
    Q_ASSERT(profileVersion.isNull());
 
    // Read the header bytes.
    const QByteArray header = readFileHeader<T>();
    qDebug() << "Header size" << header.size() << "bytes";
    if (header.isEmpty()) {
        /// \todo set not-enough-bytes; ie might need to wait for more bytes.
        qDebug() << "not enough bytes for header";
        return false;
    }
    if (header.size() < 12) {
        /// \todo set invalid header size error; ie FIT stream is corrupt / invalid.
        qDebug() << "invalid header size";
        return false;
    }
 
    {   // Protocol version is split into two parts: high 4 bits major, a low 4 bits minor.
        const quint8 version = header.at(1);
        protocolVersion = QVersionNumber(version >> 4, version & 0x0F);
        qDebug() << "Protocol version" << protocolVersion;
    }
 
    {   // Profile version is major*100 + minor (ie minor could not be more than 99).
        const quint16 version = qFromLittleEndian<quint16>(header.mid(2,2).data());
        profileVersion = QVersionNumber(version/100, version%100);
        qDebug() << "Profile version" << profileVersion;
    }
 
    expectedDataSize = qFromLittleEndian<quint32>(header.mid(4,4).data());
    qDebug() << "Data size" << expectedDataSize << "bytes";
 
    const QByteArray dataType = header.mid(8,4);
    qDebug() << "Data type" << dataType;
    if (dataType != QByteArray(".FIT")) {
        /// \todo set invalid header data type (must be ".FIT").
        return false;
    }
 
    // Check the header's checksum (only present in 14+ byte headers, and even then may be 0x0000).
    if (header.size() >= 14) {
        const quint16 expectedChecksum = qFromLittleEndian<quint16>(data.mid(12,2).data());
        if (expectedChecksum == 0x0000) {
            qDebug() << "FIT file has (optional) checksum 0x0000; ignoring.";
        } else {
            const quint16 calculatedChecksum = fitChecksum(header.mid(0,12));
            qDebug() << "Header checksum" << expectedChecksum << calculatedChecksum;
            if (calculatedChecksum != expectedChecksum) {
                qWarning() << "Checksum failure:" << calculatedChecksum << "!=" << expectedChecksum;
                /// \todo set error, and return false here?
            } else {
                qDebug() << "Checkums match";
            }
        }
    }
    return true;
}

References data, expectedDataSize, fitChecksum(), profileVersion, and protocolVersion.

Here is the call graph for this function:

peekByte() [1/3]

template<>

quint8 FitStreamReaderPrivate::peekByte ( const int  pos ) const

protected

Specialisation for reading from QByteArray objects.

Parameters

pos	The position (relative to the current stream position) to peek.

Returns

the next pos'th byte, or 0 if not enough bytes were available.

Definition at line 566 of file fitstreamreader.cpp.

{
    Q_ASSERT(device == nullptr);
    return (data.size() > (dataOffset + pos)) ? data.at(dataOffset+pos) : 0;
}

References data, dataOffset, and device.

peekByte() [2/3]

template<>

quint8 FitStreamReaderPrivate::peekByte ( const int  pos ) const

protected

Specialisation for reading from QIODevice streams.

Parameters

pos	The position (relative to the current stream position) to peek.

Returns

the next pos'th byte, or 0 if not enough bytes were available.

Definition at line 579 of file fitstreamreader.cpp.

{
    Q_ASSERT(device != nullptr);
    const QByteArray bytes = device->peek(1+pos);
    return (bytes.size() > pos) ? bytes.at(pos) : 0;
}

References device.

peekByte() [3/3]

template<class T >

FitStreamReaderPrivate::peekByte ( const int  pos = 0 ) const

protected

Peeks the next pos'th byte in the FIT stream.

If less than pos bytes are available, 0 will be returned. It is the caller's responsibility to first check that there are enough bytes availble (eg via bytesAvailable) before calling this, otherwise it would be impossible to distinguish between not-enough-bytes-available and reading a valid 0x00 byte.

Of course, we could provide a better error feedback mechanism, but as this is an internal private function, and all of our callers need to check for bytes first anyway, this is the more efficient pattern here.

Parameters

pos	The position (relative to the current stream position) to peek.

Returns

the next pos'th byte, or 0 if not enough bytes were available.

readBytes() [1/3]

template<>

QByteArray FitStreamReaderPrivate::readBytes ( const size_t  size )

protected

Specialisation for reading from QIODevice streams.

Parameters

size	The number of bytes to read.

Returns

the next size bytes, or an empty QDataArray if less than size bytes were available.

Definition at line 603 of file fitstreamreader.cpp.

{
    Q_ASSERT(device == nullptr);
    return ((data.size() - dataOffset) < size) ? QByteArray() : data.mid((dataOffset+=size)-size, size);
}

References data, dataOffset, and device.

readBytes() [2/3]

template<>

QByteArray FitStreamReaderPrivate::readBytes ( const size_t  size )

protected

Specialisation for reading from QIODevice streams.

Parameters

size	The number of bytes to read.

Returns

the next size bytes, or an empty QDataArray if less than size bytes were available.

Definition at line 616 of file fitstreamreader.cpp.

{
    Q_ASSERT(device != nullptr);
    return (device->bytesAvailable() < size) ? QByteArray() : device->read(size);
}

References device.

readBytes() [3/3]

template<class T >

FitStreamReaderPrivate::readBytes ( const size_t  size )

protected

Reads the next size bytes from the FIT stream.

Parameters

size	The number of bytes to read.

Returns

the next size bytes, or an empty QDataArray if less than size bytes were available.

readFileHeader()

template<class T >

QByteArray FitStreamReaderPrivate::readFileHeader

protected

Reads all bytes of the FIT stream file header.

This function will first peek the header length (if available), and then read the entire header if (and only if) all header bytes are available.

Returns

the FIT file header, or an empty QByteArray if not enough bytes were available.

Definition at line 630 of file fitstreamreader.cpp.

{
    // Return `n` bytes, where `n` is given by the first byte (ie a length-prefixed buffer).
    return (bytesAvailable<T>()) ? readBytes<T>(peekByte<T>()) : QByteArray();
}

readNextDataMessage()

template<class T >

AbstractDataMessage * FitStreamReaderPrivate::readNextDataMessage

protected

Reads up to, and including, the next FIT Data Message.

This function will continue reading the FIT stream until either no bytes are available, or a FIT Data Message has been located and parsed (or failed to be parsed). If (as expected) Definition Messages are found in the process, then they will be parse, and their definitions cached for interpreting future Data Messages.

Note

The caller takes ownership of the returned pointer (if not nullptr), and is responsible for deleting object when finished with.

Returns

the next FIT Data Message, or a nullptr if none found, or an error occurred.

Definition at line 649 of file fitstreamreader.cpp.

{
    // If we haven't parsed the FIT File Header yet, do so now.
    if ((protocolVersion.isNull() && (!parseFileHeader<T>()))) {
        return nullptr;
    }
 
    // Process all FIT Data Records until we get a FIT Data Message (or run out of bytes).
    while (bytesAvailable<T>()) { // At least one byte, for the next data record header byte.
        const quint8 recordHeader = peekByte<T>();
        if (isDefinitionMessage(recordHeader)) {
            if (!parseDefinitionMessage<T>()) return nullptr;
            // Not returning here; we'll continue processing until we get a FIT Data Message.
        } else return parseDataMessage<T>();
    }
    return nullptr;
}

References isDefinitionMessage(), and protocolVersion.

Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• fitstreamreader_p.h
• fitstreamreader.cpp