mferreader.cpp

/******************************************************************************
*
*   This file is part of Cardio Curves.
*   Copyright (C) 2009 Jan Gunnar Andreassen
*   Copyright (C) 2009 Lars Magne Engedal
*
*   Cardio Curves is free software: you can redistribute it and/or modify
*   it under the terms of the GNU Lesser General Public License as published
*   by the Free Software Foundation, either version 2.1 of the License, or
*   (at your option) any later version.
*
*   Cardio Cruves is distributed in the hope that it will be useful,
*   but WITHOUT ANY WARRANTY; without even the implied warranty of
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*   GNU Lesser General Public License for more details.
*
*   You should have received a copy of the GNU Lesser General Public License
*   along with Cardio Curves.  If not, see <http://www.gnu.org/licenses/>.
*
*   Developer contact:
*       (janislazzaroni at users.sourceforge.net)
*       (engedal at users.sourceforge.net )
******************************************************************************/

#include <QFile>
#include <QIODevice>
#include <QDataStream>
#include <QVector>
#include <QPoint>
#include <QtDebug>

#include <map>
#include <cmath> //std::pow
#include <iostream>

#include "mferreader.h"
#include "datahandler.h"

int power(int, int);

MferReader::MferReader(const QString &filename)
{
    this->filename = filename;
    byteorder = QDataStream::BigEndian;
    noswap = QSysInfo::ByteOrder == QSysInfo::BigEndian;
    samplingRateUnit = Frequency_hz;
    samplingResolutionUnit = Volt;
    waveformType = UNDEFINED;

    initParsetable();
    valid = false;
}

bool MferReader::readFile(const QString &filename)
{
    this->filename = filename;
    QFile file(filename);
    file.open(QIODevice::ReadOnly);
    QDataStream in(&file);

    parseBuffer(in);
    parseBlocks();
    valid = true;

    return true;
}

void MferReader::parseBlocks()
{
    mferFrame.dataBlockLength = 0;
    mferFrame.numberOfChannels = 0;
    mferFrame.numberOfSequences = 0;

    parseFuncMap_cit cit;

    for (int i = 0; i < tagsVector.size(); i++)
    {
        cit = parseFunctions.find(tagsVector[i].type);
        if (cit != parseFunctions.end())
        {
            pt2mem p = cit->second;
            (this->*p)(tagsVector[i].value, tagsVector[i].length);
        }

        if (tagsVector[i].type == MWF_WAV)
        {
            convertByteArray(tagsVector[i].length);
        }
    }
}

void MferReader::convertByteArray(int length)
{
    if (length > 0)
    {
        int l = length / sizeof(mfer_data_block);
        int i = 0;
        mferFrame.block = new mfer_data_block[l];
        QDataStream in(baTemp);
        in.setByteOrder(byteorder);
        while (!in.atEnd())
        {
            if (i >= l)
            {
                qDebug() << "overflow in convertByteArray";
                break;
            }
            in >> mferFrame.block[i++];
        }
    }
}

void MferReader::parseBuffer(QDataStream &in)
{
    quint8 d_byte;

    //read entire file
    while (!in.atEnd())
    {
        mfer_tags mt;
        // seek position for this tag
        mt.offset = in.device()->pos();
        // read tag
        in >> d_byte;
        switch (d_byte)
        {
            //Sampling attributes
            case MWF_IVL:
            case MWF_SEN:

            //Frame attributes
            case MWF_BLK:
            case MWF_CHN:
            case MWF_SEQ:

            //Waveform
            case MWF_WFM:
            case MWF_LDN:

            //Data description
            case MWF_DTP:
            case MWF_OFF:
            case MWF_NUL:
            case MWF_CMP:

            //Data alignment
            case MWF_BLE:
            case MWF_PNT:
            case MWF_ZRO:

            //Explanation
            case MWF_PRE:
            case MWF_MAN:
            case MWF_EVT:
            case MWF_INF:
            case MWF_CND:
            case MWF_NTE:
            case MWF_VER:
            case MWF_TXC:
            case MWF_FLT:
            case MWF_IPD:
                mt.type = MFER_TAGS(d_byte);
                break;
            //Channel
            case MWF_ATT:
                mt.type = MFER_TAGS(d_byte);
                //skips channel atm
                in >> d_byte;
                break;

            //Waveform
            case MWF_WAV:
                mt.type = MFER_TAGS(d_byte);
                break;

            default:
                //unknown tag
                mt.type = MWF_INVALID;
                qDebug() << "Invalid tag: " << (quint16)d_byte;
                break;
        }

        in >> d_byte;

        quint32 length = 0;
        if (d_byte & (1<<7))
        {
            int d_numOctets = d_byte & 0x7f;
            // limit to 4 octets
            d_numOctets = qMin(4, d_numOctets);
            while (d_numOctets--)
            {
                length <<= 8;
                in >> d_byte;
                length |= d_byte;
            }
            mt.length = length;
        }
        else
        {
            mt.length = d_byte;
        }

        if (mt.type == MWF_WAV)
        {
            baTemp = in.device()->read(mt.length);
            mt.value = NULL;

        }
        else
        {
            mt.value = new char[mt.length + 1];
            int bytesRead;

            if ((bytesRead = in.readRawData(mt.value, mt.length)) < 0
                || (unsigned int)bytesRead != mt.length)
            {
                qDebug() << "an error occurred readRawData";
                mt.value[bytesRead] = '\0';
            }
            mt.value[mt.length] = '\0';
        }
        tagsVector.push_back(mt);
    }
}

int MferReader::fillData(QVector<QVector<double> > &pDest,
    int screennumber,
    int channel)
{
    int rawLength = mferFrame.dataBlockLength * mferFrame.numberOfChannels;
    rawLength *= mferFrame.numberOfSequences;

    int exp = qAbs(samplingRateExponent);
    int res = power(10, exp);

    int samplesprSecond = res / samplingRateMantissa;

    int samplesprLine = DataHandler::secondsprLine * samplesprSecond;

    int samplesprScreen = DataHandler::numberofLines * samplesprLine;

    int numberOfFullScreens = (rawLength / samplesprScreen);

    int numberOfFullLines = (rawLength / samplesprLine);

    int samplesOnLastLine = rawLength % samplesprLine;

    int linesOnLastScreen = numberOfFullLines % DataHandler::numberofLines;

    int numberOfScreens = 0;
    int screenOffset = 0;

    screennumber = qBound(0, screennumber, numberOfFullScreens);

    if (numberOfFullScreens != 0)
    {
        numberOfScreens = numberOfFullScreens;
        screenOffset = screennumber * samplesprScreen;
    }
    numberOfScreens++;

    int linesToFill = 0;
    bool notFullScreens = false;
    if (numberOfScreens - 1 == screennumber)
    {
        linesToFill = linesOnLastScreen;
        notFullScreens = true;
    }
    else
    {
        linesToFill = DataHandler::numberofLines;
    }

    int i, j;
    double sampres = (samplingResolutionMantissa *
        std::pow(10.0, (double)samplingResolutionExponent));
    int idx = 0;
    for (i = 0; i < linesToFill; i++)
    {
        for (j = 0; j < samplesprLine; j++)
        {
          idx = ((i * samplesprLine) + screenOffset) + j;
            pDest[i][j] = mferFrame.block[idx] * (sampres * 1000);
        }
    }
    if (notFullScreens)
    {
        for (j = 0; j < samplesOnLastLine; j++)
        {
          idx = ((i * samplesprLine) + screenOffset) + j;
            pDest[i][j] = mferFrame.block[idx] * (sampres * 1000);
        }
        for (; j < samplesprLine; j++)
        {
            pDest[i][j] = 65535.0;
        }
        i++;
        for (; i < DataHandler::numberofLines; i++)
        {
            for (j = 0; j < samplesprLine; j++)
            {
                pDest[i][j] = 65535.0;
            }
        }
    }

    return numberOfScreens;
}
void MferReader::initParsetable(void)
{
    //Sampling attributes
    parseFunctions[MWF_IVL] = &MferReader::parse_MWF_IVL;
    parseFunctions[MWF_SEN] = &MferReader::parse_MWF_SEN;

    //Frame attributes
    parseFunctions[MWF_BLK] = &MferReader::parse_MWF_BLK;
    parseFunctions[MWF_CHN] = &MferReader::parse_MWF_CHN;
    parseFunctions[MWF_SEQ] = &MferReader::parse_MWF_SEQ;

    //Waveform attributes
    parseFunctions[MWF_WFM] = &MferReader::parse_MWF_WFM;
    parseFunctions[MWF_LDN] = &MferReader::parse_MWF_LDN;

    //Data alignment
    parseFunctions[MWF_BLE] = &MferReader::parse_MWF_BLE;
}

void MferReader::parse_MWF_IVL(char *value, int length)
{
    samplingRateUnit = SamplingRateUnit(value[0]);
    samplingRateExponent = value[1];

    int v = 0;

    if (noswap)
    {
        char *p = (char *)(&v);
        for (int i = 2; i < length; i++)
        {
            *p++ = value[i];
        }
    }
    else
    {
        register uchar *p = (uchar *)(&v);
        while (length-- > 2)
        {
            *p++ = value[length];
        }
    }
    samplingRateMantissa = v;
}
void MferReader::parse_MWF_SEN(char *value, int length)
{
    samplingResolutionUnit = SamplingResolutionUnit(value[0]);
    samplingResolutionExponent = value[1];

    int v = 0;

    if (noswap)
    {
        char *p = (char *)(&v);
        for (int i = 2; i < length; i++)
        {
            *p++ = value[i];
        }
    }
    else
    {
        register uchar *p = (uchar *)(&v);
        while (length-- > 2)
        {
            *p++ = value[length];
        }
    }
    samplingResolutionMantissa = v;
}
//Frame attributes parsing
void MferReader::parse_MWF_BLK(char *value, int length)
{
    quint32 v = 0;

    if (noswap)
    {
        char *p = (char *)(&v);
        for (int i = 0; i < length; i++)
        {
            *p++ = value[i];
        }
    }
    else
    {
        register uchar *p = (uchar *)(&v);
        while (length--)
        {
            *p++ = value[length];
        }
    }
    mferFrame.dataBlockLength = v;
}
void MferReader::parse_MWF_CHN(char *value, int length)
{
    quint32 v = 0;

    if (noswap)
    {
        char *p = (char *)(&v);
        for (int i = 0; i < length; i++)
        {
            *p++ = value[i];
        }
    }
    else
    {
        register uchar *p = (uchar *)(&v);
        while (length--)
        {
            *p++ = value[length];
        }
    }
    mferFrame.numberOfChannels = v;
}
void MferReader::parse_MWF_SEQ(char *value, int length)
{
    quint32 v = 0;

    if (noswap)
    {
        char *p = (char *)(&v);
        for (int i = 0; i < length; i++)
        {
            *p++ = value[i];
        }
    }
    else
    {
        register uchar *p = (uchar *)(&v);
        while (length--)
        {
            *p++ = value[length];
        }
    }
    mferFrame.numberOfSequences = v;
}

void MferReader::parse_MWF_WFM(char *value, int length)
{
    if (length > 2)
    {
        //Waveform string description
    }
    else
    {
        quint16 v = 0;

        if (noswap)
        {
            char *p = (char *)(&v);
            for (int i = 0; i < length; i++)
            {
                *p++ = value[i];
            }
        }
        else
        {
            register uchar *p = (uchar *)(&v);
            while (length--)
            {
                *p++ = value[length];
            }
        }
        waveformType = WaveformType(v);
    }
}

void MferReader::parse_MWF_LDN(char *value, int length)
{
    if (length > 2)
    {
        //Waveform string description
    }
    else if (length == 2)
    {
        //encoded code tag thingy
    }
    else
    {
         quint16 v = 0;

        if (noswap)
        {
            char *p = (char *)(&v);
            for (int i = 0; i < length; i++)
            {
                *p++ = value[i];
            }
        }
        else
        {
            register uchar *p = (uchar *)(&v);
            while (length--)
            {
                *p++ = value[length];
            }
        }
        //waveformCode = WaveformCode(v);
    }
}

void MferReader::parse_MWF_BLE(char *value, int length)
{
    if (*value == 0x00)
    {
        byteorder = QDataStream::BigEndian;
    }
    else if (*value == 0x01)
    {
        byteorder = QDataStream::LittleEndian;
    }
    if (QSysInfo::ByteOrder == QSysInfo::BigEndian)
    {
        noswap = (byteorder == QDataStream::BigEndian);
    }
    else
    {
        noswap = (byteorder == QDataStream::LittleEndian);
    }
}
int MferReader::samplesprSecond() const
{
    int exp = qAbs(samplingRateExponent);
    int res = power(10, exp);
    return (res / samplingRateMantissa);
}

int power (int base, int exp)
{
   if(exp >= 1)
       return base * (power(base,exp - 1));

   else
       return 1;
}

---