void UI_BI98002EDFwindow::SelectFileButton()
{
int i, j, n,
tmp,
end_of_file,
samplefreq=0,
chns = 3,
hdl,
samplesize=1,
bufsize,
*buf2,
datablocks,
blocks_written,
checked_modelnumber=0,
checked_samplerate=0,
checked_recordhours=0,
checked_recorddate=0,
checked_recordtime=0,
startdate_year=0,
startdate_month=0,
startdate_day=0,
starttime_hour=0,
starttime_minute=0,
starttime_second=0,
progress_steps;
char path[MAX_PATH_LENGTH],
outputfilename[MAX_PATH_LENGTH],
str[2048],
str2[128],
*buf1,
tmp2,
modelnumber_str[32];
FILE *dcmfile,
*evtfile;
strcpy(path, QFileDialog::getOpenFileName(0, "Select inputfile", QString::fromLocal8Bit(recent_opendir), "DCM files (*.dcm *.DCM)").toLocal8Bit().data());
if(!strcmp(path, ""))
{
return;
}
get_directory_from_path(recent_opendir, path, MAX_PATH_LENGTH);
get_filename_from_path(outputfilename, path, MAX_PATH_LENGTH);
dcmfile = fopeno(path, "rb");
if(dcmfile==NULL)
{
snprintf(str, 2048, "Can not open file %s for reading.", path);
QMessageBox messagewindow(QMessageBox::Critical, "Error", QString::fromLocal8Bit(str));
messagewindow.exec();
return;
}
remove_extension_from_filename(path);
strcat(path, ".EVT");
evtfile = fopeno(path, "rb");
if(evtfile==NULL)
{
remove_extension_from_filename(path);
strcat(path, ".evt");
evtfile = fopeno(path, "rb");
if(evtfile==NULL)
{
snprintf(str, 2048, "Can not open file %s for reading.", path);
QMessageBox messagewindow(QMessageBox::Critical, "Error", str);
messagewindow.exec();
fclose(dcmfile);
return;
}
}
/***************** check if the file is valid ******************************/
for(end_of_file=0; end_of_file == 0; )
{
for(i=0; i<256; i++)
{
tmp = fgetc(evtfile);
if(tmp == '\n')
{
break;
}
if(tmp == EOF)
{
end_of_file = 1;
break;
}
str[i] = tmp;
}
str[i] = 0;
if(!(strncmp(str, "Sampling Rate=", 14)))
{
samplefreq = atoi(str + 14);
switch(samplefreq)
{
case 128 : break;
case 256 : break;
case 512 : break;
case 1024 : break;
default : QMessageBox messagewindow(QMessageBox::Critical, "Error", "Unknown samplerate.");
messagewindow.exec();
fclose(dcmfile);
fclose(evtfile);
return;
}
checked_samplerate = 1;
}
if(!(strncmp(str, "Model number=", 13)))
{
strncpy(modelnumber_str, str + 13, 8);
modelnumber_str[8] = 0;
if(strcmp(modelnumber_str, "TM SD01G") &&
strcmp(modelnumber_str, "SD SD02G"))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Wrong modelnumber.");
messagewindow.exec();
fclose(dcmfile);
fclose(evtfile);
return;
}
checked_modelnumber = 1;
}
if(!(strncmp(str, "Record Date=", 12)))
{
strncpy(str2, str + 12, 10);
str2[10] = 0;
startdate_year = atoi(str2);
startdate_month = atoi(str2 + 5);
startdate_day = atoi(str2 + 8);
if((startdate_year < 1970) || (startdate_year > 3000) ||
(startdate_month < 1) || (startdate_month > 12) ||
(startdate_day < 1) || (startdate_day > 31))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Wrong record date.");
messagewindow.exec();
fclose(dcmfile);
fclose(evtfile);
return;
}
checked_recorddate = 1;
}
if(!(strncmp(str, "Record Time=", 12)))
{
strncpy(str2, str + 12, 10);
str2[8] = 0;
starttime_hour = atoi(str2);
starttime_minute = atoi(str2 + 3);
starttime_second = atoi(str2 + 6);
if((starttime_hour < 0) || (starttime_hour > 23) ||
(starttime_minute < 0) || (starttime_minute > 59) ||
(starttime_second < 0) || (starttime_second > 59))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Wrong recordtime.");
messagewindow.exec();
fclose(dcmfile);
fclose(evtfile);
return;
}
checked_recordtime = 1;
}
if(!(strncmp(str, "Record Hours=", 13)))
{
strncpy(str2, str + 13, 10);
str2[2] = 0;
if((atoi(str2) != 24) && (atoi(str2) != 48))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Wrong record hours.");
messagewindow.exec();
fclose(dcmfile);
fclose(evtfile);
return;
}
checked_recordhours = 1;
}
}
if(!checked_modelnumber ||
!checked_samplerate ||
!checked_recordhours ||
!checked_recorddate ||
!checked_recordtime)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Missing line.");
messagewindow.exec();
fclose(dcmfile);
fclose(evtfile);
return;
}
///////////////////////////////////////////////////////////////////////////////////
bufsize = chns * samplesize * samplefreq;
buf1 = (char *)malloc(bufsize);
if(buf1 == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error.");
messagewindow.exec();
fclose(dcmfile);
fclose(evtfile);
return;
}
buf2 = (int *)malloc(bufsize * sizeof(int));
if(buf2 == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error.");
messagewindow.exec();
fclose(dcmfile);
fclose(evtfile);
free(buf1);
return;
}
///////////////////////////////////////////////////////////////////////////////////
path[0] = 0;
if(recent_savedir[0]!=0)
{
strcpy(path, recent_savedir);
strcat(path, "/");
}
strcat(path, outputfilename);
remove_extension_from_filename(path);
strcat(path, ".edf");
strcpy(path, QFileDialog::getSaveFileName(0, "Select outputfile", QString::fromLocal8Bit(path), "EDF files (*.edf *.EDF)").toLocal8Bit().data());
if(!strcmp(path, ""))
{
fclose(dcmfile);
fclose(evtfile);
free(buf1);
free(buf2);
return;
}
get_directory_from_path(recent_savedir, path, MAX_PATH_LENGTH);
hdl = edfopen_file_writeonly(path, EDFLIB_FILETYPE_EDFPLUS, chns);
if(hdl<0)
{
snprintf(str, 2048, "Can not open file %s for writing.", path);
QMessageBox messagewindow(QMessageBox::Critical, "Error", str);
messagewindow.exec();
fclose(dcmfile);
fclose(evtfile);
free(buf1);
free(buf2);
return;
}
for(i=0; i<chns; i++)
{
edf_set_samplefrequency(hdl, i, samplefreq);
}
for(i=0; i<chns; i++)
{
edf_set_digital_maximum(hdl, i, 127);
}
for(i=0; i<chns; i++)
{
edf_set_digital_minimum(hdl, i, -128);
}
for(i=0; i<chns; i++)
{
edf_set_physical_maximum(hdl, i, 2442.307692);
}
for(i=0; i<chns; i++)
{
edf_set_physical_minimum(hdl, i, -2461.538462);
}
for(i=0; i<chns; i++)
{
edf_set_physical_dimension(hdl, i, "uV");
}
edf_set_label(hdl, 0, "channel 1");
edf_set_label(hdl, 1, "channel 2");
edf_set_label(hdl, 2, "channel 3");
edf_set_equipment(hdl, modelnumber_str);
edf_set_patientname(hdl, "BI9800");
edf_set_startdatetime(hdl, startdate_year, startdate_month, startdate_day, starttime_hour, starttime_minute, starttime_second);
fseeko(dcmfile, 0LL, SEEK_END);
datablocks = ftello(dcmfile) / bufsize;
fseeko(dcmfile, 0LL, SEEK_SET);
QProgressDialog progress("Converting...", "Cancel", 0, datablocks, myobjectDialog);
progress.setWindowModality(Qt::WindowModal);
progress.setMinimumDuration(200);
progress_steps = datablocks / 100;
if(progress_steps < 1)
{
progress_steps = 1;
}
for(blocks_written=0; ; blocks_written++)
{
if(!(blocks_written % progress_steps))
{
progress.setValue(blocks_written);
qApp->processEvents();
if(progress.wasCanceled() == true)
{
break;
}
}
n = fread(buf1, bufsize, 1, dcmfile);
if(n != 1)
{
break;
}
for(i=0; i<samplefreq; i++)
{
for(j=0; j<chns; j++)
{
tmp2 = buf1[(i * chns) + j] + 128;
buf2[(j * samplefreq) + i] = tmp2;
}
}
edf_blockwrite_digital_samples(hdl, buf2);
}
progress.reset();
edfwrite_annotation_latin1(hdl, 0LL, -1LL, "Recording starts");
fseeko(evtfile, 0LL, SEEK_SET);
for(end_of_file=0; end_of_file == 0; )
{
for(i=0; i<256; i++)
{
tmp = fgetc(evtfile);
if((tmp == '\n') || (tmp == '\r'))
{
break;
}
if(tmp == EOF)
{
end_of_file = 1;
break;
}
str[i] = tmp;
}
str[i] = 0;
if((isdigit(str[0])) && (isdigit(str[1])))
{
starttime_hour = atoi(str);
starttime_minute = atoi(str + 3);
starttime_second = atoi(str + 6);
if((starttime_hour < 0) || (starttime_hour > 23) ||
(starttime_minute < 0) || (starttime_minute > 59) ||
(starttime_second < 0) || (starttime_second > 59))
{
}
else
{
if(strlen(str) > 9)
{
edfwrite_annotation_latin1(hdl, (starttime_second + (starttime_minute * 60) + (starttime_hour * 3600)) * 10000, -1, str + 9);
}
}
}
}
edfwrite_annotation_latin1(hdl, blocks_written * 10000LL, -1LL, "Recording ends");
edfclose_file(hdl);
fclose(dcmfile);
fclose(evtfile);
free(buf1);
free(buf2);
}
void UI_RAW2EDFapp::gobuttonpressed()
{
int i, j, k, r,
hdl,
chns,
sf,
*buf,
datarecords,
tmp,
straightbinary,
samplesize,
skipblocksize,
skipbytes,
skipblockcntr,
bytecntr;
char str[256],
path[MAX_PATH_LENGTH];
double phys_max;
long long d_offset;
FILE *inputfile;
sf = SamplefreqSpinbox->value();
raw2edf_var->sf = sf;
chns = SignalsSpinbox->value();
raw2edf_var->chns = chns;
phys_max = PhysicalMaximumSpinbox->value();
raw2edf_var->phys_max = phys_max;
straightbinary = EncodingCombobox->currentIndex();
raw2edf_var->straightbinary = straightbinary;
samplesize = SampleSizeSpinbox->value();
raw2edf_var->samplesize = samplesize;
d_offset = OffsetSpinbox->value();
raw2edf_var->offset = d_offset;
skipblocksize = skipblocksizeSpinbox->value();
raw2edf_var->skipblocksize = skipblocksize;
skipbytes = skipbytesSpinbox->value();
raw2edf_var->skipbytes = skipbytes;
strcpy(raw2edf_var->phys_dim, PhysicalDimensionLineEdit->text().toLatin1().data());
remove_leading_spaces(raw2edf_var->phys_dim);
remove_trailing_spaces(raw2edf_var->phys_dim);
if(!(strlen(PatientnameLineEdit->text().toLatin1().data())))
{
QMessageBox messagewindow(QMessageBox::Critical, "Invalid input", "Please enter a subjectname.");
messagewindow.exec();
return;
}
if(!(strlen(RecordingLineEdit->text().toLatin1().data())))
{
QMessageBox messagewindow(QMessageBox::Critical, "Invalid input", "Please enter a recording description.");
messagewindow.exec();
return;
}
strcpy(path, QFileDialog::getOpenFileName(0, "Open data file", QString::fromLocal8Bit(recent_opendir), "All files (*)").toLocal8Bit().data());
if(!strcmp(path, ""))
{
return;
}
get_directory_from_path(recent_opendir, path, MAX_PATH_LENGTH);
inputfile = fopeno(path, "rb");
if(inputfile==NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open file for reading.");
messagewindow.exec();
return;
}
remove_extension_from_filename(path);
strcat(path, ".edf");
hdl = edfopen_file_writeonly(path, EDFLIB_FILETYPE_EDFPLUS, chns);
if(hdl<0)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open file for writing.\nedfopen_file_writeonly()");
messagewindow.exec();
fclose(inputfile);
return;
}
for(i=0; i<chns; i++)
{
if(edf_set_samplefrequency(hdl, i, sf))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_samplefrequency()");
messagewindow.exec();
fclose(inputfile);
return;
}
}
if(samplesize == 2)
{
for(i=0; i<chns; i++)
{
if(edf_set_digital_maximum(hdl, i, 32767))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_digital_maximum()");
messagewindow.exec();
fclose(inputfile);
return;
}
}
for(i=0; i<chns; i++)
{
if(edf_set_digital_minimum(hdl, i, -32768))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_digital_minimum()");
messagewindow.exec();
fclose(inputfile);
return;
}
}
}
if(samplesize == 1)
{
for(i=0; i<chns; i++)
{
if(edf_set_digital_maximum(hdl, i, 255))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_digital_maximum()");
messagewindow.exec();
fclose(inputfile);
return;
}
}
for(i=0; i<chns; i++)
{
if(edf_set_digital_minimum(hdl, i, -256))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_digital_minimum()");
messagewindow.exec();
fclose(inputfile);
return;
}
}
}
for(i=0; i<chns; i++)
{
if(edf_set_physical_maximum(hdl, i, phys_max))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_physical_maximum()");
messagewindow.exec();
fclose(inputfile);
return;
}
}
for(i=0; i<chns; i++)
{
if(edf_set_physical_minimum(hdl, i, -phys_max))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_physical_minimum()");
messagewindow.exec();
fclose(inputfile);
return;
}
}
for(i=0; i<chns; i++)
{
if(edf_set_physical_dimension(hdl, i, raw2edf_var->phys_dim))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_physical_dimension()");
messagewindow.exec();
fclose(inputfile);
return;
}
}
for(i=0; i<chns; i++)
{
sprintf(str, "ch. %i", i + 1);
if(edf_set_label(hdl, i, str))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_label()");
messagewindow.exec();
fclose(inputfile);
return;
}
}
if(edf_set_startdatetime(hdl, StartDatetimeedit->date().year(), StartDatetimeedit->date().month(), StartDatetimeedit->date().day(),
StartDatetimeedit->time().hour(), StartDatetimeedit->time().minute(), StartDatetimeedit->time().second()))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_startdatetime()");
messagewindow.exec();
fclose(inputfile);
edfclose_file(hdl);
return;
}
buf = (int *)malloc(sizeof(int) * sf * chns);
if(buf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "malloc()");
messagewindow.exec();
fclose(inputfile);
edfclose_file(hdl);
return;
}
// printf("samplefrequency: %14i Hz\n"
// "channels: %14i\n"
// "physical maximum: %14.6f uV\n"
// "straightbinary: %14i\n"
// "samplesize: %14i byte(s)\n"
// "offset: %14lli bytes\n"
// "skip blocksize: %14i bytes\n"
// "skip bytes: %14i bytes\n\n",
// sf,
// chns,
// phys_max,
// straightbinary,
// samplesize,
// d_offset,
// skipblocksize,
// skipbytes);
fseeko(inputfile, d_offset, SEEK_SET);
datarecords = 0;
union{
int one[1];
signed short two[2];
char four[4];
} var;
skipblockcntr = 0;
bytecntr = 0;
while(1)
{
for(j=0; j<sf; j++)
{
for(k=0; k<chns; k++)
{
// tmp = fgetc(inputfile);
// if(tmp == EOF)
// {
// edfclose_file(hdl);
// fclose(inputfile);
// free(buf);
// return;
// }
//
// tmp += (fgetc(inputfile) * 256);
//
// buf[j + (k * sf)] = tmp - 32768;
if(samplesize == 2)
{
tmp = fgetc(inputfile);
if(tmp == EOF)
{
edfclose_file(hdl);
fclose(inputfile);
free(buf);
return;
}
bytecntr++;
// printf("1: skipblockcntr is %i tmp is %02X bytecntr is %i\n", skipblockcntr, tmp, bytecntr);
if(skipblocksize)
{
if(++skipblockcntr > skipblocksize)
{
for(r=0; r<skipbytes; r++)
{
tmp = fgetc(inputfile);
if(tmp == EOF)
{
edfclose_file(hdl);
fclose(inputfile);
free(buf);
return;
}
// bytecntr++;
// printf("2: skipblockcntr is %i tmp is %02X bytecntr is %i\n", skipblockcntr, tmp, bytecntr);
}
skipblockcntr = 1;
}
}
var.four[0] = tmp;
}
if(samplesize == 1)
{
var.four[0] = 0;
}
tmp = fgetc(inputfile);
if(tmp == EOF)
{
edfclose_file(hdl);
fclose(inputfile);
free(buf);
return;
}
// bytecntr++;
// printf("3: skipblockcntr is %i tmp is %02X bytecntr is %i\n", skipblockcntr, tmp, bytecntr);
if(skipblocksize)
{
if(++skipblockcntr > skipblocksize)
{
for(r=0; r<skipbytes; r++)
{
tmp = fgetc(inputfile);
if(tmp == EOF)
{
edfclose_file(hdl);
fclose(inputfile);
free(buf);
return;
}
bytecntr++;
// printf("4: skipblockcntr is %i tmp is %02X bytecntr is %i\n", skipblockcntr, tmp, bytecntr);
}
skipblockcntr = 1;
}
}
var.four[1] = tmp;
if(straightbinary)
{
var.two[0] -= 32768;
}
if(samplesize == 1)
{
var.two[0] >>= 8;
}
buf[j + (k * sf)] = var.two[0];
}
}
if(edf_blockwrite_digital_samples(hdl, buf))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Write error during conversion.\nedf_blockwrite_digital_samples()");
messagewindow.exec();
edfclose_file(hdl);
fclose(inputfile);
free(buf);
return;
}
datarecords++;
// if(datarecords == 1) break;
}
void UI_BIOSEMI2BDFPLUSwindow::SelectFileButton()
{
int i, j, k,
error,
hdl_in,
hdl_out,
edfsignals,
status_signal=0,
status_samples_in_datarecord=0,
rising_edge,
set_duration,
status[24],
totalSamplesInDatarecord,
*buf,
buf_offset[EDFLIB_MAXSIGNALS],
sf,
new_sf,
samplerate_divider;
char str[2048],
triggerlabel[24][64],
outputfilename[MAX_PATH_LENGTH];
long long datarecords,
status_sample_duration,
trigger_cnt,
progress_steps;
struct edf_hdr_struct hdr;
struct annotationblock *annotlist=NULL;
struct annotationblock *annotation;
for(i=0; i<16; i++)
{
if(!lineEdit1[i]->text().length())
{
sprintf(str, "Trigger Input label %i is empty!", i + 1);
QMessageBox messagewindow(QMessageBox::Critical, "Error", str);
messagewindow.exec();
return;
}
}
for(i=0; i<16; i++)
{
for(j=0; j<16; j++)
{
if(i != j)
{
if(!strcmp(lineEdit1[i]->text().toLocal8Bit().data(), lineEdit1[j]->text().toLocal8Bit().data()))
{
sprintf(str, "Trigger Input labels %i and %i are the same!", i + 1, j + 1);
QMessageBox messagewindow(QMessageBox::Critical, "Error", str);
messagewindow.exec();
return;
}
}
}
}
str[0] = 0;
strcpy(inputpath, QFileDialog::getOpenFileName(0, "Select inputfile", QString::fromLocal8Bit(recent_opendir), "BDF files (*.bdf *.BDF)").toLocal8Bit().data());
if(!strcmp(inputpath, ""))
{
return;
}
get_directory_from_path(recent_opendir, inputpath, MAX_PATH_LENGTH);
error = edfopen_file_readonly(inputpath, &hdr, EDFLIB_DO_NOT_READ_ANNOTATIONS);
if(error < 0)
{
error = hdr.filetype;
switch(error)
{
case EDFLIB_MALLOC_ERROR : strcpy(str, "EDFlib: malloc error.");
break;
case EDFLIB_NO_SUCH_FILE_OR_DIRECTORY : strcpy(str, "EDFlib: no such file or directory.");
break;
case EDFLIB_FILE_CONTAINS_FORMAT_ERRORS : strcpy(str, "EDFlib: file contains format errors.\nOpen the file in EDFbrowser to get more info.");
break;
case EDFLIB_MAXFILES_REACHED : strcpy(str, "EDFlib: maximum amount of files reached.");
break;
case EDFLIB_FILE_READ_ERROR : strcpy(str, "EDFlib: a file read error occurred.");
break;
case EDFLIB_FILE_ALREADY_OPENED : strcpy(str, "EDFlib: file is already opened.");
break;
case EDFLIB_FILETYPE_ERROR : strcpy(str, "EDFlib: filetype error.");
break;
case EDFLIB_FILE_WRITE_ERROR : strcpy(str, "EDFlib: file write error.");
break;
case EDFLIB_NUMBER_OF_SIGNALS_INVALID : strcpy(str, "EDFlib: invalid number of signals.");
break;
case EDFLIB_FILE_IS_DISCONTINUOUS : strcpy(str, "EDFlib: file is discontinuous.");
break;
case EDFLIB_INVALID_READ_ANNOTS_VALUE : strcpy(str, "EDFlib: invalid read annotations argument.");
break;
default : strcpy(str, "EDFlib: unknown error.");
}
QMessageBox messagewindow(QMessageBox::Critical, "Error", str);
messagewindow.exec();
return;
}
hdl_in = hdr.handle;
/////////////////// check file /////////////////////////////////////////////
if(hdr.filetype == EDFLIB_FILETYPE_BDFPLUS)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Selected file is already a BDF-plus file.");
messagewindow.exec();
edfclose_file(hdl_in);
return;
}
if(hdr.filetype != EDFLIB_FILETYPE_BDF)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Selected file is not a BDF file.");
messagewindow.exec();
edfclose_file(hdl_in);
return;
}
if(hdr.datarecord_duration != EDFLIB_TIME_DIMENSION)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Datarecord duration of inputfile must be 1 second.");
messagewindow.exec();
edfclose_file(hdl_in);
return;
}
edfsignals = hdr.edfsignals;
if(edfsignals < 1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There are no signals in the selected file.");
messagewindow.exec();
edfclose_file(hdl_in);
return;
}
sf = hdr.signalparam[0].smp_in_datarecord;
for(i=1; i<edfsignals; i++)
{
if(hdr.signalparam[i].smp_in_datarecord != sf)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "All signals must have the same samplefrequency.");
messagewindow.exec();
edfclose_file(hdl_in);
return;
}
}
error = 1;
switch(sf)
{
case 16384 : error = 0;
break;
case 8192 : error = 0;
break;
case 4096 : error = 0;
break;
case 2048 : error = 0;
break;
case 1024 : error = 0;
break;
case 512 : error = 0;
break;
case 256 : error = 0;
break;
case 128 : error = 0;
break;
case 64 : error = 0;
break;
case 32 : error = 0;
break;
}
if(error)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Samplefrequency must be 16384, 8192, 4096, 2048, 1024, 512, 256, 128, 64 or 32 Hz.");
messagewindow.exec();
edfclose_file(hdl_in);
return;
}
for(i=0; i<edfsignals; i++)
{
if(!(strcmp(hdr.signalparam[i].label, "Status ")))
{
status_signal = i;
break;
}
}
if(i == edfsignals)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There is no Status signal in the selected file.");
messagewindow.exec();
edfclose_file(hdl_in);
return;
}
totalSamplesInDatarecord = 0;
for(i=0; i<edfsignals; i++)
{
buf_offset[i] = totalSamplesInDatarecord;
if(i == status_signal)
{
status_samples_in_datarecord = hdr.signalparam[i].smp_in_datarecord;
}
totalSamplesInDatarecord += hdr.signalparam[i].smp_in_datarecord;
}
status_sample_duration = EDFLIB_TIME_DIMENSION / (long long)status_samples_in_datarecord;
for(i=0; i<16; i++)
{
strcpy(&triggerlabel[i][0], lineEdit1[i]->text().toUtf8().data());
triggerlabel[i][16] = 0;
}
strcpy(&triggerlabel[16][0], "new epoch");
if(radioButton1->isChecked() == true)
{
rising_edge = 1;
for(i=0; i<16; i++)
{
status[i] = 1;
}
}
else
{
rising_edge = 0;
for(i=0; i<16; i++)
{
status[i] = 0;
}
}
if(checkBox1->isChecked() == true)
{
set_duration = 1;
}
else
{
set_duration = 0;
}
for(i=16; i<24; i++)
{
status[i] = 1;
}
strcpy(outputfilename, inputpath);
remove_extension_from_filename(outputfilename);
strcat(outputfilename, "_+.bdf");
outputpath[0] = 0;
if(recent_savedir[0]!=0)
{
strcpy(outputpath, recent_savedir);
strcat(outputpath, "/");
}
strcat(outputpath, outputfilename);
strcpy(outputpath, QFileDialog::getSaveFileName(0, "Output file", QString::fromLocal8Bit(outputpath), "BDF files (*.bdf *.BDF)").toLocal8Bit().data());
if(!strcmp(outputpath, ""))
{
edfclose_file(hdl_in);
return;
}
get_directory_from_path(recent_savedir, outputpath, MAX_PATH_LENGTH);
if(mainwindow->file_is_opened(outputpath))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Outputfile is already opened in EDFbrowser.\nClose the file and try again.");
messagewindow.exec();
edfclose_file(hdl_in);
return;
}
if(!(strcmp(inputpath, outputpath)))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Inputfile and outputfile are the same.");
messagewindow.exec();
edfclose_file(hdl_in);
return;
}
hdl_out = edfopen_file_writeonly(outputpath, EDFLIB_FILETYPE_BDFPLUS, edfsignals);
if(hdl_out < 0)
{
switch(hdl_out)
{
case EDFLIB_MALLOC_ERROR : strcpy(str, "EDFlib: malloc error.");
break;
case EDFLIB_NO_SUCH_FILE_OR_DIRECTORY : strcpy(str, "EDFlib: no such file or directory.");
break;
case EDFLIB_MAXFILES_REACHED : strcpy(str, "EDFlib: maximum amount of files reached.");
break;
case EDFLIB_FILE_READ_ERROR : strcpy(str, "EDFlib: a file read error occurred.");
break;
case EDFLIB_FILE_ALREADY_OPENED : strcpy(str, "EDFlib: file is already opened.");
break;
case EDFLIB_FILETYPE_ERROR : strcpy(str, "EDFlib: filetype error.");
break;
case EDFLIB_FILE_WRITE_ERROR : strcpy(str, "EDFlib: file write error.");
break;
case EDFLIB_NUMBER_OF_SIGNALS_INVALID : strcpy(str, "EDFlib: invalid number of signals.");
break;
default : strcpy(str, "EDFlib: unknown error.");
}
QMessageBox messagewindow(QMessageBox::Critical, "Error", str);
messagewindow.exec();
edfclose_file(hdl_in);
return;
}
/////////////////// copy header /////////////////////////////////////////////
for(i=0; i<edfsignals; i++)
{
edf_set_samplefrequency(hdl_out, i, hdr.signalparam[i].smp_in_datarecord);
edf_set_physical_maximum(hdl_out, i, hdr.signalparam[i].phys_max);
edf_set_physical_minimum(hdl_out, i, hdr.signalparam[i].phys_min);
edf_set_digital_maximum(hdl_out, i, hdr.signalparam[i].dig_max);
edf_set_digital_minimum(hdl_out, i, hdr.signalparam[i].dig_min);
edf_set_label(hdl_out, i, hdr.signalparam[i].label);
edf_set_prefilter(hdl_out, i, hdr.signalparam[i].prefilter);
edf_set_transducer(hdl_out, i, hdr.signalparam[i].transducer);
edf_set_physical_dimension(hdl_out, i, hdr.signalparam[i].physdimension);
}
edf_set_startdatetime(hdl_out, hdr.startdate_year, hdr.startdate_month, hdr.startdate_day, hdr.starttime_hour, hdr.starttime_minute, hdr.starttime_second);
edf_set_patientname(hdl_out, hdr.patient);
edf_set_recording_additional(hdl_out, hdr.recording);
/////////////////// collect triggers /////////////////////////////////////////////
buf = (int *)malloc(sizeof(int) * status_samples_in_datarecord);
if(buf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error (buf).");
messagewindow.exec();
edfclose_file(hdl_in);
edfclose_file(hdl_out);
return;
}
QProgressDialog progress("Collecting triggers...", "Abort", 0, (int)hdr.datarecords_in_file);
progress.setWindowModality(Qt::WindowModal);
progress.setMinimumDuration(200);
progress_steps = hdr.datarecords_in_file / 100LL;
if(progress_steps < 1LL)
{
progress_steps = 1LL;
}
trigger_cnt = 0;
for(datarecords = 0LL; datarecords < hdr.datarecords_in_file; datarecords++)
{
if(trigger_cnt >= ((hdr.datarecords_in_file * 32) - 2))
{
break;
}
if(trigger_cnt >= 100000)
{
break;
}
if(!(datarecords % progress_steps))
{
progress.setValue((int)datarecords);
qApp->processEvents();
if(progress.wasCanceled())
{
edfclose_file(hdl_in);
edfclose_file(hdl_out);
free(buf);
edfplus_annotation_delete_list(&annotlist);
return;
}
}
if(edfread_digital_samples(hdl_in, status_signal, status_samples_in_datarecord, buf) < 0)
{
progress.reset();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "A read error occurred during the collection of triggers.");
messagewindow.exec();
edfclose_file(hdl_in);
edfclose_file(hdl_out);
free(buf);
edfplus_annotation_delete_list(&annotlist);
return;
}
for(i=0; i<status_samples_in_datarecord; i++)
{
for(j=0; j<17; j++)
{
if(((buf[i] & (1 << j)) && !status[j]) || (!(buf[i] & (1 << j)) && status[j])) // rising or falling edge detected
{
if(status[j]) // falling edge detected
{
if((!rising_edge) && (j < 16))
{
annotation = (struct annotationblock *)calloc(1, sizeof(struct annotationblock));
if(annotation == NULL)
{
progress.reset();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error (annotation).");
messagewindow.exec();
edfclose_file(hdl_in);
edfclose_file(hdl_out);
free(buf);
edfplus_annotation_delete_list(&annotlist);
return;
}
annotation->onset = (datarecords * EDFLIB_TIME_DIMENSION) + ((long long)i * status_sample_duration);
annotation->onset += hdr.starttime_subsecond;
strcpy(annotation->annotation, triggerlabel[j]);
edfplus_annotation_add_item(&annotlist, annotation);
trigger_cnt++;
}
else
{
if(set_duration)
{
k = edfplus_annotation_count(&annotlist);
for(; k>0; k--)
{
annotation = edfplus_annotation_item(&annotlist, k - 1);
if(annotation == NULL)
{
break;
}
if(!strcmp(annotation->annotation, triggerlabel[j]))
{
sprintf(str, "%.4f", (double)((datarecords * EDFLIB_TIME_DIMENSION) + ((long long)i * status_sample_duration) - annotation->onset) / (double)EDFLIB_TIME_DIMENSION);
str[15] = 0;
strcpy(annotation->duration, str);
break;
}
}
}
}
status[j] = 0;
}
else // rising edge detected
{
if(rising_edge || (j == 16))
{
annotation = (struct annotationblock *)calloc(1, sizeof(struct annotationblock));
if(annotation == NULL)
{
progress.reset();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error (annotation).");
messagewindow.exec();
edfclose_file(hdl_in);
edfclose_file(hdl_out);
free(buf);
edfplus_annotation_delete_list(&annotlist);
return;
}
annotation->onset = (datarecords * EDFLIB_TIME_DIMENSION) + ((long long)i * status_sample_duration);
annotation->onset += hdr.starttime_subsecond;
strcpy(annotation->annotation, triggerlabel[j]);
edfplus_annotation_add_item(&annotlist, annotation);
trigger_cnt++;
}
else
{
if(set_duration)
{
k = edfplus_annotation_count(&annotlist);
for(; k>0; k--)
{
annotation = edfplus_annotation_item(&annotlist, k - 1);
if(annotation == NULL)
{
break;
}
if(!strcmp(annotation->annotation, triggerlabel[j]))
{
sprintf(str, "%.4f", (double)((datarecords * EDFLIB_TIME_DIMENSION) + ((long long)i * status_sample_duration) - annotation->onset) / (double)EDFLIB_TIME_DIMENSION);
str[15] = 0;
strcpy(annotation->duration, str);
break;
}
}
}
}
status[j] = 1;
}
}
}
}
}
edfwrite_annotation_latin1(hdl_out, 0LL, -1LL, "Recording starts");
j = edfplus_annotation_count(&annotlist);
for(i=0; i<j; i++)
{
annotation = edfplus_annotation_item(&annotlist, i);
if(annotation->duration[0] == 0)
{
edfwrite_annotation_utf8(hdl_out, annotation->onset / 1000LL, -1LL, annotation->annotation);
}
else
{
edfwrite_annotation_utf8(hdl_out, annotation->onset / 1000LL, (long long)(atof(annotation->duration) * 10000.0), annotation->annotation);
}
}
free(buf);
edfwrite_annotation_latin1(hdl_out, hdr.datarecords_in_file * 10000LL, -1LL, "Recording ends");
/////////////////// choose datarecord duration /////////////////////////////////////////////
samplerate_divider = 1;
i = edfplus_annotation_count(&annotlist);
edfplus_annotation_delete_list(&annotlist);
annotlist = NULL;
if(i % 2)
{
i++;
}
i += 2;
while(i > hdr.datarecords_in_file)
{
samplerate_divider *= 2;
i /= 2;
if(samplerate_divider == 32)
{
break;
}
}
if(samplerate_divider > 1)
{
for(i=0; i<edfsignals; i++)
{
edf_set_samplefrequency(hdl_out, i, hdr.signalparam[i].smp_in_datarecord / samplerate_divider);
}
if(edf_set_datarecord_duration(hdl_out, 100000 / samplerate_divider) == -1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_datarecord_duration() returned an error.");
messagewindow.exec();
edfclose_file(hdl_in);
edfclose_file(hdl_out);
return;
}
}
new_sf = sf / samplerate_divider;
/////////////////// start conversion /////////////////////////////////////////////
buf = (int *)malloc(sizeof(int) * totalSamplesInDatarecord);
if(buf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error (buf).");
messagewindow.exec();
edfclose_file(hdl_in);
edfclose_file(hdl_out);
return;
}
edfrewind(hdl_in, status_signal);
progress.setLabelText("Converting...");
progress.setValue(0);
for(datarecords = 0LL; datarecords < hdr.datarecords_in_file; datarecords++)
{
if(!(datarecords % progress_steps))
{
progress.setValue((int)datarecords);
qApp->processEvents();
if(progress.wasCanceled())
{
edfclose_file(hdl_in);
edfclose_file(hdl_out);
free(buf);
return;
}
}
for(i=0; i<edfsignals; i++)
{
if(edfread_digital_samples(hdl_in, i, hdr.signalparam[i].smp_in_datarecord, buf + buf_offset[i]) < 0)
{
progress.reset();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "A read error occurred during the conversion.");
messagewindow.exec();
edfclose_file(hdl_in);
edfclose_file(hdl_out);
free(buf);
return;
}
}
for(j=0; j<samplerate_divider; j++)
{
for(i=0; i<edfsignals; i++)
{
if(edfwrite_digital_samples(hdl_out, buf + buf_offset[i] + (j * new_sf)) < 0)
{
progress.reset();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "A write error occurred during the conversion.");
messagewindow.exec();
edfclose_file(hdl_in);
edfclose_file(hdl_out);
free(buf);
return;
}
}
}
}
QApplication::setOverrideCursor(Qt::WaitCursor);
edfclose_file(hdl_in);
edfclose_file(hdl_out);
free(buf);
QApplication::restoreOverrideCursor();
progress.reset();
#ifdef Q_WS_WIN
snprintf(str, 2048, "Done. Converted %I64d input trigger events to BDF+ annotations.\n"
"\nBDF+ file is located at %s", trigger_cnt, outputpath);
#else
snprintf(str, 2048, "Done. Converted %lli input trigger events to BDF+ annotations.\n"
"\nBDF+ file is located at %s", trigger_cnt, outputpath);
#endif
QMessageBox messagewindow(QMessageBox::Information, "Ready", str);
messagewindow.setIconPixmap(QPixmap(":/images/ok.png"));
messagewindow.exec();
}
int main(int argc, char *argv[])
{
int i, j,
hdl,
chns=1,
smp_freq=8192,
fileduration=300,
linear=1;
double buf[smp_freq],
q,
sine_1,
startfreq=10.0,
stopfreq=4095.0,
freqspan,
freq;
long long samples,
sampleswritten;
char str[256];
#ifdef BDF_FORMAT
hdl = edfopen_file_writeonly("freq_sweep.bdf", EDFLIB_FILETYPE_BDFPLUS, chns);
#else
hdl = edfopen_file_writeonly("freq_sweep.edf", EDFLIB_FILETYPE_EDFPLUS, chns);
#endif
if(hdl<0)
{
printf("error: edfopen_file_writeonly()\n");
return(1);
}
for(i=0; i<chns; i++)
{
if(edf_set_samplefrequency(hdl, i, smp_freq))
{
printf("error: edf_set_samplefrequency()\n");
return(1);
}
}
#ifdef BDF_FORMAT
for(i=0; i<chns; i++)
{
if(edf_set_digital_maximum(hdl, i, 8388607))
{
printf("error: edf_set_digital_maximum()\n");
return(1);
}
}
for(i=0; i<chns; i++)
{
if(edf_set_digital_minimum(hdl, i, -8388608))
{
printf("error: edf_set_digital_minimum()\n");
return(1);
}
}
#else
for(i=0; i<chns; i++)
{
if(edf_set_digital_maximum(hdl, i, 32767))
{
printf("error: edf_set_digital_maximum()\n");
return(1);
}
}
for(i=0; i<chns; i++)
{
if(edf_set_digital_minimum(hdl, i, -32768))
{
printf("error: edf_set_digital_minimum()\n");
return(1);
}
}
#endif
for(i=0; i<chns; i++)
{
if(edf_set_physical_maximum(hdl, i, 400.0))
{
printf("error: edf_set_physical_maximum()\n");
return(1);
}
}
for(i=0; i<chns; i++)
{
if(edf_set_physical_minimum(hdl, i, -400.0))
{
printf("error: edf_set_physical_minimum()\n");
return(1);
}
}
for(i=0; i<chns; i++)
{
if(edf_set_physical_dimension(hdl, i, "uV"))
{
printf("error: edf_set_physical_dimension()\n");
return(1);
}
}
if(edf_set_label(hdl, 0, "sweep"))
{
printf("error: edf_set_label()\n");
return(1);
}
if(edf_set_equipment(hdl, "Software generated file"))
{
printf("edf_set_equipment()\n");
return(1);
}
if(linear)
{
sprintf(str, "Linear frequency sweep from %fHz to %fHz", startfreq, stopfreq);
}
else
{
sprintf(str, "Logarithmic frequency sweep from %fHz to %fHz", startfreq, stopfreq);
}
remove_trailing_zeros(str);
edf_set_patientname(hdl, str);
edfwrite_annotation_latin1(hdl, 0LL, -1LL, "Recording starts");
sine_1 = 0.0;
sampleswritten = 0;
samples = fileduration * (long long)smp_freq;
freqspan = stopfreq - startfreq;
for(j=0; j<fileduration; j++)
{
for(i=0; i<smp_freq; i++)
{
q = M_PI * 2.0;
q /= (smp_freq / freq);
sine_1 += q;
q = sin(sine_1);
q *= 200.0;
buf[i] = q;
if(linear)
{
freq = startfreq + (freqspan * ((double)sampleswritten / (double)samples));
}
else
{
// freq = exp10((((double)sampleswritten / (double)samples)) * log10(stopfreq));
freq = exp10(((((startfreq / stopfreq) * ((stopfreq / freqspan) * samples)) + sampleswritten) / ((stopfreq / freqspan) * samples)) * log10(stopfreq));
}
sampleswritten++;
}
if(edfwrite_physical_samples(hdl, buf))
{
printf("error: edfwrite_physical_samples()\n");
return(1);
}
if(!(j%10))
{
sprintf(str, "%fHz", freq);
remove_trailing_zeros(str);
edfwrite_annotation_latin1(hdl, j * 10000LL, -1LL, str);
}
}
sprintf(str, "%fHz", freq);
remove_trailing_zeros(str);
edfwrite_annotation_latin1(hdl, j * 10000LL, -1LL, str);
edfwrite_annotation_latin1(hdl, fileduration * 10000LL, -1LL, "Recording ends");
edfclose_file(hdl);
return(0);
}
void UI_AverageCurveWindow::export_edf(void)
{
int i, j, k, p,
type,
edf_hdl,
smp_per_record,
datarecords,
smpls_left;
char path[MAX_PATH_LENGTH],
str[512];
double *buf,
frequency,
frequency2;
smp_per_record = signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].smp_per_record;
datarecords = avg_samples_on_screen / smp_per_record;
smpls_left = avg_samples_on_screen % smp_per_record;
path[0] = 0;
if(mainwindow->recent_savedir[0]!=0)
{
strcpy(path, mainwindow->recent_savedir);
strcat(path, "/");
}
get_filename_from_path(path + strlen(path), signalcomp->edfhdr->filename, 512);
remove_extension_from_filename(path);
sprintf(path + strlen(path), " averaging %s %i triggers [%s]",
signalcomp->signallabel,
avg_cnt,
avg_annotation);
if(signalcomp->edfhdr->edf)
{
strcat(path, ".edf");
strcpy(path, QFileDialog::getSaveFileName(0, "Save as EDF", QString::fromLocal8Bit(path), "EDF files (*.edf *.EDF)").toLocal8Bit().data());
}
else
{
strcat(path, ".bdf");
strcpy(path, QFileDialog::getSaveFileName(0, "Save as BDF", QString::fromLocal8Bit(path), "BDF files (*.bdf *.BDF)").toLocal8Bit().data());
}
if(!strcmp(path, ""))
{
return;
}
get_directory_from_path(mainwindow->recent_savedir, path, MAX_PATH_LENGTH);
if(signalcomp->edfhdr->edf)
{
edf_hdl = edfopen_file_writeonly(path, EDFLIB_FILETYPE_EDFPLUS, 1);
}
else
{
edf_hdl = edfopen_file_writeonly(path, EDFLIB_FILETYPE_BDFPLUS, 1);
}
if(edf_hdl < 0)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open output file for writing.");
messagewindow.exec();
return;
}
edf_set_samplefrequency(edf_hdl, 0, smp_per_record);
if(edf_set_datarecord_duration(edf_hdl, signalcomp->edfhdr->long_data_record_duration / 100LL))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Datarecordduration out of range.");
messagewindow.exec();
return;
}
if(signalcomp->edfhdr->edf)
{
edf_set_digital_maximum(edf_hdl, 0, 32767);
edf_set_digital_minimum(edf_hdl, 0, -32768);
}
else
{
edf_set_digital_maximum(edf_hdl, 0, 8388607);
edf_set_digital_minimum(edf_hdl, 0, -8388608);
}
edf_set_physical_maximum(edf_hdl, 0, avg_max_value);
edf_set_physical_minimum(edf_hdl, 0, avg_min_value);
edf_set_label(edf_hdl, 0, signalcomp->signallabel);
edf_set_physical_dimension(edf_hdl, 0, signalcomp->physdimension);
p = 0;
for(j=0; j<signalcomp->fidfilter_cnt; j++)
{
type = signalcomp->fidfilter_type[j];
frequency = signalcomp->fidfilter_freq[j];
frequency2 = signalcomp->fidfilter_freq2[j];
if(type == 0)
{
p += sprintf(str + p, "HP:%f", frequency);
}
if(type == 1)
{
p += sprintf(str + p, "LP:%f", frequency);
}
if(type == 2)
{
p += sprintf(str + p, "N:%f", frequency);
}
if(type == 3)
{
p += sprintf(str + p, "BP:%f", frequency);
}
if(type == 4)
{
p += sprintf(str + p, "BS:%f", frequency);
}
for(k=(p-1); k>0; k--)
{
if(str[k]!='0') break;
}
if(str[k]=='.') str[k] = 0;
else str[k+1] = 0;
p = strlen(str);
if((type == 3) || (type == 4))
{
p += sprintf(str + p, "-%f", frequency2);
for(k=(p-1); k>0; k--)
{
if(str[k]!='0') break;
}
if(str[k]=='.') str[k] = 0;
else str[k+1] = 0;
}
strcat(str, "Hz ");
p = strlen(str);
if(p>80) break;
}
for(j=0; j<signalcomp->ravg_filter_cnt; j++)
{
if(signalcomp->ravg_filter_type[j] == 0)
{
p += sprintf(str + p, "HP:%iSmpls ", signalcomp->ravg_filter[j]->size);
}
if(signalcomp->ravg_filter_type[j] == 1)
{
p += sprintf(str + p, "LP:%iSmpls ", signalcomp->ravg_filter[j]->size);
}
p = strlen(str);
if(p>80) break;
}
strcat(str, signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].prefilter);
edf_set_prefilter(edf_hdl, 0, str);
edf_set_transducer(edf_hdl, 0, signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].transducer);
if((signalcomp->edfhdr->edfplus) || (signalcomp->edfhdr->bdfplus))
{
edf_set_patientname(edf_hdl, signalcomp->edfhdr->plus_patient_name);
sprintf(str, "%i triggers \"%s\" averaged. %s", avg_cnt, avg_annotation, signalcomp->edfhdr->plus_recording_additional);
edf_set_recording_additional(edf_hdl, str);
edf_set_patientcode(edf_hdl, signalcomp->edfhdr->plus_patientcode);
if(signalcomp->edfhdr->plus_gender[0] == 'M')
{
edf_set_gender(edf_hdl, 1);
}
if(signalcomp->edfhdr->plus_gender[0] == 'F')
{
edf_set_gender(edf_hdl, 0);
}
edf_set_patient_additional(edf_hdl, signalcomp->edfhdr->plus_patient_additional);
edf_set_admincode(edf_hdl, signalcomp->edfhdr->plus_admincode);
edf_set_technician(edf_hdl, signalcomp->edfhdr->plus_technician);
edf_set_equipment(edf_hdl, signalcomp->edfhdr->plus_equipment);
}
else
{
edf_set_patientname(edf_hdl, signalcomp->edfhdr->patient);
sprintf(str, "%i triggers \"%s\" averaged. %s", avg_cnt, avg_annotation, signalcomp->edfhdr->recording);
edf_set_recording_additional(edf_hdl, str);
}
for(i=0; i<datarecords; i++)
{
edfwrite_physical_samples(edf_hdl, avgbuf + (i * smp_per_record));
}
if(smpls_left)
{
buf = (double *)calloc(1, smp_per_record * sizeof(double));
if(buf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error (buf).");
messagewindow.exec();
}
else
{
for(i=0; i<smpls_left; i++)
{
buf[i] = avgbuf[(datarecords * smp_per_record) + i];
}
edfwrite_physical_samples(edf_hdl, buf);
free(buf);
}
}
edfwrite_annotation_latin1(edf_hdl,
(avg_period * 10000.0) / (double)avg_trigger_position_ratio,
-1,
avg_annotation);
edfclose_file(edf_hdl);
}
void UI_MIT2EDFwindow::SelectFileButton()
{
FILE *header_inputfile=NULL,
*data_inputfile=NULL,
*annot_inputfile=NULL;
int i, j, p, len, hdl, *buf;
char header_filename[MAX_PATH_LENGTH],
txt_string[2048],
edf_filename[MAX_PATH_LENGTH],
data_filename[MAX_PATH_LENGTH],
annot_filename[MAX_PATH_LENGTH],
filename_x[MAX_PATH_LENGTH],
scratchpad[4096],
*charpntr;
unsigned char a_buf[128];
long long filesize;
pushButton1->setEnabled(false);
strcpy(header_filename, QFileDialog::getOpenFileName(0, "Select inputfile", QString::fromLocal8Bit(recent_opendir), "MIT header files (*.hea *.HEA)").toLocal8Bit().data());
if(!strcmp(header_filename, ""))
{
pushButton1->setEnabled(true);
return;
}
get_directory_from_path(recent_opendir, header_filename, MAX_PATH_LENGTH);
header_inputfile = fopeno(header_filename, "rb");
if(header_inputfile==NULL)
{
snprintf(txt_string, 2048, "Can not open file %s for reading.\n", header_filename);
textEdit1->append(QString::fromLocal8Bit(txt_string));
pushButton1->setEnabled(true);
return;
}
get_filename_from_path(filename_x, header_filename, MAX_PATH_LENGTH);
snprintf(txt_string, 2048, "Read file: %s", filename_x);
textEdit1->append(QString::fromLocal8Bit(txt_string));
remove_extension_from_filename(filename_x);
charpntr = fgets(scratchpad, 4095, header_inputfile);
if(charpntr == NULL)
{
textEdit1->append("Can not read header file. (error 1)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
len = strlen(charpntr);
if(len < 6)
{
textEdit1->append("Can not read header file. (error 2)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
for(i=0; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == len)
{
textEdit1->append("Can not read header file. (error 3)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
if(strcmp(charpntr, filename_x))
{
textEdit1->append("Can not read header file. (error 4)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
p = ++i;
for(; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == p)
{
textEdit1->append("Can not read header file. (error 5)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
mit_hdr.chns = atoi(charpntr + p);
if(mit_hdr.chns < 1)
{
textEdit1->append("Error, number of signals is less than one. (error 6)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
if(mit_hdr.chns > MAXSIGNALS)
{
textEdit1->append("Error, Too many signals in header. (error 7)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
p = ++i;
for(; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == p)
{
textEdit1->append("Can not read header file. (error 8)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
mit_hdr.sf = atoi(charpntr + p);
if(mit_hdr.sf < 1)
{
textEdit1->append("Error, samplefrequency is less than 1 Hz. (error 9)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
if(mit_hdr.sf > 100000)
{
textEdit1->append("Error, samplefrequency is more than 100000 Hz. (error 10)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
mit_hdr.smp_period = 1000000000LL / mit_hdr.sf;
strcat(filename_x, ".dat");
for(j=0; j<mit_hdr.chns; j++)
{
mit_hdr.adc_gain[j] = 200.0;
mit_hdr.adc_resolution[j] = 12;
mit_hdr.adc_zero[j] = 0;
mit_hdr.init_val[j] = 0;
sprintf(mit_hdr.label[j], "chan. %i", j + 1);
charpntr = fgets(scratchpad, 4095, header_inputfile);
if(charpntr == NULL)
{
textEdit1->append("Can not read header file. (error 11)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
len = strlen(charpntr);
if(len < 6)
{
textEdit1->append("Can not read header file. (error 12)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
for(i=0; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == len)
{
textEdit1->append("Can not read header file. (error 13)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
if(strcmp(charpntr, filename_x))
{
textEdit1->append("Error, filenames are different. (error 14)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
p = ++i;
for(; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == len)
{
textEdit1->append("Can not read header file. (error 15)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
mit_hdr.format[j] = atoi(charpntr + p);
if((mit_hdr.format[j] != 212) && (mit_hdr.format[j] != 16))
{
snprintf(txt_string, 2048, "Error, unsupported format: %i (error 16)\n", mit_hdr.format[j]);
textEdit1->append(txt_string);
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
if(j>0)
{
if(mit_hdr.format[j] != mit_hdr.format[0])
{
textEdit1->append("Error, different formats in the same file. (error 17)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
}
p = ++i;
for(; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == p)
{
continue;
}
mit_hdr.adc_gain[j] = atoi(charpntr + p);
p = ++i;
for(; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == p)
{
continue;
}
mit_hdr.adc_resolution[j] = atoi(charpntr + p);
p = ++i;
for(; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == p)
{
continue;
}
mit_hdr.adc_zero[j] = atoi(charpntr + p);
p = ++i;
for(; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == p)
{
continue;
}
mit_hdr.init_val[j] = atoi(charpntr + p);
p = ++i;
for(; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == p)
{
continue;
}
// skip
p = ++i;
for(; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == p)
{
continue;
}
// skip
p = ++i;
for(; i<len; i++)
{
if((charpntr[i] == '\n') || (charpntr[i] == '\r'))
{
charpntr[i] = 0;
break;
}
}
if(i == p)
{
continue;
}
strncpy(mit_hdr.label[j], charpntr + p, 16);
mit_hdr.label[j][16] = 0;
}
fclose(header_inputfile);
strcpy(data_filename, header_filename);
remove_extension_from_filename(data_filename);
strcpy(edf_filename, data_filename);
strcpy(annot_filename, data_filename);
strcat(data_filename, ".dat");
strcat(edf_filename, ".edf");
strcat(annot_filename, ".atr");
data_inputfile = fopeno(data_filename, "rb");
if(data_inputfile==NULL)
{
snprintf(txt_string, 2048, "Can not open file %s for reading.\n", data_filename);
textEdit1->append(QString::fromLocal8Bit(txt_string));
pushButton1->setEnabled(true);
return;
}
fseeko(data_inputfile, 0LL, SEEK_END);
filesize = ftello(data_inputfile);
if(filesize < (mit_hdr.chns * mit_hdr.sf * 45 / 10))
{
textEdit1->append("Error, .dat filesize is too small.\n");
fclose(data_inputfile);
pushButton1->setEnabled(true);
return;
}
mit_hdr.sf_div = 1;
mit_hdr.sf_block = mit_hdr.sf;
if(!(mit_hdr.sf % 10))
{
mit_hdr.sf_div = 10;
mit_hdr.sf_block /= mit_hdr.sf_div;
}
else if(!(mit_hdr.sf % 8))
{
mit_hdr.sf_div = 8;
mit_hdr.sf_block /= mit_hdr.sf_div;
}
else if(!(mit_hdr.sf % 4))
{
mit_hdr.sf_div = 4;
mit_hdr.sf_block /= mit_hdr.sf_div;
}
else if(!(mit_hdr.sf % 2))
{
mit_hdr.sf_div = 2;
mit_hdr.sf_block /= mit_hdr.sf_div;
}
hdl = edfopen_file_writeonly(edf_filename, EDFLIB_FILETYPE_EDFPLUS, mit_hdr.chns);
if(hdl<0)
{
snprintf(txt_string, 2048, "Can not open file %s for writing.\n", edf_filename);
textEdit1->append(QString::fromLocal8Bit(txt_string));
fclose(data_inputfile);
pushButton1->setEnabled(true);
return;
}
for(i=0; i<mit_hdr.chns; i++)
{
if(edf_set_samplefrequency(hdl, i, mit_hdr.sf_block))
{
textEdit1->append("Error: edf_set_samplefrequency()\n");
fclose(data_inputfile);
edfclose_file(hdl);
pushButton1->setEnabled(true);
return;
}
}
for(i=0; i<mit_hdr.chns; i++)
{
if(edf_set_digital_minimum(hdl, i, -32768))
{
textEdit1->append("Error: edf_set_digital_minimum()\n");
fclose(data_inputfile);
edfclose_file(hdl);
pushButton1->setEnabled(true);
return;
}
}
for(i=0; i<mit_hdr.chns; i++)
{
if(edf_set_digital_maximum(hdl, i, 32767))
{
textEdit1->append("Error: edf_set_digital_maximum()\n");
fclose(data_inputfile);
edfclose_file(hdl);
pushButton1->setEnabled(true);
return;
}
}
for(i=0; i<mit_hdr.chns; i++)
{
if(edf_set_label(hdl, i, mit_hdr.label[i]))
{
textEdit1->append("Error: edf_set_label()\n");
fclose(data_inputfile);
edfclose_file(hdl);
pushButton1->setEnabled(true);
return;
}
}
for(i=0; i<mit_hdr.chns; i++)
{
if(edf_set_physical_dimension(hdl, i, "uV"))
{
textEdit1->append("Error: edf_set_physical_dimension()\n");
fclose(data_inputfile);
edfclose_file(hdl);
pushButton1->setEnabled(true);
return;
}
if(edf_set_physical_maximum(hdl, i, (double)((32767 - mit_hdr.adc_zero[i]) * 1000) / mit_hdr.adc_gain[i]))
{
textEdit1->append("Error: edf_set_physical_maximum()\n");
fclose(data_inputfile);
edfclose_file(hdl);
pushButton1->setEnabled(true);
return;
}
if(edf_set_physical_minimum(hdl, i, (double)((-32768 - mit_hdr.adc_zero[i]) * 1000) / mit_hdr.adc_gain[i]))
{
textEdit1->append("Error: edf_set_physical_minimum()\n");
fclose(data_inputfile);
edfclose_file(hdl);
pushButton1->setEnabled(true);
return;
}
}
if(edf_set_datarecord_duration(hdl, 100000 / mit_hdr.sf_div))
{
textEdit1->append("Error: edf_set_datarecord_duration()\n");
fclose(data_inputfile);
edfclose_file(hdl);
pushButton1->setEnabled(true);
return;
}
buf = (int *)malloc(mit_hdr.sf_block * mit_hdr.chns * sizeof(int));
if(buf == NULL)
{
textEdit1->append("Malloc() error (buf)\n");
fclose(data_inputfile);
edfclose_file(hdl);
pushButton1->setEnabled(true);
return;
}
/////////////////// Start conversion //////////////////////////////////////////
int k, blocks, tmp1, tmp2;
fseeko(data_inputfile, 0LL, SEEK_SET);
blocks = filesize / (mit_hdr.sf_block * mit_hdr.chns);
QProgressDialog progress("Converting digitized signals ...", "Abort", 0, blocks);
progress.setWindowModality(Qt::WindowModal);
progress.setMinimumDuration(200);
if(mit_hdr.format[0] == 212)
{
blocks *= 10;
blocks /= 15;
progress.setMaximum(blocks);
for(k=0; k<blocks; k++)
{
if(!(k % 100))
{
progress.setValue(k);
qApp->processEvents();
if(progress.wasCanceled() == true)
{
textEdit1->append("Conversion aborted by user.\n");
fclose(data_inputfile);
edfclose_file(hdl);
free(buf);
pushButton1->setEnabled(true);
return;
}
}
for(i=0; i<mit_hdr.sf_block; i++)
{
for(j=0; j<mit_hdr.chns; j++)
{
if(j % 2)
{
tmp1 = fgetc(data_inputfile);
tmp2 = fgetc(data_inputfile);
if(tmp2 == EOF)
{
goto OUT;
}
buf[j * mit_hdr.sf_block + i] = (tmp1 & 0xf0) << 4;
buf[j * mit_hdr.sf_block + i] += tmp2;
if(buf[j * mit_hdr.sf_block + i] & 0x800)
{
buf[j * mit_hdr.sf_block + i] |= 0xfffff000;
}
}
else
{
tmp1 = fgetc(data_inputfile);
tmp2 = fgetc(data_inputfile);
buf[j * mit_hdr.sf_block + i] = (tmp2 & 0x0f) << 8;
buf[j * mit_hdr.sf_block + i] += tmp1;
if(buf[j * mit_hdr.sf_block + i] & 0x800)
{
buf[j * mit_hdr.sf_block + i] |= 0xfffff000;
}
fseeko(data_inputfile, -1LL, SEEK_CUR);
}
}
}
if(edf_blockwrite_digital_samples(hdl, buf))
{
progress.reset();
textEdit1->append("A write error occurred during conversion.\n");
fclose(data_inputfile);
edfclose_file(hdl);
free(buf);
pushButton1->setEnabled(true);
return;
}
}
}
if(mit_hdr.format[0] == 16)
{
blocks /= 2;
progress.setMaximum(blocks);
for(k=0; k<blocks; k++)
{
if(!(k % 100))
{
progress.setValue(k);
qApp->processEvents();
if(progress.wasCanceled() == true)
{
textEdit1->append("Conversion aborted by user.\n");
fclose(data_inputfile);
edfclose_file(hdl);
free(buf);
pushButton1->setEnabled(true);
return;
}
}
for(i=0; i<mit_hdr.sf_block; i++)
{
for(j=0; j<mit_hdr.chns; j++)
{
tmp1 = fgetc(data_inputfile);
if(tmp1 == EOF)
{
goto OUT;
}
tmp1 += (fgetc(data_inputfile) << 8);
if(tmp1 & 0x8000)
{
tmp1 |= 0xffff0000;
}
buf[j * mit_hdr.sf_block + i] = tmp1;
}
}
if(edf_blockwrite_digital_samples(hdl, buf))
{
progress.reset();
textEdit1->append("A write error occurred during conversion.\n");
fclose(data_inputfile);
edfclose_file(hdl);
free(buf);
pushButton1->setEnabled(true);
return;
}
}
}
OUT:
progress.reset();
qApp->processEvents();
/////////////////// End conversion //////////////////////////////////////////
fclose(data_inputfile);
free(buf);
int annot_code, tc=0, skip;
long long bytes_read;
get_filename_from_path(filename_x, annot_filename, MAX_PATH_LENGTH);
annot_inputfile = fopeno(annot_filename, "rb");
if(annot_inputfile==NULL)
{
remove_extension_from_filename(annot_filename);
strcat(annot_filename, ".ari");
annot_inputfile = fopeno(annot_filename, "rb");
}
if(annot_inputfile==NULL)
{
remove_extension_from_filename(annot_filename);
strcat(annot_filename, ".ecg");
annot_inputfile = fopeno(annot_filename, "rb");
}
if(annot_inputfile==NULL)
{
snprintf(txt_string, 2048, "Can not open file %s for reading.\n"
"Annotations can not be included.", filename_x);
textEdit1->append(QString::fromLocal8Bit(txt_string));
}
else
{
snprintf(txt_string, 2048, "Read file: %s", filename_x);
textEdit1->append(QString::fromLocal8Bit(txt_string));
fseeko(annot_inputfile, 0LL, SEEK_END);
filesize = ftello(annot_inputfile);
progress.setLabelText("Converting annotations ...");
progress.setMinimum(0);
progress.setMaximum(filesize);
fseeko(annot_inputfile, 0LL, SEEK_SET);
for(bytes_read=0LL; bytes_read < filesize; bytes_read += 2LL)
{
if(!(bytes_read % 100))
{
progress.setValue(bytes_read);
qApp->processEvents();
if(progress.wasCanceled() == true)
{
textEdit1->append("Conversion aborted by user.\n");
break;
}
}
skip = 0;
if(fread(a_buf, 2, 1, annot_inputfile) != 1)
{
break;
}
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
if(*((unsigned short *)a_buf) == 0) // end of file
{
break;
}
annot_code = a_buf[1] >> 2;
if(annot_code == 59)
{
if(fread(a_buf, 4, 1, annot_inputfile) != 1)
{
break;
}
tc += (*((unsigned short *)a_buf) << 16);
tc += *((unsigned short *)(a_buf + 2));
}
else if(annot_code == 63)
{
skip = *((unsigned short *)a_buf) & 0x3ff;
if(skip % 2) skip++;
}
else if((annot_code >= 0) && (annot_code <= ACMAX))
{
tc += *((unsigned short *)a_buf) & 0x3ff;
#pragma GCC diagnostic warning "-Wstrict-aliasing"
if(annot_code < 42)
{
edfwrite_annotation_latin1(hdl, ((long long)tc * mit_hdr.smp_period) / 100000LL, -1, annotdescrlist[annot_code]);
}
else
{
edfwrite_annotation_latin1(hdl, ((long long)tc * mit_hdr.smp_period) / 100000LL, -1, "user-defined");
}
}
if(skip)
{
if(fseek(annot_inputfile, skip, SEEK_CUR) < 0)
{
break;
}
bytes_read += skip;
}
}
fclose(annot_inputfile);
}
progress.reset();
edfclose_file(hdl);
textEdit1->append("Ready.\n");
pushButton1->setEnabled(true);
}
int main(int argc, char *argv[])
{
int i, j,
hdl,
buf2[SMP_FREQ],
chns;
double buf[SMP_FREQ],
q;
chns = 2;
hdl = edfopen_file_writeonly("sinus.bdf", EDFLIB_FILETYPE_BDFPLUS, chns);
if(hdl<0)
{
printf("error: edfopen_file_writeonly()\n");
return(1);
}
for(i=0; i<chns; i++)
{
if(edf_set_samplefrequency(hdl, i, SMP_FREQ))
{
printf("error: edf_set_samplefrequency()\n");
return(1);
}
}
for(i=0; i<chns; i++)
{
if(edf_set_physical_maximum(hdl, i, 3000.0))
{
printf("error: edf_set_physical_maximum()\n");
return(1);
}
}
for(i=0; i<chns; i++)
{
if(edf_set_digital_maximum(hdl, i, 8388607))
{
printf("error: edf_set_digital_maximum()\n");
return(1);
}
}
for(i=0; i<chns; i++)
{
if(edf_set_digital_minimum(hdl, i, -8388608))
{
printf("error: edf_set_digital_minimum()\n");
return(1);
}
}
for(i=0; i<chns; i++)
{
if(edf_set_physical_minimum(hdl, i, -3000.0))
{
printf("error: edf_set_physical_minimum()\n");
return(1);
}
}
if(edf_set_label(hdl, 0, "sinus"))
{
printf("error: edf_set_label()\n");
return(1);
}
if(edf_set_label(hdl, 1, "ramp"))
{
printf("error: edf_set_label()\n");
return(1);
}
for(i=0; i<chns; i++)
{
if(edf_set_physical_dimension(hdl, i, "mV"))
{
printf("error: edf_set_physical_dimension()\n");
return(1);
}
}
for(j=0; j<10; j++)
{
for(i=0; i<SMP_FREQ; i++)
{
q = M_PI * 2.0;
q /= SMP_FREQ;
q *= i;
q = sin(q);
q *= 3000.0;
buf[i] = q;
}
if(edfwrite_physical_samples(hdl, buf))
{
printf("error: edfwrite_physical_samples()\n");
return(1);
}
for(i=0; i<SMP_FREQ; i++)
{
buf[i] = -3000.0 + (i * 2.9296875);
}
if(edfwrite_physical_samples(hdl, buf))
{
printf("error: edfwrite_physical_samples()\n");
return(1);
}
}
for(j=0; j<10; j++)
{
for(i=0; i<SMP_FREQ; i++)
{
q = M_PI * 2.0;
q /= SMP_FREQ;
q *= i;
q = sin(q);
q *= 8388607.0;
buf2[i] = q;
}
if(edfwrite_digital_samples(hdl, buf2))
{
printf("error: edfwrite_digital_samples()\n");
return(1);
}
for(i=0; i<SMP_FREQ; i++)
{
buf2[i] = -8388608 + (i * 8192);
}
if(edfwrite_digital_samples(hdl, buf2))
{
printf("error: edfwrite_digital_samples()\n");
return(1);
}
}
edfwrite_annotation_latin1(hdl, 0LL, -1LL, "Recording starts");
edfwrite_annotation_latin1(hdl, 200000LL, -1LL, "Recording ends");
edfclose_file(hdl);
return(0);
}
int main(int argc, char *argv[])
{
int i, j,
hdl,
chns;
double buf[1000],
q,
sine_1,
sine_8,
sine_81777,
sine_85,
sine_15,
sine_17,
sine_50;
struct{
long long samples;
long long triggers[512];
int index;
int code;
int bitposition;
int smp_in_bit;
} dc_event_stat;
memset(&dc_event_stat, 0, sizeof(dc_event_stat));
dc_event_stat.code = 0;
dc_event_stat.triggers[0] = 1951;
for(i=1; i<512; i++)
{
dc_event_stat.triggers[i] = (i * 1667) + 1951;
}
chns = 14;
#ifdef BDF_FORMAT
hdl = edfopen_file_writeonly("test_generator.bdf", EDFLIB_FILETYPE_BDFPLUS, chns);
#else
hdl = edfopen_file_writeonly("test_generator.edf", EDFLIB_FILETYPE_EDFPLUS, chns);
#endif
if(hdl<0)
{
printf("error: edfopen_file_writeonly()\n");
return(1);
}
for(i=0; i<chns; i++)
{
if(edf_set_samplefrequency(hdl, i, SMP_FREQ))
{
printf("error: edf_set_samplefrequency()\n");
return(1);
}
}
if(edf_set_samplefrequency(hdl, 3, SMP_FREQ_2))
{
printf("error: edf_set_samplefrequency()\n");
return(1);
}
if(edf_set_samplefrequency(hdl, 4, SMP_FREQ_3))
{
printf("error: edf_set_samplefrequency()\n");
return(1);
}
if(edf_set_samplefrequency(hdl, 13, 1000))
{
printf("error: edf_set_samplefrequency()\n");
return(1);
}
#ifdef BDF_FORMAT
for(i=0; i<chns; i++)
{
if(edf_set_digital_maximum(hdl, i, 8388607))
{
printf("error: edf_set_digital_maximum()\n");
return(1);
}
}
for(i=0; i<chns; i++)
{
if(edf_set_digital_minimum(hdl, i, -8388608))
{
printf("error: edf_set_digital_minimum()\n");
return(1);
}
}
if(edf_set_digital_minimum(hdl, 13, 8300000))
{
printf("error: edf_set_digital_minimum()\n");
return(1);
}
#else
for(i=0; i<chns; i++)
{
if(edf_set_digital_maximum(hdl, i, 32767))
{
printf("error: edf_set_digital_maximum()\n");
return(1);
}
}
for(i=0; i<chns; i++)
{
if(edf_set_digital_minimum(hdl, i, -32768))
{
printf("error: edf_set_digital_minimum()\n");
return(1);
}
}
#endif
for(i=0; i<chns; i++)
{
if(edf_set_physical_maximum(hdl, i, 1000.0))
{
printf("error: edf_set_physical_maximum()\n");
return(1);
}
}
if(edf_set_physical_maximum(hdl, 8, 262143.0))
{
printf("error: edf_set_physical_maximum()\n");
return(1);
}
if(edf_set_physical_maximum(hdl, 13, 10.0))
{
printf("error: edf_set_physical_maximum()\n");
return(1);
}
for(i=0; i<chns; i++)
{
if(edf_set_physical_minimum(hdl, i, -1000.0))
{
printf("error: edf_set_physical_minimum()\n");
return(1);
}
}
if(edf_set_physical_minimum(hdl, 8, -262144.0))
{
printf("error: edf_set_physical_minimum()\n");
return(1);
}
if(edf_set_physical_minimum(hdl, 13, -10.0))
{
printf("error: edf_set_physical_minimum()\n");
return(1);
}
for(i=0; i<chns; i++)
{
if(edf_set_physical_dimension(hdl, i, "uV"))
{
printf("error: edf_set_physical_dimension()\n");
return(1);
}
}
if(edf_set_physical_dimension(hdl, 13, "V"))
{
printf("error: edf_set_physical_dimension()\n");
return(1);
}
i = 0;
if(edf_set_label(hdl, i++, "squarewave"))
{
printf("error: edf_set_label()\n");
return(1);
}
if(edf_set_label(hdl, i++, "ramp"))
{
printf("error: edf_set_label()\n");
return(1);
}
if(edf_set_label(hdl, i++, "pulse 1"))
{
printf("error: edf_set_label()\n");
return(1);
}
if(edf_set_label(hdl, i++, "pulse 2"))
{
printf("error: edf_set_label()\n");
return(1);
}
if(edf_set_label(hdl, i++, "pulse 3"))
{
printf("error: edf_set_label()\n");
return(1);
}
if(edf_set_label(hdl, i++, "noise"))
{
printf("error: edf_set_label()\n");
return(1);
}
if(edf_set_label(hdl, i++, "sine 1 Hz"))
{
printf("error: edf_set_label()\n");
return(1);
}
if(edf_set_label(hdl, i++, "sine 8 Hz"))
{
printf("error: edf_set_label()\n");
return(1);
}
if(edf_set_label(hdl, i++, "sine 8.1777 Hz"))
{
printf("error: edf_set_label()\n");
return(1);
}
if(edf_set_label(hdl, i++, "sine 8.5 Hz"))
{
printf("error: edf_set_label()\n");
return(1);
}
if(edf_set_label(hdl, i++, "sine 15 Hz"))
{
printf("error: edf_set_label()\n");
return(1);
}
if(edf_set_label(hdl, i++, "sine 17 Hz"))
{
printf("error: edf_set_label()\n");
return(1);
}
if(edf_set_label(hdl, i++, "sine 50 Hz"))
{
printf("error: edf_set_label()\n");
return(1);
}
if(edf_set_label(hdl, i++, "DC 01"))
{
printf("error: edf_set_label()\n");
return(1);
}
if(edf_set_equipment(hdl, "test generator"))
{
printf("edf_set_equipment()\n");
return(1);
}
edf_set_birthdate(hdl, 1969, 6, 30);
sine_1 = 0.0;
sine_8 = 0.0;
sine_81777 = 0.0;
sine_85 = 0.0;
sine_15 = 0.0;
sine_17 = 0.0;
sine_50 = 0.0;
for(j=0; j<FILE_DURATION; j++)
{
if((j%10)<5) /* square */
{
for(i=0; i<SMP_FREQ; i++)
{
buf[i] = 100.0;
}
}
else
{
for(i=0; i<SMP_FREQ; i++)
{
buf[i] = -100.0;
}
}
if(edfwrite_physical_samples(hdl, buf))
{
printf("error: edfwrite_physical_samples()\n");
return(1);
}
for(i=0; i<SMP_FREQ; i++) /* ramp */
{
buf[i] = -100.0 + (i * (200.0 / SMP_FREQ));
}
if(edfwrite_physical_samples(hdl, buf))
{
printf("error: edfwrite_physical_samples()\n");
return(1);
}
for(i=0; i<SMP_FREQ; i++) /* pulse 1 */
{
buf[i] = 0.0;
}
buf[0] = 100.0;
buf[SMP_FREQ - 2] = 100.0;
if(edfwrite_physical_samples(hdl, buf))
{
printf("error: edfwrite_physical_samples()\n");
return(1);
}
for(i=0; i<SMP_FREQ_2; i++) /* pulse 2 */
{
buf[i] = 0.0;
}
buf[0] = 100.0;
buf[SMP_FREQ_2 - 2] = 100.0;
if(edfwrite_physical_samples(hdl, buf))
{
printf("error: edfwrite_physical_samples()\n");
return(1);
}
for(i=0; i<SMP_FREQ_3; i++) /* pulse 3 */
{
buf[i] = 0.0;
}
buf[0] = 100.0;
buf[SMP_FREQ_3 - 2] = 100.0;
if(edfwrite_physical_samples(hdl, buf))
{
printf("error: edfwrite_physical_samples()\n");
return(1);
}
for(i=0; i<SMP_FREQ; i++) /* noise */
{
buf[i] = (int)(100.0 * (rand() / (RAND_MAX + 1.0)));
}
if(edfwrite_physical_samples(hdl, buf))
{
printf("error: edfwrite_physical_samples()\n");
return(1);
}
for(i=0; i<SMP_FREQ; i++) /* sine 1 Hz */
{
q = M_PI * 2.0;
q /= SMP_FREQ;
sine_1 += q;
q = sin(sine_1);
q *= 100.0;
buf[i] = q;
}
if(edfwrite_physical_samples(hdl, buf))
{
printf("error: edfwrite_physical_samples()\n");
return(1);
}
for(i=0; i<SMP_FREQ; i++) /* sine 8 Hz */
{
q = M_PI * 2.0;
q /= (SMP_FREQ / 8.0);
sine_8 += q;
q = sin(sine_8);
q *= 100.0;
buf[i] = q + 800.0; /* add dc-offset */
}
if(edfwrite_physical_samples(hdl, buf))
{
printf("error: edfwrite_physical_samples()\n");
return(1);
}
for(i=0; i<SMP_FREQ; i++) /* sine 8.1777 Hz */
{
q = M_PI * 2.0;
q /= (SMP_FREQ / 8.1777);
sine_81777 += q;
q = sin(sine_81777);
q *= 100.0;
buf[i] = q + 6000.0; /* add dc-offset */
}
if(edfwrite_physical_samples(hdl, buf))
{
printf("error: edfwrite_physical_samples()\n");
return(1);
}
for(i=0; i<SMP_FREQ; i++) /* sine 8.5 Hz */
{
q = M_PI * 2.0;
q /= (SMP_FREQ / 8.5);
sine_85 += q;
q = sin(sine_85);
q *= 100.0;
buf[i] = q;
}
if(edfwrite_physical_samples(hdl, buf))
{
printf("error: edfwrite_physical_samples()\n");
return(1);
}
for(i=0; i<SMP_FREQ; i++) /* sine 15 Hz */
{
q = M_PI * 2.0;
q /= (SMP_FREQ / 15.0);
sine_15 += q;
q = sin(sine_15);
q *= 100.0;
buf[i] = q;
}
if(edfwrite_physical_samples(hdl, buf))
{
printf("error: edfwrite_physical_samples()\n");
return(1);
}
for(i=0; i<SMP_FREQ; i++) /* sine 17 Hz */
{
q = M_PI * 2.0;
q /= (SMP_FREQ / 17.0);
sine_17 += q;
q = sin(sine_17);
q *= 100.0;
buf[i] = q;
}
if(edfwrite_physical_samples(hdl, buf))
{
printf("error: edfwrite_physical_samples()\n");
return(1);
}
for(i=0; i<SMP_FREQ; i++) /* sine 50 Hz */
{
q = M_PI * 2.0;
q /= (SMP_FREQ / 50.0);
sine_50 += q;
q = sin(sine_50);
q *= 100.0;
buf[i] = q;
}
if(edfwrite_physical_samples(hdl, buf))
{
printf("error: edfwrite_physical_samples()\n");
return(1);
}
for(i=0; i<1000; i++) /* DC 01 */
{
if(dc_event_stat.bitposition)
{
if(dc_event_stat.bitposition == 1)
{
buf[i] = 1.0;
}
else
{
if(dc_event_stat.code & (1 << (dc_event_stat.bitposition - 2)))
{
buf[i] = 1.0;
}
else
{
buf[i] = 0.0;
}
}
if(++dc_event_stat.smp_in_bit >= 10)
{
dc_event_stat.smp_in_bit = 0;
dc_event_stat.bitposition++;
}
if(dc_event_stat.bitposition > 10)
{
dc_event_stat.bitposition = 0;
dc_event_stat.smp_in_bit = 0;
dc_event_stat.code++;
dc_event_stat.code &= 255;
if(++dc_event_stat.index >= 512)
{
dc_event_stat.index = 0;
dc_event_stat.code = 0;
}
}
}
else
{
if(dc_event_stat.samples == dc_event_stat.triggers[dc_event_stat.index])
{
/* edfwrite_annotation_latin1(hdl, dc_event_stat.samples * 10LL, -1LL, "Trigger"); */
dc_event_stat.bitposition = 1;
dc_event_stat.smp_in_bit = 1;
buf[i] = 1.0;
}
else
{
buf[i] = 0.0;
}
}
dc_event_stat.samples++;
}
if(edfwrite_physical_samples(hdl, buf))
{
printf("error: edfwrite_physical_samples()\n");
return(1);
}
}
edfwrite_annotation_latin1(hdl, 0LL, -1LL, "Recording starts");
edfwrite_annotation_latin1(hdl, 2980000LL, -1LL, "Test 1");
edfwrite_annotation_latin1(hdl, 2940000LL + (long long)((10000.0 / SMP_FREQ) * (SMP_FREQ - 2)), -1LL, "pulse 1");
edfwrite_annotation_latin1(hdl, 2950000LL + (long long)((10000.0 / SMP_FREQ_2) * (SMP_FREQ_2 - 2)), -1LL, "pulse 2");
edfwrite_annotation_latin1(hdl, 2960000LL + (long long)((10000.0 / SMP_FREQ_3) * (SMP_FREQ_3 - 2)), -1LL, "pulse 3");
edfwrite_annotation_latin1(hdl, FILE_DURATION * 10000LL, -1LL, "Recording ends");
edfclose_file(hdl);
return(0);
}
/* ==================================================================== */
int sci_edf_set_digital_minimum(char *fname)
{
SciErr sciErr;
int m1 = 0, n1 = 0;
int *piAddressVarOne = NULL;
int* piLenVarOne = NULL;
double *pdVarOne = NULL;
int iType1 = 0;
int m2 = 0, n2 = 0;
int *piAddressVarTwo = NULL;
double *pdVarTwo = NULL;
int iType2 = 0;
int m3 = 0, n3 = 0;
int *piAddressVarThree = NULL;
double *pdVarThree = NULL;
int iType3 = 0;
int m_out = 0, n_out = 0;
double *dOut = NULL;
int i;
int handle;
/* --> result = csum(3,8)
/* check that we have only 2 parameters input */
/* check that we have only 1 parameters output */
CheckInputArgument(pvApiCtx,3,3) ;
CheckOutputArgument(pvApiCtx,1,1) ;
/* get Address of inputs */
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if(sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
if(sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddressVarThree);
if(sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
/* check input type */
sciErr = getVarType(pvApiCtx, piAddressVarOne, &iType1);
if(sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
if ( iType1 != sci_matrix )
{
Scierror(999,"%s: Wrong type for input argument #%d: A integer expected.\n",fname,1);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddressVarTwo, &iType2);
if(sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
if ( iType2 != sci_matrix )
{
Scierror(999,"%s: Wrong type for input argument #%d: A double expected.\n",fname,2);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddressVarThree, &iType3);
if(sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
if ( iType3 != sci_matrix )
{
Scierror(999,"%s: Wrong type for input argument #%d: A double expected.\n",fname,3);
return 0;
}
sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarOne,&m1,&n1,&pdVarOne);
if(sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarTwo,&m2,&n2,&pdVarTwo);
if(sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarThree,&m3,&n3,&pdVarThree);
if(sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
/* check size */
if ( (m1 != 1) || (n1 != 1) )
{
Scierror(999,"%s: Wrong size for input argument #%d: A scalar expected.\n",fname,1);
return 0;
}
if ( (m2 !=1) || (n2 !=1) )
{
Scierror(999,"%s: Wrong size for input argument #%d: A scalar expected.\n",fname,2);
return 0;
}
if ( (m3 !=1) || (n3 !=1) )
{
Scierror(999,"%s: Wrong size for input argument #%d: A scalar expected.\n",fname,2);
return 0;
}
if ((int)pdVarTwo[0]<1){
Scierror(999,"The parameter edfsignal must be at least 1 !\n");
return 0;
}
/* call c function csum */
// csum(&pdVarOne[0],&pdVarTwo[0],&dOut);
if ( edf_set_digital_minimum((int)pdVarOne[0], (int)pdVarTwo[0]-1 , pdVarThree[0]) <0)
{
Scierror(999,"Could not write digital minimum\n");
return 0;
}
m_out = 1; n_out = 1;
dOut = (double*)malloc(sizeof(double) * m_out*n_out);
// CreateVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m_out, &n_out, &dout);
dOut[0]=0;
/* create result on stack */
createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m_out, n_out, dOut);
free(dOut);
AssignOutputVariable(pvApiCtx,1) = nbInputArgument(pvApiCtx) + 1;
/* This function put on scilab stack, the lhs variable
which are at the position lhs(i) on calling stack */
/* You need to add PutLhsVar here because WITHOUT_ADD_PUTLHSVAR
was defined and equal to %t */
/* without this, you do not need to add PutLhsVar here */
ReturnArguments(pvApiCtx);
return 0;
}
void UI_Mainwindow::save_screen_waveform()
{
int i, j,
n=0,
chn,
chns=0,
hdl=-1,
yref[MAX_CHNS],
yor[MAX_CHNS];
char str[128],
opath[MAX_PATHLEN];
short *wavbuf[4];
long long rec_len=0LL;
double yinc[MAX_CHNS];
if(device == NULL)
{
return;
}
wavbuf[0] = NULL;
wavbuf[1] = NULL;
wavbuf[2] = NULL;
wavbuf[3] = NULL;
scrn_timer->stop();
scrn_thread->wait();
if(devparms.timebasedelayenable)
{
rec_len = EDFLIB_TIME_DIMENSION * devparms.timebasedelayscale * devparms.hordivisions;
}
else
{
rec_len = EDFLIB_TIME_DIMENSION * devparms.timebasescale * devparms.hordivisions;
}
if(rec_len < 10LL)
{
strcpy(str, "Can not save waveforms when timebase < 1uSec.");
goto OUT_ERROR;
}
for(chn=0; chn<MAX_CHNS; chn++)
{
if(!devparms.chandisplay[chn]) // Download data only when channel is switched on
{
continue;
}
wavbuf[chn] = (short *)malloc(WAVFRM_MAX_BUFSZ * sizeof(short));
if(wavbuf[chn] == NULL)
{
strcpy(str, "Malloc error.");
goto OUT_ERROR;
}
chns++;
}
if(!chns)
{
strcpy(str, "No active channels.");
goto OUT_ERROR;
}
for(chn=0; chn<MAX_CHNS; chn++)
{
if(!devparms.chandisplay[chn]) // Download data only when channel is switched on
{
continue;
}
usleep(20000);
sprintf(str, ":WAV:SOUR CHAN%i", chn + 1);
tmc_write(str);
usleep(20000);
tmc_write(":WAV:FORM BYTE");
usleep(20000);
tmc_write(":WAV:MODE NORM");
usleep(20000);
tmc_write(":WAV:YINC?");
usleep(20000);
tmc_read();
yinc[chn] = atof(device->buf);
if(yinc[chn] < 1e-6)
{
sprintf(str, "Error, parameter \"YINC\" out of range. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
usleep(20000);
tmc_write(":WAV:YREF?");
usleep(20000);
tmc_read();
yref[chn] = atoi(device->buf);
if((yref[chn] < 1) || (yref[chn] > 255))
{
sprintf(str, "Error, parameter \"YREF\" out of range. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
usleep(20000);
tmc_write(":WAV:YOR?");
usleep(20000);
tmc_read();
yor[chn] = atoi(device->buf);
if((yor[chn] < -255) || (yor[chn] > 255))
{
sprintf(str, "Error, parameter \"YOR\" out of range. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
usleep(20000);
tmc_write(":WAV:DATA?");
QApplication::setOverrideCursor(Qt::WaitCursor);
qApp->processEvents();
n = tmc_read();
QApplication::restoreOverrideCursor();
if(n < 0)
{
strcpy(str, "Can not read from device.");
goto OUT_ERROR;
}
if(n > WAVFRM_MAX_BUFSZ)
{
strcpy(str, "Datablock too big for buffer.");
goto OUT_ERROR;
}
if(n < 16)
{
strcpy(str, "Not enough data in buffer.");
goto OUT_ERROR;
}
for(i=0; i<n; i++)
{
wavbuf[chn][i] = ((int)(((unsigned char *)device->buf)[i]) - yref[chn] - yor[chn]) << 5;
}
}
opath[0] = 0;
if(recent_savedir[0]!=0)
{
strcpy(opath, recent_savedir);
strcat(opath, "/");
}
strcat(opath, "waveform.edf");
strcpy(opath, QFileDialog::getSaveFileName(this, "Save file", opath, "EDF files (*.edf *.EDF)").toLocal8Bit().data());
if(!strcmp(opath, ""))
{
goto OUT_NORMAL;
}
get_directory_from_path(recent_savedir, opath, MAX_PATHLEN);
hdl = edfopen_file_writeonly(opath, EDFLIB_FILETYPE_EDFPLUS, chns);
if(hdl < 0)
{
strcpy(str, "Can not create EDF file.");
goto OUT_ERROR;
}
if(edf_set_datarecord_duration(hdl, rec_len / 100LL))
{
strcpy(str, "Can not set datarecord duration of EDF file.");
goto OUT_ERROR;
}
j = 0;
for(chn=0; chn<MAX_CHNS; chn++)
{
if(!devparms.chandisplay[chn])
{
continue;
}
edf_set_samplefrequency(hdl, j, n);
edf_set_digital_maximum(hdl, j, 32767);
edf_set_digital_minimum(hdl, j, -32768);
if(devparms.chanscale[chn] > 2)
{
edf_set_physical_maximum(hdl, j, yinc[chn] * 32767.0 / 32.0);
edf_set_physical_minimum(hdl, j, yinc[chn] * -32768.0 / 32.0);
edf_set_physical_dimension(hdl, j, "V");
}
else
{
edf_set_physical_maximum(hdl, j, 1000.0 * yinc[chn] * 32767.0 / 32.0);
edf_set_physical_minimum(hdl, j, 1000.0 * yinc[chn] * -32768.0 / 32.0);
edf_set_physical_dimension(hdl, j, "mV");
}
sprintf(str, "CHAN%i", chn + 1);
edf_set_label(hdl, j, str);
j++;
}
edf_set_equipment(hdl, devparms.modelname);
for(chn=0; chn<MAX_CHNS; chn++)
{
if(!devparms.chandisplay[chn])
{
continue;
}
if(edfwrite_digital_short_samples(hdl, wavbuf[chn]))
{
strcpy(str, "A write error occurred.");
goto OUT_ERROR;
}
}
OUT_NORMAL:
if(hdl >= 0)
{
edfclose_file(hdl);
}
for(chn=0; chn<MAX_CHNS; chn++)
{
free(wavbuf[chn]);
}
scrn_timer->start(devparms.screentimerival);
return;
OUT_ERROR:
QMessageBox msgBox;
msgBox.setIcon(QMessageBox::Critical);
msgBox.setText(str);
msgBox.exec();
if(hdl >= 0)
{
edfclose_file(hdl);
}
for(chn=0; chn<MAX_CHNS; chn++)
{
free(wavbuf[chn]);
}
scrn_timer->start(devparms.screentimerival);
}
void UI_Mainwindow::save_memory_waveform()
{
int i, j, k,
n=0,
chn,
chns=0,
hdl=-1,
bytes_rcvd=0,
mempnts,
yref[MAX_CHNS],
yor[MAX_CHNS],
smps_per_record,
datrecs=1,
empty_buf;
char str[128],
opath[MAX_PATHLEN];
short *wavbuf[4];
long long rec_len=0LL;
double yinc[MAX_CHNS];
if(device == NULL)
{
return;
}
scrn_timer->stop();
scrn_thread->wait();
wavbuf[0] = NULL;
wavbuf[1] = NULL;
wavbuf[2] = NULL;
wavbuf[3] = NULL;
mempnts = devparms.acquirememdepth;
smps_per_record = mempnts;
QProgressDialog progress("Downloading data...", "Abort", 0, mempnts, this);
progress.setWindowModality(Qt::WindowModal);
progress.setMinimumDuration(100);
statusLabel->setText("Downloading data...");
for(i=0; i<MAX_CHNS; i++)
{
if(!devparms.chandisplay[i])
{
continue;
}
chns++;
}
if(!chns)
{
strcpy(str, "No active channels.");
goto OUT_ERROR;
}
while(smps_per_record >= (5000000 / chns))
{
smps_per_record /= 2;
datrecs *= 2;
}
if(mempnts < 1)
{
strcpy(str, "Can not save waveform when memory depth is set to \"Auto\".");
goto OUT_ERROR;
}
rec_len = (EDFLIB_TIME_DIMENSION * (long long)mempnts) / devparms.samplerate;
if(rec_len < 100)
{
strcpy(str, "Can not save waveforms shorter than 10 uSec.\n"
"Set the horizontal timebase to 1 uSec or higher.");
goto OUT_ERROR;
}
for(i=0; i<MAX_CHNS; i++)
{
if(!devparms.chandisplay[i]) // Download data only when channel is switched on
{
continue;
}
wavbuf[i] = (short *)malloc(mempnts * sizeof(short));
if(wavbuf[i] == NULL)
{
sprintf(str, "Malloc error. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
}
tmc_write(":STOP");
usleep(20000);
for(chn=0; chn<MAX_CHNS; chn++)
{
if(!devparms.chandisplay[chn]) // Download data only when channel is switched on
{
continue;
}
sprintf(str, ":WAV:SOUR CHAN%i", chn + 1);
tmc_write(str);
tmc_write(":WAV:FORM BYTE");
usleep(20000);
tmc_write(":WAV:MODE RAW");
usleep(20000);
tmc_write(":WAV:YINC?");
usleep(20000);
tmc_read();
yinc[chn] = atof(device->buf);
if(yinc[chn] < 1e-6)
{
sprintf(str, "Error, parameter \"YINC\" out of range. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
usleep(20000);
tmc_write(":WAV:YREF?");
usleep(20000);
tmc_read();
yref[chn] = atoi(device->buf);
if((yref[chn] < 1) || (yref[chn] > 255))
{
sprintf(str, "Error, parameter \"YREF\" out of range. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
usleep(20000);
tmc_write(":WAV:YOR?");
usleep(20000);
tmc_read();
yor[chn] = atoi(device->buf);
if((yor[chn] < -255) || (yor[chn] > 255))
{
sprintf(str, "Error, parameter \"YOR\" out of range. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
empty_buf = 0;
for(bytes_rcvd=0; bytes_rcvd<mempnts ;)
{
progress.setValue(bytes_rcvd);
qApp->processEvents();
if(progress.wasCanceled())
{
strcpy(str, "Canceled");
goto OUT_ERROR;
}
sprintf(str, ":WAV:STAR %i", bytes_rcvd + 1);
usleep(20000);
tmc_write(str);
if((bytes_rcvd + SAV_MEM_BSZ) > mempnts)
{
sprintf(str, ":WAV:STOP %i", mempnts);
}
else
{
sprintf(str, ":WAV:STOP %i", bytes_rcvd + SAV_MEM_BSZ);
}
usleep(20000);
tmc_write(str);
usleep(20000);
tmc_write(":WAV:DATA?");
n = tmc_read();
if(n < 0)
{
sprintf(str, "Can not read from device. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
printf("received %i bytes, total %i bytes\n", n, n + bytes_rcvd);
if(n > SAV_MEM_BSZ)
{
sprintf(str, "Datablock too big for buffer. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
if(n < 1)
{
if(empty_buf++ > 100)
{
break;
}
}
else
{
empty_buf = 0;
}
for(k=0; k<n; k++)
{
if((bytes_rcvd + k) >= mempnts)
{
break;
}
wavbuf[chn][bytes_rcvd + k] = ((int)(((unsigned char *)device->buf)[k]) - yref[chn] - yor[chn]) << 5;
}
bytes_rcvd += n;
if(bytes_rcvd >= mempnts)
{
break;
}
}
if(bytes_rcvd < mempnts)
{
sprintf(str, "Download error. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
}
progress.reset();
for(chn=0; chn<MAX_CHNS; chn++)
{
if(!devparms.chandisplay[chn])
{
continue;
}
sprintf(str, ":WAV:SOUR CHAN%i", chn + 1);
usleep(20000);
tmc_write(str);
usleep(20000);
tmc_write(":WAV:MODE NORM");
usleep(20000);
tmc_write(":WAV:STAR 1");
if(devparms.modelserie == 1)
{
usleep(20000);
tmc_write(":WAV:STOP 1200");
}
else
{
usleep(20000);
tmc_write(":WAV:STOP 1400");
usleep(20000);
tmc_write(":WAV:POIN 1400");
}
}
if(bytes_rcvd < mempnts)
{
sprintf(str, "Download error. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
else
{
statusLabel->setText("Downloading finished");
}
opath[0] = 0;
if(recent_savedir[0]!=0)
{
strcpy(opath, recent_savedir);
strcat(opath, "/");
}
strcat(opath, "waveform.edf");
strcpy(opath, QFileDialog::getSaveFileName(this, "Save file", opath, "EDF files (*.edf *.EDF)").toLocal8Bit().data());
if(!strcmp(opath, ""))
{
goto OUT_NORMAL;
}
get_directory_from_path(recent_savedir, opath, MAX_PATHLEN);
hdl = edfopen_file_writeonly(opath, EDFLIB_FILETYPE_EDFPLUS, chns);
if(hdl < 0)
{
strcpy(str, "Can not create EDF file.");
goto OUT_ERROR;
}
if(edf_set_datarecord_duration(hdl, (rec_len / 100LL) / datrecs))
{
strcpy(str, "Can not set datarecord duration of EDF file.");
goto OUT_ERROR;
}
j = 0;
for(chn=0; chn<MAX_CHNS; chn++)
{
if(!devparms.chandisplay[chn])
{
continue;
}
edf_set_samplefrequency(hdl, j, smps_per_record);
edf_set_digital_maximum(hdl, j, 32767);
edf_set_digital_minimum(hdl, j, -32768);
if(devparms.chanscale[chn] > 2)
{
edf_set_physical_maximum(hdl, j, yinc[chn] * 32767.0 / 32.0);
edf_set_physical_minimum(hdl, j, yinc[chn] * -32768.0 / 32.0);
edf_set_physical_dimension(hdl, j, "V");
}
else
{
edf_set_physical_maximum(hdl, j, 1000.0 * yinc[chn] * 32767.0 / 32.0);
edf_set_physical_minimum(hdl, j, 1000.0 * yinc[chn] * -32768.0 / 32.0);
edf_set_physical_dimension(hdl, j, "mV");
}
sprintf(str, "CHAN%i", chn + 1);
edf_set_label(hdl, j, str);
j++;
}
edf_set_equipment(hdl, devparms.modelname);
for(i=0; i<datrecs; i++)
{
for(chn=0; chn<MAX_CHNS; chn++)
{
if(!devparms.chandisplay[chn])
{
continue;
}
if(edfwrite_digital_short_samples(hdl, wavbuf[chn] + (i * smps_per_record)))
{
strcpy(str, "A write error occurred.");
goto OUT_ERROR;
}
}
}
OUT_NORMAL:
if(hdl >= 0)
{
edfclose_file(hdl);
}
for(chn=0; chn<MAX_CHNS; chn++)
{
free(wavbuf[chn]);
}
scrn_timer->start(devparms.screentimerival);
return;
OUT_ERROR:
progress.reset();
statusLabel->setText("Downloading aborted");
if(hdl >= 0)
{
edfclose_file(hdl);
}
if(progress.wasCanceled() == false)
{
QMessageBox msgBox;
msgBox.setIcon(QMessageBox::Critical);
msgBox.setText(str);
msgBox.exec();
}
for(chn=0; chn<MAX_CHNS; chn++)
{
if(!devparms.chandisplay[chn])
{
continue;
}
sprintf(str, ":WAV:SOUR CHAN%i", chn + 1);
tmc_write(str);
tmc_write(":WAV:MODE NORM");
tmc_write(":WAV:STAR 1");
if(devparms.modelserie == 1)
{
tmc_write(":WAV:STOP 1200");
}
else
{
tmc_write(":WAV:STOP 1400");
tmc_write(":WAV:POIN 1400");
}
}
for(chn=0; chn<MAX_CHNS; chn++)
{
free(wavbuf[chn]);
}
scrn_timer->start(devparms.screentimerival);
}
void UI_WAV2EDFwindow::SelectFileButton()
{
FILE *inputfile=NULL;
int i, j,
edfsignals,
sf,
resolution,
edf_hdl,
readbufsize,
*writebuf,
bytes_per_sample,
sf_divider;
unsigned int fmt_chunk_offset,
data_chunk_offset,
tmp;
char path[MAX_PATH_LENGTH],
outputfilename[MAX_PATH_LENGTH],
scratchpad[512],
*readbuf;
long long blocks,
leftover,
progress_steps,
k;
union {
unsigned int one;
signed int one_signed;
unsigned short two[2];
signed short two_signed[2];
unsigned char four[4];
} var;
enable_widgets(false);
if(!(strlen(PatientnameLineEdit->text().toLatin1().data())))
{
QMessageBox messagewindow(QMessageBox::Critical, "Invalid input", "Please enter a subject name.");
messagewindow.exec();
enable_widgets(true);
return;
}
if(!(strlen(RecordingLineEdit->text().toLatin1().data())))
{
QMessageBox messagewindow(QMessageBox::Critical, "Invalid input", "Please enter a recording description.");
messagewindow.exec();
enable_widgets(true);
return;
}
strcpy(path, QFileDialog::getOpenFileName(0, "Select inputfile", QString::fromLocal8Bit(recent_opendir), "Text files (*.wav *.WAV)").toLocal8Bit().data());
if(!strcmp(path, ""))
{
enable_widgets(true);
return;
}
get_directory_from_path(recent_opendir, path, MAX_PATH_LENGTH);
inputfile = fopeno(path, "rb");
if(inputfile==NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open file for reading.");
messagewindow.exec();
enable_widgets(true);
return;
}
/***************** check if the wavefile is valid ******************************/
rewind(inputfile);
if(fread(scratchpad, 256, 1, inputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if((strncmp(scratchpad, "RIFF", 4)) || (strncmp(scratchpad + 8, "WAVE", 4)))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "File is not a Wave file.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
fmt_chunk_offset = 12;
while(1)
{
fseeko(inputfile, (long long)fmt_chunk_offset, SEEK_SET);
if(fread(scratchpad, 256, 1, inputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not find fmt chunk.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(strncmp(scratchpad, "fmt ", 4) == 0)
{
break;
}
tmp = *((unsigned int *)(scratchpad + 4));
if(tmp < 2)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not find fmt chunk.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(tmp & 1)
{
tmp++;
}
fmt_chunk_offset += (tmp + 8);
}
if(*((signed short *)(scratchpad + 8)) != 1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "File contains compressed data.\nCan not convert compressed data.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
edfsignals = *((unsigned short *)(scratchpad + 10));
if(edfsignals < 1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Channels < 1");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(edfsignals > MAXSIGNALS)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Channels > MAXSIGNALS");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
sf = *((unsigned int *)(scratchpad + 12));
if(sf < 1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Samplefrequency < 1");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(sf > 500000)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Samplefrequency > 500000");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
resolution = *((unsigned short *)(scratchpad + 22));
if(resolution < 8)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Resolution < 8 bit");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(resolution > 24)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Resolution > 24");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if((resolution != 8) && (resolution != 16) && (resolution != 24))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Resolution (bitdepth) must be 8, 16 or 24 bit.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
bytes_per_sample = 2;
if(resolution > 16)
{
bytes_per_sample = 3;
}
if(resolution < 9)
{
bytes_per_sample = 1;
}
///////////////////////////////////////////////////////////////////////////////
data_chunk_offset = 12;
while(1)
{
fseeko(inputfile, (long long)data_chunk_offset, SEEK_SET);
if(fread(scratchpad, 256, 1, inputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not find data chunk.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(strncmp(scratchpad, "data", 4) == 0)
{
break;
}
tmp = *((unsigned int *)(scratchpad + 4));
if(tmp < 2)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not find data chunk.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(tmp & 1)
{
tmp++;
}
data_chunk_offset += (tmp + 8);
}
///////////////////////////////////////////////////////////////////////////////
sf_divider = 1;
if((sf % 10) == 0)
{
sf_divider = 10;
sf /= 10;
}
blocks = (long long)(*((int *)(scratchpad + 4)));
blocks /= (sf * edfsignals * bytes_per_sample);
fseeko(inputfile, 0LL, SEEK_END);
leftover = ftello(inputfile) - (long long)data_chunk_offset - 8LL;
leftover /= (sf * edfsignals * bytes_per_sample);
if(blocks > leftover)
{
blocks = leftover;
}
if(blocks < 1LL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Not enough data in file.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
readbufsize = bytes_per_sample * sf * edfsignals;
readbuf = (char *)malloc(readbufsize);
if(readbuf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "A memory allocation error occurred. (readbuf).");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
writebuf = (int *)malloc(sf * edfsignals * sizeof(int));
if(writebuf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "A memory allocation error occurred. (writebuf).");
messagewindow.exec();
free(readbuf);
fclose(inputfile);
enable_widgets(true);
return;
}
// printf("resolution is %i edfsignals is %i sf is %i blocks is %lli\n", resolution, edfsignals, sf, blocks);
/***************** create a new EDF file *****************************************/
get_filename_from_path(outputfilename, path, MAX_PATH_LENGTH);
remove_extension_from_filename(outputfilename);
if(resolution > 16)
{
strcat(outputfilename, ".bdf");
}
else
{
strcat(outputfilename, ".edf");
}
path[0] = 0;
if(recent_savedir[0]!=0)
{
strcpy(path, recent_savedir);
strcat(path, "/");
}
strcat(path, outputfilename);
if(resolution > 16)
{
strcpy(path, QFileDialog::getSaveFileName(0, "Output file", QString::fromLocal8Bit(path), "BDF files (*.bdf *.BDF)").toLocal8Bit().data());
}
else
{
strcpy(path, QFileDialog::getSaveFileName(0, "Output file", QString::fromLocal8Bit(path), "EDF files (*.edf *.EDF)").toLocal8Bit().data());
}
if(!strcmp(path, ""))
{
enable_widgets(true);
fclose(inputfile);
return;
}
get_directory_from_path(recent_savedir, path, MAX_PATH_LENGTH);
if(resolution > 16)
{
edf_hdl = edfopen_file_writeonly(path, EDFLIB_FILETYPE_BDFPLUS, edfsignals);
}
else
{
edf_hdl = edfopen_file_writeonly(path, EDFLIB_FILETYPE_EDFPLUS, edfsignals);
}
if(edf_hdl < 0)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open output file for writing.");
messagewindow.exec();
fclose(inputfile);
free(readbuf);
free(writebuf);
enable_widgets(true);
return;
}
for(i=0; i<edfsignals; i++)
{
edf_set_samplefrequency(edf_hdl, i, sf);
}
if(sf_divider != 1)
{
edf_set_datarecord_duration(edf_hdl, 100000 / sf_divider);
}
for(i=0; i<edfsignals; i++)
{
if(resolution > 16)
{
edf_set_digital_maximum(edf_hdl, i, 8388607);
}
else
{
if(resolution < 9)
{
edf_set_digital_maximum(edf_hdl, i, 127);
}
else
{
edf_set_digital_maximum(edf_hdl, i, 32767);
}
}
}
for(i=0; i<edfsignals; i++)
{
if(resolution > 16)
{
edf_set_digital_minimum(edf_hdl, i, -8388608);
}
else
{
if(resolution < 9)
{
edf_set_digital_minimum(edf_hdl, i, -128);
}
else
{
edf_set_digital_minimum(edf_hdl, i, -32768);
}
}
}
for(i=0; i<edfsignals; i++)
{
edf_set_physical_maximum(edf_hdl, i, PhysMaxSpinBox->value());
}
for(i=0; i<edfsignals; i++)
{
edf_set_physical_minimum(edf_hdl, i, PhysMaxSpinBox->value() * -1.0);
}
for(i=0; i<edfsignals; i++)
{
edf_set_physical_dimension(edf_hdl, i, PhysDimLineEdit->text().toLatin1().data());
}
for(i=0; i<edfsignals; i++)
{
sprintf(scratchpad, "channel %i", i + 1);
edf_set_label(edf_hdl, i, scratchpad);
}
edf_set_patientname(edf_hdl, PatientnameLineEdit->text().toLatin1().data());
edf_set_recording_additional(edf_hdl, RecordingLineEdit->text().toLatin1().data());
edf_set_startdatetime(edf_hdl, StartDatetimeedit->date().year(), StartDatetimeedit->date().month(), StartDatetimeedit->date().day(),
StartDatetimeedit->time().hour(), StartDatetimeedit->time().minute(), StartDatetimeedit->time().second());
edfwrite_annotation_latin1(edf_hdl, 0LL, -1, "Recording starts");
/***************** start conversion **************************************/
fseeko(inputfile, (long long)data_chunk_offset + 8LL, SEEK_SET);
QProgressDialog progress("Converting a Wave file ...", "Abort", 0, (int)blocks, myobjectDialog);
progress.setWindowModality(Qt::WindowModal);
progress.setMinimumDuration(200);
progress_steps = blocks / 100LL;
if(progress_steps < 1LL)
{
progress_steps = 1LL;
}
for(k=0LL; k<blocks; k++)
{
if(!(k%progress_steps))
{
progress.setValue((int)k);
qApp->processEvents();
if(progress.wasCanceled() == true)
{
edfclose_file(edf_hdl);
fclose(inputfile);
free(readbuf);
free(writebuf);
enable_widgets(true);
return;
}
}
if(fread(readbuf, readbufsize, 1, inputfile)!=1)
{
progress.reset();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "A read error occurred during conversion.");
messagewindow.exec();
edfclose_file(edf_hdl);
fclose(inputfile);
free(readbuf);
free(writebuf);
enable_widgets(true);
return;
}
if(bytes_per_sample == 1)
{
for(i=0; i<sf; i++)
{
for(j=0; j<edfsignals; j++)
{
writebuf[i + (j * sf)] = (signed char)(*(readbuf + (i * edfsignals) + j) + 128);
}
}
}
if(bytes_per_sample == 2)
{
for(i=0; i<sf; i++)
{
for(j=0; j<edfsignals; j++)
{
writebuf[i + (j * sf)] = *(((signed short *)readbuf) + (i * edfsignals) + j);
}
}
}
if(bytes_per_sample == 3)
{
for(i=0; i<sf; i++)
{
for(j=0; j<edfsignals; j++)
{
var.two[0] = *((unsigned short *)(readbuf + (i * edfsignals) + (j * 3)));
var.four[2] = *((unsigned char *)(readbuf + (i * edfsignals * 3) + (j * 3) + 2));
if(var.four[2]&0x80)
{
var.four[3] = 0xff;
}
else
{
var.four[3] = 0x00;
}
writebuf[i + (j * sf)] = var.one_signed;
}
}
}
if(edf_blockwrite_digital_samples(edf_hdl, writebuf))
{
progress.reset();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "A write error occurred during conversion.");
messagewindow.exec();
edfclose_file(edf_hdl);
fclose(inputfile);
free(readbuf);
free(writebuf);
enable_widgets(true);
return;
}
}
progress.reset();
edfwrite_annotation_latin1(edf_hdl, (blocks * 10000LL) / sf_divider, -1, "Recording ends");
edfclose_file(edf_hdl);
fclose(inputfile);
QMessageBox messagewindow(QMessageBox::Information, "Ready", "Done.");
messagewindow.setIconPixmap(QPixmap(":/images/ok.png"));
messagewindow.exec();
free(readbuf);
free(writebuf);
enable_widgets(true);
}