chris/OSCAR-code
1
0
Fork 0
mirror of https://gitlab.com/pholy/OSCAR-code.git synced 2025-04-05 10:40:42 +00:00
Code Issues Packages Projects Releases Wiki Activity
3e6bddc08c
OSCAR-code/SleepLib/loader_plugins/prs1_loader.cpp
Mark Watkins 687eb0aaa2 Catch some exceptions
2011-07-03 21:49:47 +10:00

788 lines
25 KiB
C++
Raw Blame History

/*
SleepLib PRS1 Loader Implementation
Author: Mark Watkins <jedimark64@users.sourceforge.net>
License: GPL
*/
#include <QString>
#include <QDateTime>
#include <QDir>
#include <QFile>
#include <QMessageBox>
#include <QProgressBar>
#include <QDebug>
#include "prs1_loader.h"
#include "SleepLib/session.h"
//********************************************************************************************
/// IMPORTANT!!!
//********************************************************************************************
// Please INCREMENT the prs1_data_version in prs1_loader.h when making changes to this loader
// that change loader behaviour or modify channels.
//********************************************************************************************
extern QProgressBar *qprogress;
map<int,QString> ModelMap;
PRS1::PRS1(Profile *p,MachineID id):CPAP(p,id)
{
m_class=prs1_class_name;
properties["Brand"]="Philips Respironics";
properties["Model"]="System One";
//SleepFlags= { CPAP_RERA, PRS1_VSnore2, CPAP_FlowLimit, CPAP_Hypopnea, CPAP_Obstructive, CPAP_ClearAirway, CPAP_CSR };
}
PRS1::~PRS1()
{
}
PRS1Loader::PRS1Loader()
{
m_buffer=new unsigned char [max_load_buffer_size]; //allocate once and reuse.
}
PRS1Loader::~PRS1Loader()
{
for (map<QString,Machine *>::iterator i=PRS1List.begin(); i!=PRS1List.end(); i++) {
delete i->second;
}
delete [] m_buffer;
}
Machine *PRS1Loader::CreateMachine(QString serial,Profile *profile)
{
qDebug() << "Create Machine " << serial;
assert(profile!=NULL);
vector<Machine *> ml=profile->GetMachines(MT_CPAP);
bool found=false;
for (vector<Machine *>::iterator i=ml.begin(); i!=ml.end(); i++) {
if (((*i)->GetClass()=="PRS1") && ((*i)->properties["Serial"]==serial)) {
PRS1List[serial]=*i; //static_cast<CPAP *>(*i);
found=true;
break;
}
}
if (found) return PRS1List[serial];
//assert(PRS1List.find(serial)==PRS1List.end())
Machine *m=new PRS1(profile,0);
PRS1List[serial]=m;
profile->AddMachine(m);
m->properties["Serial"]=serial;
return m;
}
bool isdigit(QChar c)
{
if ((c>='0') && (c<='9')) return true;
return false;
}
bool PRS1Loader::Open(QString & path,Profile *profile)
{
QString newpath;
QString pseries="P-Series";
if (path.endsWith("/"+pseries)) {
newpath=path;
} else {
newpath=path+"/"+pseries;
}
QDir dir(newpath);
if ((!dir.exists() || !dir.isReadable()))
return 0;
qDebug() << "PRS1Loader::Open newpath=" << newpath;
dir.setFilter(QDir::NoDotAndDotDot | QDir::Dirs | QDir::Files | QDir::Hidden | QDir::NoSymLinks);
dir.setSorting(QDir::Name);
QFileInfoList flist=dir.entryInfoList();
list<QString> SerialNumbers;
list<QString>::iterator sn;
for (int i=0;i<flist.size();i++) {
QFileInfo fi=flist.at(i);
QString filename=fi.fileName();
if ((filename[0]=='P') && (isdigit(filename[1])) && (isdigit(filename[2]))) {
SerialNumbers.push_back(filename);
} else if (filename.toLower()=="last.txt") { // last.txt points to the current serial number
QString file=fi.canonicalFilePath();
QFile f(file);
if (!fi.isReadable()) {
qDebug() << "PRS1Loader: last.txt exists but I couldn't read it!";
continue;
}
if (!f.open(QIODevice::ReadOnly)) {
qDebug() << "PRS1Loader: last.txt exists but I couldn't open it!";
continue;
}
last=f.readLine(64);
last=last.trimmed();
f.close();
}
}
if (SerialNumbers.empty()) return 0;
Machine *m;
for (sn=SerialNumbers.begin(); sn!=SerialNumbers.end(); sn++) {
QString s=*sn;
m=CreateMachine(s,profile);
try {
if (m) OpenMachine(m,newpath+"/"+(*sn),profile);
} catch(OneTypePerDay e) {
profile->DelMachine(m);
PRS1List.erase(s);
QMessageBox::warning(NULL,"Import Error","This Machine Record cannot be imported in this profile.\nThe Day records overlap with already existing content.",QMessageBox::Ok);
delete m;
}
}
return PRS1List.size();
// return c;
}
bool PRS1Loader::ParseProperties(Machine *m,QString filename)
{
QFile f(filename);
if (!f.open(QIODevice::ReadOnly))
return false;
QString line;
map<QString,QString> prop;
QString s=f.readLine();
QChar sep='=';
QString key,value;
while (!f.atEnd()) {
key=s.section(sep,0,0); //BeforeFirst(sep);
if (key==s) continue;
value=s.section(sep,1).trimmed(); //AfterFirst(sep).Strip();
if (value==s) continue;
prop[key]=value;
s=f.readLine();
}
bool ok;
int i=prop["ProductType"].toInt(&ok);
if (ok) {
if (ModelMap.find(i)!=ModelMap.end()) {
m->properties["SubModel"]=ModelMap[i];
}
}
if (prop["SerialNumber"]!=m->properties["Serial"]) {
qDebug() << "Serial Number in PRS1 properties.txt doesn't match directory structure";
} else prop.erase("SerialNumber"); // already got it stored.
for (map<QString,QString>::iterator i=prop.begin(); i!=prop.end(); i++) {
m->properties[i->first]=i->second;
}
f.close();
return true;
}
int PRS1Loader::OpenMachine(Machine *m,QString path,Profile *profile)
{
qDebug() << "Opening PRS1 " << path;
QDir dir(path);
if (!dir.exists() || (!dir.isReadable()))
return false;
dir.setFilter(QDir::NoDotAndDotDot | QDir::Dirs | QDir::Files | QDir::Hidden | QDir::NoSymLinks);
dir.setSorting(QDir::Name);
QFileInfoList flist=dir.entryInfoList();
QString filename;
if (qprogress) qprogress->setValue(0);
list<QString> paths;
for (int i=0;i<flist.size();i++) {
QFileInfo fi=flist.at(i);
filename=fi.fileName();
if ((filename[0].toLower()=='p') && (isdigit(filename[1]))) {
paths.push_back(fi.canonicalFilePath());
} else if (filename.toLower()=="properties.txt") {
ParseProperties(m,fi.canonicalFilePath());
} else if (filename.toLower()=="e") {
// don't really give a crap about .004 files yet.
}
//if (qprogress) qprogress->Pulse();
}
SessionID session;
long ext;
typedef vector<QString> StringList;
map<SessionID,StringList> sessfiles;
int size=paths.size();
int cnt=0;
bool ok;
for (list<QString>::iterator p=paths.begin(); p!=paths.end(); p++) {
dir.setPath(*p);
if (!dir.exists() || !dir.isReadable()) continue;
flist=dir.entryInfoList();
for (int i=0;i<flist.size();i++) {
QFileInfo fi=flist.at(i);
QString ext_s=fi.fileName().section(".",-1);
QString session_s=fi.fileName().section(".",0,-2);
ext=ext_s.toLong(&ok);
if (!ok) continue;
session=session_s.toLong(&ok);
if (!ok) continue;
if (sessfiles[session].capacity()==0) sessfiles[session].resize(3);
if (ext==1) {
sessfiles[session][0]=fi.canonicalFilePath();
} else if (ext==2) {
sessfiles[session][1]=fi.canonicalFilePath();
} else if (ext==5) {
sessfiles[session][2]=fi.canonicalFilePath();
}
cnt++;
//if (qprogress) qprogress->Pulse(); //Update((float(cnt)/float(size)*25));
if (qprogress) qprogress->setValue((float(cnt)/float(size)*33.0));
}
}
size=sessfiles.size();
if (size==0)
return 0;
cnt=0;
for (map<SessionID,StringList>::iterator s=sessfiles.begin(); s!=sessfiles.end(); s++) {
session=s->first;
cnt++;
if (qprogress) qprogress->setValue(33.0+(float(cnt)/float(size)*33.0));
if (m->SessionExists(session)) continue;
if (s->second[0].isEmpty()) continue;
Session *sess=new Session(m,session);
if (session==0x112)
int q=0;
if (!OpenSummary(sess,s->second[0])) {
qWarning() << "PRS1Loader: Could'nt open summary file " << s->second[0];
delete sess;
continue;
}
//sess->SetSessionID(sess->start().GetTicks());
if (!s->second[1].isEmpty()) {
if (!OpenEvents(sess,s->second[1])) {
qWarning() << "PRS1Loader: Couldn't open event file " << s->second[1];
}
}
if (!s->second[2].isEmpty()) {
if (!OpenWaveforms(sess,s->second[2])) {
qWarning() << "PRS1Loader: Couldn't open event file " << s->second[2];
}
}
const double ignore_thresh=300.0/3600.0;// Ignore useless sessions under 5 minute
if (sess->hours()<=ignore_thresh) {
delete sess;
continue;
}
m->AddSession(sess,profile);
//if (sess->summary.find(CPAP_Obstructive)==sess->summary.end()) {
sess->summary[CPAP_Obstructive]=sess->count_events(CPAP_Obstructive);
sess->summary[CPAP_Hypopnea]=sess->count_events(CPAP_Hypopnea);
sess->summary[CPAP_ClearAirway]=sess->count_events(CPAP_ClearAirway);
sess->summary[CPAP_RERA]=sess->count_events(CPAP_RERA);
sess->summary[CPAP_FlowLimit]=sess->count_events(CPAP_FlowLimit);
//}
sess->summary[CPAP_CSR]=sess->sum_event_field(CPAP_CSR,0);
sess->summary[CPAP_VSnore]=sess->count_events(CPAP_VSnore);
sess->summary[CPAP_Snore]=sess->sum_event_field(CPAP_Snore,0);
if (sess->count_events(CPAP_IAP)>0) {
sess->summary[CPAP_Mode]=MODE_BIPAP;
if (sess->summary[CPAP_PressureReliefType].toInt()!=PR_NONE) {
sess->summary[CPAP_PressureReliefType]=PR_BIFLEX;
}
sess->summary[CPAP_PressureMedian]=(sess->avg_event_field(CPAP_EAP,0)+sess->avg_event_field(CPAP_IAP,0))/2.0;
sess->summary[CPAP_PressureAverage]=(sess->weighted_avg_event_field(CPAP_IAP,0)+sess->weighted_avg_event_field(CPAP_EAP,0))/2.0;
sess->summary[CPAP_PressureMinAchieved]=sess->min_event_field(CPAP_IAP,0);
sess->summary[CPAP_PressureMaxAchieved]=sess->max_event_field(CPAP_EAP,0);
sess->summary[BIPAP_EAPAverage]=sess->weighted_avg_event_field(CPAP_EAP,0);
sess->summary[BIPAP_EAPMin]=sess->min_event_field(CPAP_EAP,0);
sess->summary[BIPAP_EAPMax]=sess->max_event_field(CPAP_EAP,0);
sess->summary[BIPAP_IAPAverage]=sess->weighted_avg_event_field(CPAP_IAP,0);
sess->summary[BIPAP_IAPMin]=sess->min_event_field(CPAP_IAP,0);
sess->summary[BIPAP_IAPMax]=sess->max_event_field(CPAP_IAP,0);
} else {
sess->summary[CPAP_PressureMedian]=sess->avg_event_field(CPAP_Pressure,0);
//sess->summary[CPAP_PressureAverage]=sess->weighted_avg_event_field(CPAP_Pressure,0);
sess->summary[CPAP_PressureMinAchieved]=sess->min_event_field(CPAP_Pressure,0);
sess->summary[CPAP_PressureMaxAchieved]=sess->max_event_field(CPAP_Pressure,0);
if (sess->summary.find(CPAP_PressureMin)==sess->summary.end()) {
sess->summary[CPAP_BrokenSummary]=true;
//sess->set_last(sess->first());
if (sess->summary[CPAP_PressureMinAchieved]==sess->summary[CPAP_PressureMaxAchieved]) {
sess->summary[CPAP_Mode]=MODE_CPAP;
} else {
sess->summary[CPAP_Mode]=MODE_UNKNOWN;
}
sess->summary[CPAP_PressureReliefType]=PR_UNKNOWN;
}
}
if (sess->summary[CPAP_Mode]==MODE_CPAP) {
sess->summary[CPAP_PressureAverage]=sess->summary[CPAP_PressureMin];
sess->summary[CPAP_PressureMax]=sess->summary[CPAP_PressureMin];
}
sess->summary[CPAP_LeakMinimum]=sess->min_event_field(CPAP_Leak,0);
sess->summary[CPAP_LeakMaximum]=sess->max_event_field(CPAP_Leak,0); // should be merged..
sess->summary[CPAP_LeakMedian]=sess->avg_event_field(CPAP_Leak,0);
sess->summary[CPAP_LeakAverage]=sess->weighted_avg_event_field(CPAP_Leak,0);
sess->summary[CPAP_SnoreMinimum]=sess->min_event_field(CPAP_Snore,0);
sess->summary[CPAP_SnoreMaximum]=sess->max_event_field(CPAP_Snore,0);
sess->summary[CPAP_SnoreMedian]=sess->avg_event_field(CPAP_Snore,0);
sess->summary[CPAP_SnoreAverage]=sess->weighted_avg_event_field(CPAP_Snore,0);
//Printf(sess->start().Format()+wxT(" avgsummary=%.3f avgmine=%.3f\n"),sess->summary[CPAP_PressureAverage].GetDouble(),sess->weighted_avg_event_field(CPAP_Pressure,0));
sess->SetChanged(true);
}
QString s;
s.sprintf("%i",prs1_data_version);
m->properties["DataVersion"]=s;
m->Save(); // Save any new sessions to disk in our format
if (qprogress) qprogress->setValue(100);
return true;
}
bool PRS1Loader::OpenSummary(Session *session,QString filename)
{
int size,sequence,seconds,br;
qint64 timestamp;
unsigned char header[24];
unsigned char ext,sum;
//qDebug() << "Opening PRS1 Summary " << filename;
QFile f(filename);
//,wxT("rb"));
if (!f.open(QIODevice::ReadOnly))
return false;
if (!f.exists())
return false;
int hl=16;
br=f.read((char *)header,hl);
if (header[0]!=header[5])
return false;
sequence=size=timestamp=seconds=ext=0;
sequence=(header[10] << 24) | (header[9] << 16) | (header[8] << 8) | header[7];
timestamp=(header[14] << 24) | (header[13] << 16) | (header[12] << 8) | header[11];
size=(header[2] << 8) | header[1];
ext=header[6];
if (ext!=1)
return false;
//size|=(header[3]<<16) | (header[4]<<24); // the jury is still out on the 32bitness of one. doesn't matter here anyway.
size-=(hl+2);
sum=0;
for (int i=0; i<hl-1; i++) sum+=header[i];
if (sum!=header[hl-1])
return false;
if (size<=19) {
qDebug() << "Ignoring short session file " << filename;
return false;
}
qint64 date=timestamp*1000;
memset(m_buffer,0,size);
unsigned char * buffer=m_buffer;
br=f.read((char *)buffer,size);
if (br<size) {
return false;
}
if (size<0x30)
return true;
session->set_first(date);
//session->set_last(date);
double max;
session->summary[CPAP_PressureMin]=(double)buffer[0x03]/10.0;
session->summary[CPAP_PressureMax]=max=(double)buffer[0x04]/10.0;
session->summary[CPAP_RampTime]=(int)buffer[0x06]; // Minutes. Convert to seconds/hours here?
session->summary[CPAP_RampStartingPressure]=(double)buffer[0x07]/10.0;
if (max>0) { // Ignoring bipap until I see some more data.
session->summary[CPAP_Mode]=(int)MODE_APAP;
} else session->summary[CPAP_Mode]=(int)MODE_CPAP;
// This is incorrect..
if (buffer[0x08] & 0x80) { // Flex Setting
if (buffer[0x08] & 0x08) {
if (max>0) session->summary[CPAP_PressureReliefType]=(int)PR_AFLEX;
else session->summary[CPAP_PressureReliefType]=(int)PR_CFLEXPLUS;
} else session->summary[CPAP_PressureReliefType]=(int)PR_CFLEX;
} else session->summary[CPAP_PressureReliefType]=(int)PR_NONE;
session->summary[CPAP_PressureReliefSetting]=(int)buffer[0x08] & 3;
session->summary[CPAP_HumidifierSetting]=(int)buffer[0x09]&0x0f;
session->summary[CPAP_HumidifierStatus]=(buffer[0x09]&0x80)==0x80;
session->summary[PRS1_SystemLockStatus]=(buffer[0x0a]&0x80)==0x80;
session->summary[PRS1_SystemResistanceStatus]=(buffer[0x0a]&0x40)==0x40;
session->summary[PRS1_SystemResistanceSetting]=(int)buffer[0x0a]&7;
session->summary[PRS1_HoseDiameter]=(int)((buffer[0x0a]&0x08)?15:22);
session->summary[PRS1_AutoOff]=(buffer[0x0c]&0x10)==0x10;
session->summary[PRS1_MaskAlert]=(buffer[0x0c]&0x08)==0x08;
session->summary[PRS1_ShowAHI]=(buffer[0x0c]&0x04)==0x04;
unsigned char * b=&buffer[0x14];
quint16 bb=*(quint16*)b;
unsigned duration=bb;// | (buffer[0x15] << 8);
session->summary[CPAP_Duration]=(int)duration;
//qDebug() << "ID: " << session->session() << " " << duration;
//float hours=float(duration)/3600.0;
//session->set_hours(hours);
if (!duration) return false;
session->set_last(date+qint64(duration)*1000L);
session->summary[CPAP_PressureMinAchieved]=buffer[0x16]/10.0;
session->summary[CPAP_PressureMaxAchieved]=buffer[0x17]/10.0;
session->summary[CPAP_PressureAverage]=buffer[0x18]/10.0;
session->summary[CPAP_PressurePercentValue]=buffer[0x19]/10.0;
session->summary[CPAP_PressurePercentName]=90.0;
if (max==0) {
session->summary[CPAP_PressureAverage]=session->summary[CPAP_PressureMin];
}
if (size==0x4d) {
session->summary[CPAP_Obstructive]=(int)buffer[0x1C] | (buffer[0x1D] << 8);
session->summary[CPAP_ClearAirway]=(int)buffer[0x20] | (buffer[0x21] << 8);
session->summary[CPAP_Hypopnea]=(int)buffer[0x2A] | (buffer[0x2B] << 8);
session->summary[CPAP_RERA]=(int)buffer[0x2E] | (buffer[0x2F] << 8);
session->summary[CPAP_FlowLimit]=(int)buffer[0x30] | (buffer[0x31] << 8);
}
return true;
}
bool PRS1Loader::Parse002(Session *session,unsigned char *buffer,int size,qint64 timestamp)
{
MachineCode Codes[]={
PRS1_Unknown00, PRS1_Unknown01, CPAP_Pressure, CPAP_EAP, PRS1_PressurePulse, CPAP_RERA, CPAP_Obstructive, CPAP_ClearAirway,
PRS1_Unknown08, PRS1_Unknown09, CPAP_Hypopnea, PRS1_Unknown0B, CPAP_FlowLimit, CPAP_VSnore, PRS1_Unknown0E, CPAP_CSR, PRS1_Unknown10,
CPAP_Leak, PRS1_Unknown12
};
int ncodes=sizeof(Codes)/sizeof(MachineCode);
EventDataType data[4];
qint64 start=timestamp;
qint64 t=timestamp;
qint64 tt;
int pos=0;
int cnt=0;
short delta;
while (pos<size) {
char code=buffer[pos++];
assert(code<ncodes);
if (code!=0x12) {
delta=buffer[pos] | buffer[pos+1] << 8;
pos+=2;
t+=delta*1000;
}
// float data0,data1,data2;
MachineCode cpapcode=Codes[(int)code];
tt=t;
cnt++;
switch (code) {
case 0x00: // Unknown
case 0x01: // Unknown
case 0x02: // Pressure
data[0]=buffer[pos++]/10.0;
session->AddEvent(new Event(t,cpapcode, data,1));
break;
case 0x04: // Pressure Pulse
data[0]=buffer[pos++];
session->AddEvent(new Event(t,cpapcode, data,1));
break;
case 0x05: // RERA
case 0x06: // Obstructive Apoanea
case 0x07: // Clear Airway
case 0x0a: // Hypopnea
case 0x0c: // Flow Limitation
data[0]=buffer[pos];
tt-=buffer[pos++]*1000; // Subtract Time Offset
session->AddEvent(new Event(tt,cpapcode,data,1));
break;
case 0x0d: // Vibratory Snore
session->AddEvent(new Event(t,cpapcode, data,0));
break;
case 0x03: // BIPAP Pressure
case 0x0b: // Unknown
case 0x11: // Leak Rate
data[0]=buffer[pos++];
data[1]=buffer[pos++];
if (code==0x11) {
session->AddEvent(new Event(t,cpapcode, data,1));
session->AddEvent(new Event(t,CPAP_Snore,&data[1],1));
if (data[1]>0) {
session->AddEvent(new Event(t,PRS1_VSnore2, &data[1],1));
}
} else if (code==0x03) {
data[0]/=10.0;
data[1]/=10.0;
session->AddEvent(new Event(t,CPAP_EAP, data, 1));
session->AddEvent(new Event(t,CPAP_IAP, &data[1], 1));
} else {
session->AddEvent(new Event(t,cpapcode, data, 2));
}
break;
case 0x0e: // Unknown
case 0x10: // Unknown
data[0]=buffer[pos++]; // << 8) | buffer[pos];
data[1]=buffer[pos++];
data[2]=buffer[pos++];
session->AddEvent(new Event(t,cpapcode, data, 3));
break;
case 0x0f: // Cheyne Stokes Respiration
data[0]=buffer[pos+1]<<8 | buffer[pos];
pos+=2;
data[1]=buffer[pos++];
tt-=data[1]*1000;
session->AddEvent(new Event(tt,cpapcode, data, 2));
break;
case 0x12: // Summary
data[0]=buffer[pos++];
data[1]=buffer[pos++];
data[2]=buffer[pos+1]<<8 | buffer[pos];
pos+=2;
session->AddEvent(new Event(t,cpapcode, data,3));
break;
default:
// ERROR!!!
qWarning() << "Some new fandangled PRS1 code detected:" << code;
return false;
}
}
return true;
}
bool PRS1Loader::OpenEvents(Session *session,QString filename)
{
int size,sequence,seconds,br;
qint64 timestamp;
unsigned char header[24]; // use m_buffer?
unsigned char ext;
//wxLogMessage(wxT("Opening PRS1 Events ")+filename);
QFile f(filename);
if (!f.open(QIODevice::ReadOnly))
return false;
int hl=16;
br=f.read((char *)header,hl);
if (header[0]!=header[5])
return false;
sequence=size=timestamp=seconds=ext=0;
sequence=(header[10] << 24) | (header[9] << 16) | (header[8] << 8) | header[7];
timestamp=(header[14] << 24) | (header[13] << 16) | (header[12] << 8) | header[11];
size=(header[2] << 8) | header[1];
ext=header[6];
if (ext!=2)
return false;
//size|=(header[3]<<16) | (header[4]<<24); // the jury is still out on the 32bitness of one. doesn't matter here anyway.
size-=(hl+2);
unsigned char sum=0;
for (int i=0; i<hl-1; i++) sum+=header[i];
if (sum!=header[hl-1]) return false;
unsigned char *buffer=(unsigned char *)m_buffer;
br=f.read((char *)buffer,size);
if (br<size) {
return false;
}
Parse002(session,buffer,size,timestamp*1000L);
return true;
}
bool PRS1Loader::OpenWaveforms(Session *session,QString filename)
{
//wxLogMessage(wxT("Opening PRS1 Waveforms ")+filename);
int size,sequence,seconds,br;
unsigned cnt=0;
qint64 timestamp;
qint64 start=0;
unsigned char header[24];
unsigned char ext;
QFile f(filename);
if (!f.open(QIODevice::ReadOnly))
return false;
int hl=24;
long samples=0;
qint64 duration=0;
char * buffer=(char *)m_buffer;
while (true) {
br=f.read((char *)header,hl);
if (br<hl) {
if (cnt==0)
return false;
break;
}
if (header[0]!=header[5]) {
if (cnt==0)
return false;
break;
}
sequence=size=timestamp=seconds=ext=0;
sequence=(header[10] << 24) | (header[9] << 16) | (header[8] << 8) | header[7];
timestamp=(header[14] << 24) | (header[13] << 16) | (header[12] << 8) | header[11];
size=(header[2] << 8) | header[1];
ext=header[6];
if (sequence==328) {
seconds=0;
}
if (!start) start=timestamp*1000;
seconds=(header[16] << 8) | header[15];
size-=(hl+2);
if (ext!=5) {
if (cnt==0)
return false;
break;
}
unsigned char sum=0;
for (int i=0; i<hl-1; i++) sum+=header[i];
if (sum!=header[hl-1])
return false;
if (samples+size>=max_load_buffer_size) {
qWarning("max_load_buffer_size is too small in PRS1 Loader");
if (cnt==0)
return false;
break;
}
br=f.read((char *)&buffer[samples],size);
if (br<size) {
delete [] buffer;
break;
}
//wavedata.push_back(buffer);
//wavesize.push_back(size);
cnt++;
duration+=seconds;
samples+=size;
char chkbuf[2];
qint16 chksum;
br=f.read(chkbuf,2);
if (br<2)
return false;
chksum=chkbuf[0] << 8 | chkbuf[1];
}
if (samples==0)
return false;
//double rate=double(duration)/double(samples);
// Convert to SampleFormat
SampleFormat *data=new SampleFormat [samples];
SampleFormat min=0,max=0;
bool first=true;
SampleFormat c;
duration*=1000;
for (long i=0;i<samples;i++) {
data[i]=buffer[i];
c=data[i];
if (first) {
min=max=c;
first=false;
}
if (min>c) min=c;
if (max<c) max=c;
}
Waveform *w=new Waveform(start,CPAP_FlowRate,data,samples,duration,min,max);
session->AddWaveform(w);
return true;
}
void InitModelMap()
{
ModelMap[34]="RemStar Pro with C-Flex+";
ModelMap[35]="RemStar Auto with A-Flex";
ModelMap[37]="RemStar BIPAP Auto with Bi-Flex";
};
bool initialized=false;
void PRS1Loader::Register()
{
if (initialized) return;
qDebug() << "Registering PRS1Loader";
RegisterLoader(new PRS1Loader());
InitModelMap();
initialized=true;
}
Reference in New Issue View Git Blame Copy Permalink