int main(){
d_filter_t low_pass, high_pass, integrator;
const float dt = 1.0/(float)SAMPLE_RATE;
float lp,hp,i, u = 0;
int counter = 0;
printf("\nInitializing Filters\n\n");
printf(" Sample Rate: %dhz ", SAMPLE_RATE);
printf(" Time Constant: %5.2f ", TIME_CONSTANT);
printf(" dt: %6.2f \n\n", dt);
low_pass = create_first_order_low_pass(dt, TIME_CONSTANT);
high_pass = create_first_order_high_pass(dt, TIME_CONSTANT);
integrator = create_integrator(dt);
reset_filter(&low_pass);
reset_filter(&high_pass);
reset_filter(&integrator);
// print header
printf(" input u |");
printf(" lowpass |");
printf(" highpass |");
printf("complement|");
printf("integrator|");
printf("\n");
// Keep Running until program state changes to EXITING
u=1;
while(get_state() != EXITING){
// march all filters one step forward with u as the common input.
// new outputs saved as lp,hp,and i. complement is lp+hp
lp = march_filter(&low_pass, u);
hp = march_filter(&high_pass, u);
i = march_filter(&integrator, u);
printf("\r");
printf("%7.2f |", u);
printf("%7.2f |", lp);
printf("%7.2f |", hp);
printf("%7.2f |", lp+hp);
printf("%7.2f |", i);
fflush(stdout);
// toggle u between 0 and 1 every 10 seconds
counter++;
if(counter >= SAMPLE_RATE*10){
counter = 0;
if(u>0) u = 0;
else u = 1;
}
// sleep enough for a rough timed loop
usleep(1000000/SAMPLE_RATE);
}
return 0;
}
void
filters_view_reset(view_t *view)
{
view->invert = cfg.filter_inverted_by_default ? 1 : 0;
view->prev_invert = view->invert;
(void)replace_string(&view->prev_manual_filter, "");
replace_matcher(&view->manual_filter, "");
(void)replace_string(&view->prev_auto_filter, "");
reset_filter(&view->auto_filter);
(void)replace_string(&view->local_filter.prev, "");
reset_filter(&view->local_filter.filter);
view->local_filter.in_progress = 0;
view->local_filter.saved = NULL;
view->local_filter.poshist = NULL;
view->local_filter.poshist_len = 0U;
}
/* XXX This should become a function in a library, there're very
* little variance of this repeated code instances
*/
static int showneighs(void)
{
reset_filter();
if (rtnl_wilddump_request(&rth, AF_XIA, RTM_GETROUTE) < 0) {
perror("Cannot send dump request");
exit(1);
}
if (rtnl_dump_filter(&rth, print_neigh, stdout, NULL, NULL) < 0) {
fprintf(stderr, "Dump terminated\n");
exit(1);
}
return 0;
}
/* Based on iproute2/ip/iproute.c:iproute_list_flush_or_save. */
static int dump(int tbl_id)
{
reset_filter();
filter.tb = tbl_id;
if (rtnl_wilddump_request(&rth, AF_XIA, RTM_GETROUTE) < 0) {
perror("Cannot send dump request");
exit(1);
}
if (rtnl_dump_filter(&rth, print_route, stdout, NULL, NULL) < 0) {
fprintf(stderr, "Dump terminated\n");
exit(1);
}
return 0;
}
void print_screen_to_edf(UI_Mainwindow *mainwindow)
{
int i, j, k, p,
n=0,
records,
records_written,
signalcomps,
duration_factor[MAXFILES],
temp=0,
edfplus=0,
tallen,
annotationlist_nr=0,
annotations_left=1,
add_one_sec=0,
annot_smp_per_record=16,
type,
len;
long long duration,
smpls_written[MAXSIGNALS],
s2,
preamble=0LL,
smpls_preamble[MAXSIGNALS],
taltime=0LL,
l_temp,
referencetime,
annot_difftime=0LL;
char path[MAX_PATH_LENGTH],
scratchpad[512],
datrecduration[8],
*viewbuf;
double frequency,
frequency2,
dig_value;
FILE *outputfile;
struct signalcompblock **signalcomp;
union {
signed int one_signed;
signed short two_signed[2];
unsigned char four[4];
} wr_var;
union {
signed short one_signed;
unsigned char two[2];
} null_bytes[MAXSIGNALS];
struct annotationblock *annotations_pntr;
struct date_time_struct date_time;
/////////////////////////////////////////////////////////////////////////
signalcomps = mainwindow->signalcomps;
signalcomp = mainwindow->signalcomp;
viewbuf = mainwindow->viewbuf;
annotations_pntr = mainwindow->annotationlist[0];
if((!mainwindow->files_open)||(!signalcomps))
{
QMessageBox messagewindow(QMessageBox::Critical, "Print to EDF", "Put a signal on the screen and try again.");
messagewindow.exec();
return;
}
for(i=0; i<mainwindow->files_open; i++)
{
if(mainwindow->edfheaderlist[i]->bdf)
{
QMessageBox messagewindow(QMessageBox::Critical, "Print to EDF", "BDF files can not be printed to EDF.");
messagewindow.exec();
return;
}
if(mainwindow->edfheaderlist[i]->discontinuous)
{
QMessageBox messagewindow(QMessageBox::Critical, "Print to EDF", "Sorry, discontinues EDF files can not be printed to EDF.");
messagewindow.exec();
return;
}
if(mainwindow->edfheaderlist[i]->edfplus)
{
edfplus = 1;
for(j=0; j<mainwindow->edfheaderlist[i]->nr_annot_chns; j++)
{
if(mainwindow->edfheaderlist[i]->edfparam[mainwindow->edfheaderlist[i]->annot_ch[j]].smp_per_record>annot_smp_per_record)
{
annot_smp_per_record = mainwindow->edfheaderlist[i]->edfparam[mainwindow->edfheaderlist[i]->annot_ch[j]].smp_per_record;
}
}
}
}
annot_smp_per_record += 16;
taltime = mainwindow->edfheaderlist[mainwindow->sel_viewtime]->starttime_offset;
duration = 0;
for(i=0; i<signalcomps; i++)
{
if(signalcomp[i]->edfhdr->long_data_record_duration>duration)
{
duration = signalcomp[i]->edfhdr->long_data_record_duration;
n = i;
}
}
fseeko(signalcomp[n]->edfhdr->file_hdl, 244LL, SEEK_SET);
if(fread(datrecduration, 8, 1, signalcomp[n]->edfhdr->file_hdl)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile.");
messagewindow.exec();
return;
}
temp = 0;
for(i=0; i<signalcomps; i++)
{
if(duration % signalcomp[i]->edfhdr->long_data_record_duration)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "This combination of files can not be printed to EDF\n"
"because the quotient of the datarecordblock durations is not an integer.");
messagewindow.exec();
return;
}
duration_factor[signalcomp[i]->filenum] = duration / signalcomp[i]->edfhdr->long_data_record_duration;
temp += signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].smp_per_record;
}
path[0] = 0;
if(mainwindow->recent_savedir[0]!=0)
{
strcpy(path, mainwindow->recent_savedir);
strcat(path, "/");
}
len = strlen(path);
get_filename_from_path(path + len, mainwindow->edfheaderlist[mainwindow->sel_viewtime]->filename, MAX_PATH_LENGTH - len);
remove_extension_from_filename(path);
strcat(path, "_screenprint.edf");
strcpy(path, QFileDialog::getSaveFileName(0, "Print to EDF", QString::fromLocal8Bit(path), "EDF files (*.edf *.EDF)").toLocal8Bit().data());
if(!strcmp(path, ""))
{
return;
}
get_directory_from_path(mainwindow->recent_savedir, path, MAX_PATH_LENGTH);
if(mainwindow->file_is_opened(path))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Error, selected file is in use.");
messagewindow.exec();
return;
}
outputfile = fopeno(path, "wb");
if(outputfile==NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not create a file for writing.");
messagewindow.exec();
return;
}
referencetime = mainwindow->edfheaderlist[mainwindow->sel_viewtime]->utc_starttime;
if(mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime<0)
{
if((-mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime) % TIME_DIMENSION)
{
preamble = TIME_DIMENSION - ((-mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime) % TIME_DIMENSION);
referencetime--;
add_one_sec = 1;
}
}
else
{
preamble = mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime % TIME_DIMENSION;
if(preamble) add_one_sec = 1;
}
for(i=0; i<signalcomps; i++)
{
smpls_preamble[i] = preamble / (signalcomp[i]->edfhdr->long_data_record_duration / signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].smp_per_record);
}
referencetime += (mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime / TIME_DIMENSION);
utc_to_date_time(referencetime, &date_time);
/************************* write EDF-header ***************************************/
rewind(mainwindow->edfheaderlist[mainwindow->sel_viewtime]->file_hdl);
rewind(outputfile);
if(edfplus)
{
if(mainwindow->edfheaderlist[mainwindow->sel_viewtime]->edfplus)
{
if(fread(scratchpad, 88, 1, mainwindow->edfheaderlist[mainwindow->sel_viewtime]->file_hdl)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
if(fwrite(scratchpad, 88, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
else
{
fprintf(outputfile, "0 X X X X ");
if(fread(scratchpad, 88, 1, mainwindow->edfheaderlist[mainwindow->sel_viewtime]->file_hdl)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
if(fwrite(scratchpad + 8, 72, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
fprintf(outputfile, "Startdate %02i-", date_time.day);
switch(date_time.month)
{
case 1 : fprintf(outputfile, "JAN");
break;
case 2 : fprintf(outputfile, "FEB");
break;
case 3 : fprintf(outputfile, "MAR");
break;
case 4 : fprintf(outputfile, "APR");
break;
case 5 : fprintf(outputfile, "MAY");
break;
case 6 : fprintf(outputfile, "JUN");
break;
case 7 : fprintf(outputfile, "JUL");
break;
case 8 : fprintf(outputfile, "AUG");
break;
case 9 : fprintf(outputfile, "SEP");
break;
case 10 : fprintf(outputfile, "OCT");
break;
case 11 : fprintf(outputfile, "NOV");
break;
case 12 : fprintf(outputfile, "DEC");
break;
default : fprintf(outputfile, "ERR");
break;
}
fprintf(outputfile, "-%04i ", date_time.year);
if(mainwindow->edfheaderlist[mainwindow->sel_viewtime]->edfplus)
{
if(fread(scratchpad, 80, 1, mainwindow->edfheaderlist[mainwindow->sel_viewtime]->file_hdl)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
if(scratchpad[10]=='X')
{
if(fwrite(scratchpad + 12, 58, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
else
{
if(fwrite(scratchpad + 22, 58, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
}
else
{
fprintf(outputfile, "X X X ");
if(fread(scratchpad, 80, 1, mainwindow->edfheaderlist[mainwindow->sel_viewtime]->file_hdl)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
if(fwrite(scratchpad + 28, 52, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
}
else
{
if(fread(scratchpad, 168, 1, mainwindow->edfheaderlist[mainwindow->sel_viewtime]->file_hdl)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
if(fwrite(scratchpad, 168, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
fprintf(outputfile,
"%02i.%02i.%02i%02i.%02i.%02i",
date_time.day,
date_time.month,
date_time.year % 100,
date_time.hour,
date_time.minute,
date_time.second);
fprintf(outputfile, "%-8i", (signalcomps + edfplus) * 256 + 256);
if(edfplus)
{
fprintf(outputfile, "EDF+C");
for(i=0; i<39; i++) fputc(' ', outputfile);
}
else for(i=0; i<44; i++) fputc(' ', outputfile);
records = (int)(mainwindow->pagetime / duration);
if(add_one_sec)
{
records += TIME_DIMENSION / duration;
}
fprintf(outputfile, "%-8i", records);
if(fwrite(datrecduration, 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
fprintf(outputfile, "%-4i", signalcomps + edfplus);
for(i=0; i<signalcomps; i++)
{
strcpy(scratchpad, signalcomp[i]->signallabel);
strcat(scratchpad, " ");
if(fwrite(scratchpad, 16, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
if(edfplus)
{
if(fwrite("EDF Annotations ", 16, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
for(i=0; i<signalcomps; i++)
{
if(fwrite(signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].transducer, 80, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
if(edfplus)
{
for(i=0; i<80; i++) fputc(' ', outputfile);
}
for(i=0; i<signalcomps; i++)
{
strcpy(scratchpad, signalcomp[i]->physdimension);
strcat(scratchpad, " ");
if(fwrite(scratchpad, 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
if(edfplus)
{
for(i=0; i<8; i++) fputc(' ', outputfile);
}
for(i=0; i<signalcomps; i++)
{
if((signalcomp[i]->ecg_filter == NULL) && (signalcomp[i]->zratio_filter == NULL))
{
fseeko(signalcomp[i]->edfhdr->file_hdl, (long long)((signalcomp[i]->edfsignal[0] * 8) + (104 * signalcomp[i]->edfhdr->edfsignals) + 256), SEEK_SET);
if(fread(scratchpad, 8, 1, signalcomp[i]->edfhdr->file_hdl)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
if(fwrite(scratchpad, 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
if(signalcomp[i]->ecg_filter != NULL)
{
if(fwrite("0 ", 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
if(signalcomp[i]->zratio_filter != NULL)
{
if(fwrite("-1 ", 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
}
if(edfplus)
{
if(fwrite("-1 ", 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
for(i=0; i<signalcomps; i++)
{
if((signalcomp[i]->ecg_filter == NULL) && (signalcomp[i]->zratio_filter == NULL))
{
fseeko(signalcomp[i]->edfhdr->file_hdl, (long long)((signalcomp[i]->edfsignal[0] * 8) + (112 * signalcomp[i]->edfhdr->edfsignals) + 256), SEEK_SET);
if(fread(scratchpad, 8, 1, signalcomp[i]->edfhdr->file_hdl)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
if(fwrite(scratchpad, 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
if(signalcomp[i]->ecg_filter != NULL)
{
if(fwrite("1000 ", 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
if(signalcomp[i]->zratio_filter != NULL)
{
if(fwrite("1 ", 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
}
if(edfplus)
{
if(fwrite("1 ", 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
for(i=0; i<signalcomps; i++)
{
if((signalcomp[i]->ecg_filter == NULL) && (signalcomp[i]->zratio_filter == NULL))
{
fprintf(outputfile, "%-8i", signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_min);
if(signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_min<0)
{
null_bytes[i].one_signed = 0;
}
else
{
null_bytes[i].one_signed = signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_min;
}
}
else
{
if(fwrite("-32768 ", 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
null_bytes[i].one_signed = -32768;
}
}
if(edfplus)
{
if(fwrite("-32768 ", 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
for(i=0; i<signalcomps; i++)
{
if((signalcomp[i]->ecg_filter == NULL) && (signalcomp[i]->zratio_filter == NULL))
{
fprintf(outputfile, "%-8i", signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_max);
}
else
{
if(fwrite("32767 ", 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
}
if(edfplus)
{
if(fwrite("32767 ", 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
for(i=0; i<signalcomps; i++)
{
strcpy(scratchpad, signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].prefilter);
strcat(scratchpad, " ");
for(p = strlen(scratchpad) - 1; p>=0; p--)
{
if(scratchpad[p]!=' ') break;
}
p++;
if(p) p++;
for(j=0; j<signalcomp[i]->filter_cnt; j++)
{
if(signalcomp[i]->filter[j]->is_LPF == 1)
{
p += sprintf(scratchpad + p, "LP:%f", signalcomp[i]->filter[j]->cutoff_frequency);
}
if(signalcomp[i]->filter[j]->is_LPF == 0)
{
p += sprintf(scratchpad + p, "HP:%f", signalcomp[i]->filter[j]->cutoff_frequency);
}
for(k=(p-1); k>0; k--)
{
if(scratchpad[k]!='0') break;
}
if(scratchpad[k]=='.') scratchpad[k] = 0;
else scratchpad[k+1] = 0;
strcat(scratchpad, "Hz ");
p = strlen(scratchpad);
if(p>80) break;
}
for(j=0; j<signalcomp[i]->fidfilter_cnt; j++)
{
type = signalcomp[i]->fidfilter_type[j];
frequency = signalcomp[i]->fidfilter_freq[j];
frequency2 = signalcomp[i]->fidfilter_freq2[j];
if(type == 0)
{
p += sprintf(scratchpad + p, "HP:%f", frequency);
}
if(type == 1)
{
p += sprintf(scratchpad + p, "LP:%f", frequency);
}
if(type == 2)
{
p += sprintf(scratchpad + p, "N:%f", frequency);
}
if(type == 3)
{
p += sprintf(scratchpad + p, "BP:%f", frequency);
}
if(type == 4)
{
p += sprintf(scratchpad + p, "BS:%f", frequency);
}
for(k=(p-1); k>0; k--)
{
if(scratchpad[k]!='0') break;
}
if(scratchpad[k]=='.') scratchpad[k] = 0;
else scratchpad[k+1] = 0;
p = strlen(scratchpad);
if((type == 3) || (type == 4))
{
p += sprintf(scratchpad + p, "-%f", frequency2);
for(k=(p-1); k>0; k--)
{
if(scratchpad[k]!='0') break;
}
if(scratchpad[k]=='.') scratchpad[k] = 0;
else scratchpad[k+1] = 0;
}
strcat(scratchpad, "Hz ");
p = strlen(scratchpad);
if(p>80) break;
}
for(j=0; j<signalcomp[i]->ravg_filter_cnt; j++)
{
if(signalcomp[i]->ravg_filter_type[j] == 0)
{
p += sprintf(scratchpad + p, "HP:%iSmpls ", signalcomp[i]->ravg_filter[j]->size);
}
if(signalcomp[i]->ravg_filter_type[j] == 1)
{
p += sprintf(scratchpad + p, "LP:%iSmpls ", signalcomp[i]->ravg_filter[j]->size);
}
p = strlen(scratchpad);
if(p>80) break;
}
if(signalcomp[i]->ecg_filter != NULL)
{
p += sprintf(scratchpad + p, "ECG:HR ");
}
if(signalcomp[i]->zratio_filter != NULL)
{
p += sprintf(scratchpad + p, "Z-ratio ");
}
for(;p<81; p++)
{
scratchpad[p] = ' ';
}
if(fwrite(scratchpad, 80, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
if(edfplus)
{
for(i=0; i<80; i++) fputc(' ', outputfile);
}
for(i=0; i<signalcomps; i++)
{
fprintf(outputfile, "%-8i", signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].smp_per_record
* duration_factor[signalcomp[i]->filenum]);
}
if(edfplus)
{
fprintf(outputfile, "%-8i", annot_smp_per_record);
}
for(i=0; i<signalcomps; i++)
{
for(j=0; j<32; j++) fputc(' ', outputfile);
}
if(edfplus)
{
for(i=0; i<32; i++) fputc(' ', outputfile);
}
/////////////////////////////////////////////////////////////////////
for(i=0; i<MAXSIGNALS; i++) smpls_written[i] = 0;
mainwindow->print_to_edf_active = 1;
mainwindow->setup_viewbuf();
viewbuf = mainwindow->viewbuf;
if(viewbuf==NULL)
{
fclose(outputfile);
return;
}
QApplication::setOverrideCursor(Qt::WaitCursor);
for(records_written=0; records_written<records; records_written++)
{
qApp->processEvents();
for(i=0; i<signalcomps; i++)
{
for(k=0; k<signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].smp_per_record * duration_factor[signalcomp[i]->filenum]; k++)
{
if(smpls_preamble[i])
{
smpls_preamble[i]--;
fputc(null_bytes[i].two[0], outputfile);
if(fputc(null_bytes[i].two[1], outputfile)==EOF)
{
QApplication::restoreOverrideCursor();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
else
{
dig_value = 0;
s2 = smpls_written[i] + signalcomp[i]->sample_timeoffset - signalcomp[i]->sample_start;
for(j=0; j<signalcomp[i]->num_of_signals; j++)
{
if((smpls_written[i]<signalcomp[i]->sample_stop)&&(s2>=0))
{
if(signalcomp[i]->edfhdr->edf)
{
temp = *(((short *)(
viewbuf
+ signalcomp[i]->viewbufoffset
+ (signalcomp[i]->edfhdr->recordsize * (s2 / signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[j]].smp_per_record))
+ signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[j]].buf_offset))
+ (s2 % signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[j]].smp_per_record));
}
temp += signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[j]].offset;
temp *= signalcomp[i]->factor[j];
temp -= signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[j]].offset;
}
else
{
temp = 0;
}
dig_value += temp;
}
for(p=0; p<signalcomp[i]->filter_cnt; p++)
{
if(smpls_written[i]==signalcomp[i]->sample_start)
{
if(mainwindow->edfheaderlist[signalcomp[i]->filenum]->viewtime==0)
{
reset_filter(dig_value, signalcomp[i]->filter[p]);
}
else
{
signalcomp[i]->filter[p]->old_input = signalcomp[i]->filterpreset_a[p];
signalcomp[i]->filter[p]->old_output = signalcomp[i]->filterpreset_b[p];
}
}
dig_value = first_order_filter(dig_value, signalcomp[i]->filter[p]);
}
for(p=0; p<signalcomp[i]->ravg_filter_cnt; p++)
{
if(smpls_written[i]==signalcomp[i]->sample_start)
{
if(mainwindow->edfheaderlist[signalcomp[i]->filenum]->viewtime!=0)
{
ravg_filter_restore_buf(signalcomp[i]->ravg_filter[p]);
}
}
dig_value = run_ravg_filter(dig_value, signalcomp[i]->ravg_filter[p]);
}
for(p=0; p<signalcomp[i]->fidfilter_cnt; p++)
{
if(smpls_written[i]==signalcomp[i]->sample_start)
{
if(mainwindow->edfheaderlist[signalcomp[i]->filenum]->viewtime!=0)
{
memcpy(signalcomp[i]->fidbuf[p], signalcomp[i]->fidbuf2[p], fid_run_bufsize(signalcomp[i]->fid_run[p]));
}
}
dig_value = signalcomp[i]->fidfuncp[p](signalcomp[i]->fidbuf[p], dig_value);
}
if(signalcomp[i]->ecg_filter != NULL)
{
if(smpls_written[i]==signalcomp[i]->sample_start)
{
if(mainwindow->edfheaderlist[signalcomp[i]->filenum]->viewtime != 0)
{
ecg_filter_restore_buf(signalcomp[i]->ecg_filter);
}
}
dig_value = run_ecg_filter(dig_value, signalcomp[i]->ecg_filter);
dig_value = (dig_value * signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].bitvalue * 65.536) - 32768.0;
}
if(signalcomp[i]->zratio_filter != NULL)
{
if(smpls_written[i]==signalcomp[i]->sample_start)
{
if(mainwindow->edfheaderlist[signalcomp[i]->filenum]->viewtime != 0)
{
zratio_filter_restore_buf(signalcomp[i]->zratio_filter);
}
}
dig_value = run_zratio_filter(dig_value, signalcomp[i]->zratio_filter);
dig_value = dig_value * signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].bitvalue * 32768.0;
}
if((smpls_written[i]>=signalcomp[i]->sample_start)&&(smpls_written[i]<signalcomp[i]->sample_stop))
{
wr_var.one_signed = dig_value;
if((signalcomp[i]->ecg_filter == NULL) && (signalcomp[i]->zratio_filter == NULL))
{
if(wr_var.one_signed>signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_max)
{
wr_var.one_signed = signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_max;
}
if(wr_var.one_signed<signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_min)
{
wr_var.one_signed = signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_min;
}
}
else
{
if(wr_var.one_signed > 32767)
{
wr_var.one_signed = 32767;
}
if(wr_var.one_signed < -32768)
{
wr_var.one_signed = -32768;
}
}
fputc(wr_var.four[0], outputfile);
if(fputc(wr_var.four[1], outputfile)==EOF)
{
QApplication::restoreOverrideCursor();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
else
{
fputc(null_bytes[i].two[0], outputfile);
if(fputc(null_bytes[i].two[1], outputfile)==EOF)
{
QApplication::restoreOverrideCursor();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
smpls_written[i]++;
}
}
}
if(edfplus)
{
tallen = fprintf(outputfile, "+%i.%07i",
(int)(taltime / TIME_DIMENSION),
(int)(taltime % TIME_DIMENSION));
fputc(20, outputfile);
fputc(20, outputfile);
fputc(0, outputfile);
tallen += 3;
if(annotations_left)
{
if(mainwindow->viewtime_sync==VIEWTIME_SYNCED_ABSOLUT)
{
annot_difftime = (referencetime - mainwindow->edfheaderlist[annotationlist_nr]->utc_starttime) * TIME_DIMENSION;
}
if(mainwindow->viewtime_sync==VIEWTIME_SYNCED_OFFSET)
{
annot_difftime = (referencetime - mainwindow->edfheaderlist[mainwindow->sel_viewtime]->utc_starttime) * TIME_DIMENSION;
}
if((mainwindow->viewtime_sync==VIEWTIME_UNSYNCED) || (mainwindow->viewtime_sync==VIEWTIME_USER_DEF_SYNCED))
{
annot_difftime = (referencetime - mainwindow->edfheaderlist[mainwindow->sel_viewtime]->utc_starttime) * TIME_DIMENSION;
annot_difftime += (mainwindow->edfheaderlist[annotationlist_nr]->viewtime - mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime);
}
if(annotationlist_nr != mainwindow->sel_viewtime)
{
annot_difftime -= mainwindow->edfheaderlist[mainwindow->sel_viewtime]->starttime_offset;
annot_difftime += mainwindow->edfheaderlist[annotationlist_nr]->starttime_offset;
}
}
while(annotations_left)
{
while(!annotations_pntr)
{
annotationlist_nr++;
if(annotationlist_nr>=mainwindow->files_open)
{
annotations_left = 0;
annotations_pntr = NULL;
break;
}
annotations_pntr = mainwindow->annotationlist[annotationlist_nr];
if(mainwindow->viewtime_sync==VIEWTIME_SYNCED_ABSOLUT)
{
annot_difftime = (referencetime - mainwindow->edfheaderlist[annotationlist_nr]->utc_starttime) * TIME_DIMENSION;
}
if(mainwindow->viewtime_sync==VIEWTIME_SYNCED_OFFSET)
{
annot_difftime = (referencetime - mainwindow->edfheaderlist[mainwindow->sel_viewtime]->utc_starttime) * TIME_DIMENSION;
}
if((mainwindow->viewtime_sync==VIEWTIME_UNSYNCED) || (mainwindow->viewtime_sync==VIEWTIME_USER_DEF_SYNCED))
{
annot_difftime = (referencetime - mainwindow->edfheaderlist[mainwindow->sel_viewtime]->utc_starttime) * TIME_DIMENSION;
annot_difftime += (mainwindow->edfheaderlist[annotationlist_nr]->viewtime - mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime);
}
if(annotationlist_nr != mainwindow->sel_viewtime)
{
annot_difftime -= mainwindow->edfheaderlist[mainwindow->sel_viewtime]->starttime_offset;
annot_difftime += mainwindow->edfheaderlist[annotationlist_nr]->starttime_offset;
}
}
if(!annotations_left) break;
if(annotations_pntr)
{
l_temp = annotations_pntr->onset - annot_difftime;
if((l_temp >= 0LL) && (l_temp < (mainwindow->pagetime + TIME_DIMENSION)))
{
tallen += fprintf(outputfile, "%+i.%07i",
(int)(l_temp / TIME_DIMENSION),
(int)(l_temp % TIME_DIMENSION));
if(annotations_pntr->duration[0]!=0)
{
fputc(21, outputfile);
tallen++;
tallen += fprintf(outputfile, "%s", annotations_pntr->duration);
}
fputc(20, outputfile);
tallen++;
tallen += fprintf(outputfile, "%s", annotations_pntr->annotation);
fputc(20, outputfile);
fputc(0, outputfile);
tallen += 2;
annotations_pntr = annotations_pntr->next_annotation;
break;
}
else
{
annotations_pntr = annotations_pntr->next_annotation;
continue;
}
}
}
for(j=tallen; j<(annot_smp_per_record * 2); j++)
{
fputc(0, outputfile);
}
taltime += duration;
}
}
QApplication::restoreOverrideCursor();
fclose(outputfile);
}
