/**
* Compares two lists of files and records the results into the master receipt
*/
void compare_records(FILE *rcpt, FILE *before, FILE *after)
{
struct record *rbef = malloc(sizeof(struct record));
struct record *raft = malloc(sizeof(struct record));
while (read_struct(raft, after) == 0)
{
assert(read_struct(rbef, before) >= 0);
// if there are new files, go until we're synced up
while (strcmp(raft->filename, rbef->filename) != 0)
{
write_struct(raft, rcpt);
free(raft->filename);
if (read_struct(raft, after) != 0)
{
free(rbef->filename);
goto cleanup;
}
}
// file was modified, so record it
if (raft->modified.tv_sec > rbef->modified.tv_sec)
{
write_struct(raft, rcpt);
}
free(raft->filename);
free(rbef->filename);
}
cleanup:
free(rbef);
free(raft);
}
void
write_warmstart(void)
{
(void) write_struct(RPCBFILE, (xdrproc_t)xdr_rpcblist_ptr, &list_rbl);
#ifdef PORTMAP
(void) write_struct(PMAPFILE, (xdrproc_t)xdr_pmaplist_ptr, &list_pml);
#endif
}
int
free_blocknum(int blocknum)
{
vcb_t *vcbp = retrieve_vcb();
free_t freeb;
freeb.f_next = vcbp->vb_free;
if (write_struct(blocknum, &freeb) < 0)
return -1;
vcbp->vb_free = blocknum;
write_struct(0, vcbp);
return 0;
}
static char *def_tuple(CTX *ctx, struct ir_struct_type *st, bool add_names)
{
// NOTE: we use the same C type for empty tuples and compounds; should be ok
if (st->members_count == 0)
return VOID_MANGLE;
char *m = get_mangle(ctx, st);
if (m)
return m;
assert(ctx->writing_types);
m = talloc_strdup(ctx, MANGLE_PREFIX "tuple_");
for (int n = 0; n < st->members_count; n++) {
struct ir_struct_member *sm = st->members[n];
mangle_append_sub(&m, def_type(ctx, sm->type));
assert(add_names == (sm->name[0]));
if (sm->name)
m = talloc_asprintf_append_buffer(m, "n%zd_%s_", strlen(sm->name),
sm->name);
}
if (use_anon_mangle_for_tuples) {
char *new_mangle = HT_GET_DEF(dstr, dstr, ctx->tuple_abbrev, m, NULL);
if (!new_mangle) {
new_mangle = gen_anon_mangle(ctx, "tuple");
HT_INSERT(dstr, dstr, ctx->tuple_abbrev, m, new_mangle);
}
m = new_mangle;
}
add_mangle(ctx, st, m);
if (!check_redef(ctx, m))
write_struct(ctx, st, m);
return m;
}
int issue_noarg_command(u8 cmd)
{
struct noarg_request req;
debug_printf(4, "%s() cmd: %d\n", __func__, cmd);
req.req = cmd;
write_struct(REQM, &req);
return wait_for_response();
}
int card_info_cmd(enum card_info_subcommand cmd)
{
struct card_info_req cir;
cir.o = 'o';
cir.subcommand = cmd;
write_struct(REQM, &cir);
return wait_for_response();
}
int get_log_at_offset(u32 offset)
{
struct fetch_log_cmd cmd;
cmd.m = 'm';
cmd.offset = u32_to_be32(offset);
debug_printf(2, "getting log at offset: %08x\n", offset);
write_struct(REQM, &cmd);
return wait_for_response();
}
void inc_seq(void)
{
/*
* Oddly enough, the sequence number appears
* to be of normal endianness.
*/
//u32 tmpseq = be32_to_u32(seq.seq);
//seq.seq = u32_to_be32(tmpseq+1);
eyefi_seq.seq++;
write_struct(REQC, &eyefi_seq);
}
int
get_free_blocknum()
{
vcb_t *vbp = retrieve_vcb();
int res = vbp->vb_free;
free_t freeb;
if (res > 0)
read_struct(res, &freeb);
vbp->vb_free = freeb.f_next;
write_struct(0, vbp);
return res;
}
static char *def_struct(CTX *ctx, struct ir_struct_type *st)
{
char *m = get_mangle(ctx, st);
if (m)
return m;
assert(ctx->writing_types);
// In theory we must not mangle at all. If there is C code that
// uses the same struct, they must use the same name (and have
// the same members and so on).
// xxx handle structs nested inside functions
m = talloc_strdup(ctx, st->name);
add_mangle(ctx, st, m);
write_struct(ctx, st, m);
return m;
}
int network_action(char cmd, char *essid, char *ascii_password)
{
struct net_request nr;
memset(&nr, 0, sizeof(nr));
nr.req = cmd;
strcpy(&nr.essid[0], essid);
nr.essid_len = strlen(essid);
if (ascii_password) {
int ret = make_network_key(&nr.key, essid, ascii_password);
if (ret)
return ret;
}
write_struct(REQM, &nr);
return wait_for_response();
}
/*{{{ write_synamps_exit(transform_info_ptr tinfo) {*/
METHODDEF void
write_synamps_exit(transform_info_ptr tinfo) {
struct write_synamps_storage *local_arg=(struct write_synamps_storage *)tinfo->methods->local_storage;
#define SETUP_OFFSET_NSWEEPS 360
#define SETUP_OFFSET_NUMSAMPLES 864
#define SETUP_OFFSET_EVENTTABLEPOS 886
/* Apparently NeuroScan write this even for epoched files although there's no event table there...
* It is important there to compute bytes_per_sample */
local_arg->EEG.EventTablePos=ftell(local_arg->SCAN);
if (local_arg->output_format==FORMAT_CNTFILE) {
TEEG TagType;
EVENT1 event;
int const nevents=local_arg->triggers.current_length/sizeof(struct trigger);
int n;
TagType.Teeg=TEEG_EVENT_TAB1;
TagType.Size=(nevents+1)*sm_EVENT1[0].offset; /* sm_EVENT1[0].offset is sizeof(EVENT1) in the file. */
TagType.p_o.Offset=0L;
# ifndef LITTLE_ENDIAN
change_byteorder((char *)&TagType, sm_TEEG);
# endif
write_struct((char *)&TagType, sm_TEEG, local_arg->SCAN);
for (n=0; n<nevents; n++) {
struct trigger * const intrig=((struct trigger *)local_arg->triggers.buffer_start)+n;
int acc=NAV_STARTSTOP, type=0, resp=0, keyboard=0;
while (acc>=0 && intrig->code!=neuroscan_accept_translation[acc]) acc--;
if (acc<0) {
acc=0;
if (intrig->code>0) {
type=intrig->code;
} else {
resp=(-intrig->code)&0xf;
if (resp==0) {
keyboard=(-intrig->code)>>4;
if (keyboard==0) {
TRACEMS1(tinfo->emethods, 1, "write_synamps_exit: Can't decipher event code %d\n", MSGPARM(intrig->code));
} else {
keyboard--;
}
}
}
}
/*{{{ write_rec_close_file(transform_info_ptr tinfo) {*/
LOCAL void
write_rec_close_file(transform_info_ptr tinfo) {
struct write_rec_storage *local_arg=(struct write_rec_storage *)tinfo->methods->local_storage;
char numbuf[NUMBUF_LENGTH];
snprintf(numbuf, NUMBUF_LENGTH, "%ld", local_arg->nr_of_records);
memset(&local_arg->fheader.nr_of_records, ' ', sizeof(local_arg->fheader.nr_of_records));
copy_nstring(local_arg->fheader.nr_of_records, numbuf, sizeof(local_arg->fheader.nr_of_records));
fseek(local_arg->outfptr, 0L, SEEK_SET);
#ifndef LITTLE_ENDIAN
change_byteorder((char *)&local_arg->fheader, sm_REC_file);
#endif
write_struct((char *)&local_arg->fheader, sm_REC_file, local_arg->outfptr);
if (local_arg->outfptr!=stdout && local_arg->outfptr!=stderr) {
fclose(local_arg->outfptr);
} else {
fflush(local_arg->outfptr);
}
}
/**
* Recurses a given directory pointer, and writes data to the file
* pointer when it finds files
*/
void record_files(char *path, DIR *dp, FILE *fp)
{
struct dirent *ent;
while ((ent = readdir(dp)) != NULL)
{
// skip dot files
if (ent->d_name[0] != '.')
{
int pathsize = strlen(path) + ent->d_namlen + 2;
char *newpath = malloc(pathsize * sizeof(char));
snprintf(newpath, pathsize, "%s/%s", path, ent->d_name);
if (ent->d_type == DT_DIR)
{
DIR *ndp = opendir(newpath);
// we don't have permission, continue
if (ndp == NULL)
{
continue;
}
record_files(newpath, ndp, fp);
closedir(ndp);
}
else
{
struct stat info;
assert(stat(newpath, &info) == 0);
struct record rec;
rec.filename = newpath;
rec.modified = info.st_mtimespec;
write_struct(&rec, fp);
}
free(newpath);
}
}
}
/*{{{ write_synamps(transform_info_ptr tinfo) {*/
METHODDEF DATATYPE *
write_synamps(transform_info_ptr calltinfo) {
struct write_synamps_storage *local_arg=(struct write_synamps_storage *)calltinfo->methods->local_storage;
transform_argument *args=calltinfo->methods->arguments;
NEUROSCAN_EPOCHED_SWEEP_HEAD sweephead;
long tsdata_step, tsdata_steps, tsdata_stepwidth;
array myarray;
/* Note that 'tinfo' instead of 'tinfoptr' is used here so that we don't have to modify
* all of the older code which stored only one epoch */
transform_info_ptr tinfo=calltinfo;
if (args[ARGS_LINKED].is_set) {
/* Go to the start: */
for (; tinfo->previous!=NULL; tinfo=tinfo->previous);
}
for (; tinfo!=NULL; tinfo=tinfo->next) {
DATATYPE * const orig_tsdata=tinfo->tsdata;
/*{{{ Assert that epoch size didn't change & itemsize==1*/
if (tinfo->itemsize!=1) {
ERREXIT(tinfo->emethods, "write_synamps: Only itemsize=1 is supported.\n");
}
if (local_arg->EEG.nchannels!=tinfo->nr_of_channels) {
ERREXIT2(tinfo->emethods, "write_synamps: nr_of_channels was %d, now %d\n", MSGPARM(local_arg->EEG.nchannels), MSGPARM(tinfo->nr_of_channels));
}
/*}}} */
if (tinfo->data_type==FREQ_DATA) {
tinfo->nr_of_points=tinfo->nroffreq;
tsdata_steps=tinfo->nrofshifts;
tsdata_stepwidth=tinfo->nr_of_channels*tinfo->nroffreq*tinfo->itemsize;
} else {
tsdata_steps=1;
tsdata_stepwidth=0;
}
for (tsdata_step=0; tsdata_step<tsdata_steps; tinfo->tsdata+=tsdata_stepwidth, tsdata_step++) {
switch (local_arg->output_format) {
case FORMAT_EEGFILE:
if (local_arg->EEG.pnts!=tinfo->nr_of_points) {
ERREXIT2(tinfo->emethods, "write_synamps: nr_of_points was %d, now %d\n", MSGPARM(local_arg->EEG.pnts), MSGPARM(tinfo->nr_of_points));
}
/*{{{ Set sweephead values*/
sweephead.accept=1;
sweephead.type=254;
sweephead.correct=0;
sweephead.rt=0;
sweephead.response=0;
if (tinfo->condition>0) {
sweephead.type=tinfo->condition&0xff;
} else if (tinfo->condition<0 && (-tinfo->condition)<=0xf) {
sweephead.type=0;
sweephead.response= -tinfo->condition;
} else {
/* KeyBoard event: Do it the same way 'Edit' does when epoching,
* mapping F1 to type=1 and so on (overlap with stim codes, but they
* should know how they want it...) */
sweephead.type= (-tinfo->condition)>>4;
}
/*}}} */
/*{{{ Write sweephead struct*/
# ifndef LITTLE_ENDIAN
change_byteorder((char *)&sweephead, sm_NEUROSCAN_EPOCHED_SWEEP_HEAD);
# endif
write_struct((char *)&sweephead, sm_NEUROSCAN_EPOCHED_SWEEP_HEAD, local_arg->SCAN);
# ifndef LITTLE_ENDIAN
change_byteorder((char *)&sweephead, sm_NEUROSCAN_EPOCHED_SWEEP_HEAD);
# endif
/*}}} */
local_arg->EEG.nsweeps++; /* This gets patched into the header by write_synamps_exit */
local_arg->EEG.compsweeps++;
local_arg->EEG.acceptcnt++;
break;
case FORMAT_AVGFILE:
if (local_arg->EEG.NumSamples!=0) {
ERREXIT(tinfo->emethods, "write_synamps: Only a single epoch may be written to an .AVG file!\n");
}
case FORMAT_CNTFILE:
if (tinfo->triggers.buffer_start!=NULL) {
struct trigger *intrig=(struct trigger *)tinfo->triggers.buffer_start+1;
while (intrig->code!=0) {
push_trigger(&local_arg->triggers,local_arg->EEG.NumSamples+intrig->position,intrig->code,intrig->description);
intrig++;
}
}
local_arg->EEG.NumSamples+=tinfo->nr_of_points;
break;
}
tinfo_array(tinfo, &myarray);
if (local_arg->output_format==FORMAT_AVGFILE) {
/* points are the elements */
float *pdata, * const buffer=(float *)malloc(myarray.nr_of_elements*sizeof(float));
const char *fill="\0\0\0\0\0";
if (buffer==NULL) {
ERREXIT(tinfo->emethods, "write_synamps: Error allocating AVGFILE buffer\n");
}
do {
int const channel=myarray.current_vector;
/* Write the `5-byte channel header that is no longer used' */
fwrite(fill, 1, 5, local_arg->SCAN);
pdata=buffer;
do {
*pdata=NEUROSCAN_FLOATCONV(&local_arg->Channels[channel], array_scan(&myarray));
# ifndef LITTLE_ENDIAN
Intel_float(pdata);
# endif
pdata++;
} while (myarray.message==ARRAY_CONTINUE);
if ((int)fwrite(buffer,sizeof(float),myarray.nr_of_elements,local_arg->SCAN)!=myarray.nr_of_elements) {
ERREXIT(tinfo->emethods, "write_synamps: Error writing data point\n");
}
} while (myarray.message!=ARRAY_ENDOFSCAN);
free(buffer);
} else {
int16_t * const buffer=(int16_t *)malloc(myarray.nr_of_vectors*sizeof(int16_t));
if (buffer==NULL) {
ERREXIT(tinfo->emethods, "write_synamps: Error allocating buffer\n");
}
array_transpose(&myarray); /* channels are the elements */
do {
int channel=0;
do {
DATATYPE hold=array_scan(&myarray), hold2;
/* Code anything exceeding the representable range, including +-Inf, as min/max representable value. */
hold2=NEUROSCAN_SHORTCONV(&local_arg->Channels[channel], hold);
if (hold2< -32768) hold2= -32768;
else if (hold2> 32767) hold2= 32767;
buffer[channel]=(int16_t)hold2;
# ifndef LITTLE_ENDIAN
Intel_int16(&buffer[channel]);
# endif
channel++;
} while (myarray.message==ARRAY_CONTINUE);
if ((int)fwrite(buffer,sizeof(int16_t),myarray.nr_of_elements,local_arg->SCAN)!=myarray.nr_of_elements) {
ERREXIT(tinfo->emethods, "write_synamps: Error writing data point\n");
}
} while (myarray.message!=ARRAY_ENDOFSCAN);
free(buffer);
}
} /* FREQ_DATA shifts loop */
tinfo->tsdata=orig_tsdata;
if (!args[ARGS_LINKED].is_set) {
break;
}
} /* Linked epochs loop */
return calltinfo->tsdata; /* Simply to return something `useful' */
}
/*{{{ write_rec_open_file(transform_info_ptr tinfo) {*/
LOCAL void
write_rec_open_file(transform_info_ptr tinfo) {
struct write_rec_storage *local_arg=(struct write_rec_storage *)tinfo->methods->local_storage;
transform_argument *args=tinfo->methods->arguments;
FILE *outfptr=NULL;
if (strcmp(args[ARGS_OFILE].arg.s, "stdout")==0) outfptr=stdout;
else if (strcmp(args[ARGS_OFILE].arg.s, "stderr")==0) outfptr=stderr;
local_arg->appendmode=args[ARGS_APPEND].is_set;
if (local_arg->appendmode) {
/*{{{ Append mode open if cofile exists and is of non-zero length*/
if (outfptr==NULL) {
if ((outfptr=fopen(args[ARGS_OFILE].arg.s, "r+b"))!=NULL) {
fseek(outfptr, 0L, SEEK_END);
if (ftell(outfptr)==0L) {
local_arg->appendmode=FALSE; /* If at start: write header */
}
}
}
/*}}} */
}
if (outfptr==NULL) {
/*{{{ Open the REC file in truncate mode*/
local_arg->appendmode=FALSE; /* write header */
if ((outfptr=fopen(args[ARGS_OFILE].arg.s, "wb"))==NULL) {
ERREXIT1(tinfo->emethods, "write_rec_open_file: Can't open %s\n", MSGPARM(args[ARGS_OFILE].arg.s));
}
/*}}} */
}
local_arg->outfptr=outfptr;
if (local_arg->appendmode) {
/* Read rather than write header in append mode */
fseek(outfptr, 0L, SEEK_SET);
if (read_struct((char *)&local_arg->fheader, sm_REC_file, outfptr)==0) {
ERREXIT1(tinfo->emethods, "write_rec_open_file: Can't read header in file %s\n", MSGPARM(args[ARGS_OFILE].arg.s));
}
# ifndef LITTLE_ENDIAN
change_byteorder((char *)&local_arg->fheader, sm_REC_file);
# endif
local_arg->nr_of_records=atoi(local_arg->fheader.nr_of_records);
fseek(outfptr, 0L, SEEK_END);
} else {
/*{{{ Write header*/
REC_channel_header channelheader;
const long channelheader_length=CHANNELHEADER_SIZE_PER_CHANNEL*tinfo->nr_of_channels;
int channel;
short dd, mm, yy, yyyy, hh, mi, ss;
char numbuf[NUMBUF_LENGTH];
setlocale(LC_NUMERIC, "C"); /* Print fractional numbers with decimal point */
#define fileheader local_arg->fheader
memset(&fileheader, ' ', sizeof(REC_file_header));
copy_nstring(fileheader.version, "0", sizeof(fileheader.version));
if (args[ARGS_PATIENT].is_set) copy_nstring(fileheader.patient, args[ARGS_PATIENT].arg.s, sizeof(fileheader.patient));
if (args[ARGS_RECORDING].is_set) copy_nstring(fileheader.recording, args[ARGS_RECORDING].arg.s, sizeof(fileheader.recording));
if (args[ARGS_DATETIME].is_set) {
char * const comma=strchr(args[ARGS_DATETIME].arg.s, ',');
if (comma==NULL) {
ERREXIT(tinfo->emethods, "write_rec_open_file: Datetime format is dd.mm.yy,hh.mi.ss !\n");
}
copy_nstring(fileheader.startdate, args[ARGS_DATETIME].arg.s, sizeof(fileheader.startdate));
copy_nstring(fileheader.starttime, comma+1, sizeof(fileheader.starttime));
} else if (tinfo->comment!=NULL) {
if (!args[ARGS_RECORDING].is_set) copy_nstring(fileheader.recording, tinfo->comment, sizeof(fileheader.recording));
if (comment2time(tinfo->comment, &dd, &mm, &yy, &yyyy, &hh, &mi, &ss)) {
snprintf(numbuf, NUMBUF_LENGTH, "%02d.%02d.%02d", dd, mm, yy);
copy_nstring(fileheader.startdate, numbuf, sizeof(fileheader.startdate));
snprintf(numbuf, NUMBUF_LENGTH, "%02d.%02d.%02d", hh, mi, ss);
copy_nstring(fileheader.starttime, numbuf, sizeof(fileheader.starttime));
}
}
if (*fileheader.startdate==' ') {
/* Date/time weren't set otherwise: */
copy_nstring(fileheader.startdate, "00.00.00", sizeof(fileheader.startdate));
copy_nstring(fileheader.starttime, "00.00.00", sizeof(fileheader.starttime));
}
snprintf(numbuf, NUMBUF_LENGTH, "%ld", sm_REC_file[0].offset+channelheader_length);
copy_nstring(fileheader.bytes_in_header, numbuf, sizeof(fileheader.bytes_in_header));
copy_nstring(fileheader.data_format_version, (args[ARGS_DATA_FORMAT_VERSION].is_set ? args[ARGS_DATA_FORMAT_VERSION].arg.s : "write_rec file"), sizeof(fileheader.data_format_version));
local_arg->nr_of_records=0;
copy_nstring(fileheader.nr_of_records, "-1", sizeof(fileheader.nr_of_records));
snprintf(numbuf, NUMBUF_LENGTH, "%g", ((double)local_arg->samples_per_record)/tinfo->sfreq);
copy_nstring(fileheader.duration_s, numbuf, sizeof(fileheader.duration_s));
snprintf(numbuf, NUMBUF_LENGTH, "%d", tinfo->nr_of_channels);
copy_nstring(fileheader.nr_of_channels, numbuf, sizeof(fileheader.nr_of_channels));
#ifndef LITTLE_ENDIAN
change_byteorder((char *)&fileheader, sm_REC_file);
#endif
write_struct((char *)&fileheader, sm_REC_file, outfptr);
#ifndef LITTLE_ENDIAN
change_byteorder((char *)&fileheader, sm_REC_file);
#endif
#undef fileheader
if ((channelheader.label=(char (*)[16])malloc(channelheader_length))==NULL) {
ERREXIT(tinfo->emethods, "write_rec_open_file: Error allocating channelheader memory\n");
}
channelheader.transducer=(char (*)[80])(channelheader.label+tinfo->nr_of_channels);
channelheader.dimension=(char (*)[8])(channelheader.transducer+tinfo->nr_of_channels);
channelheader.physmin=(char (*)[8])(channelheader.dimension+tinfo->nr_of_channels);
channelheader.physmax=(char (*)[8])(channelheader.physmin+tinfo->nr_of_channels);
channelheader.digmin=(char (*)[8])(channelheader.physmax+tinfo->nr_of_channels);
channelheader.digmax=(char (*)[8])(channelheader.digmin+tinfo->nr_of_channels);
channelheader.prefiltering=(char (*)[80])(channelheader.digmax+tinfo->nr_of_channels);
channelheader.samples_per_record=(char (*)[8])(channelheader.prefiltering+tinfo->nr_of_channels);
channelheader.reserved=(char (*)[32])(channelheader.samples_per_record+tinfo->nr_of_channels);
memset(channelheader.label, ' ', channelheader_length);
for (channel=0; channel<tinfo->nr_of_channels; channel++) {
copy_nstring(channelheader.dimension[channel], "uV", sizeof(channelheader.dimension[channel]));
copy_nstring(channelheader.label[channel], tinfo->channelnames[channel], sizeof(channelheader.label[channel]));
snprintf(numbuf, NUMBUF_LENGTH, "%g", (double)local_arg->digmin*local_arg->resolution);
copy_nstring(channelheader.physmin[channel], numbuf, sizeof(channelheader.physmin[channel]));
snprintf(numbuf, NUMBUF_LENGTH, "%g", (double)local_arg->digmax*local_arg->resolution);
copy_nstring(channelheader.physmax[channel], numbuf, sizeof(channelheader.physmax[channel]));
snprintf(numbuf, NUMBUF_LENGTH, "%ld", local_arg->digmin);
copy_nstring(channelheader.digmin[channel], numbuf, sizeof(channelheader.digmin[channel]));
snprintf(numbuf, NUMBUF_LENGTH, "%ld", local_arg->digmax);
copy_nstring(channelheader.digmax[channel], numbuf, sizeof(channelheader.digmax[channel]));
snprintf(numbuf, NUMBUF_LENGTH, "%ld", local_arg->samples_per_record);
copy_nstring(channelheader.samples_per_record[channel], numbuf, sizeof(channelheader.samples_per_record[channel]));
}
setlocale(LC_NUMERIC, ""); /* Reset locale to environment */
if (tinfo->nr_of_channels!=(int)fwrite((void *)channelheader.label, CHANNELHEADER_SIZE_PER_CHANNEL, tinfo->nr_of_channels, local_arg->outfptr)) {
ERREXIT(tinfo->emethods, "write_rec_open_file: Error writing channel headers\n");
}
free(channelheader.label);
/*}}} */
}
}
/*{{{ write_vitaport_exit(transform_info_ptr tinfo) {*/
METHODDEF void
write_vitaport_exit(transform_info_ptr tinfo) {
struct write_vitaport_storage *local_arg=(struct write_vitaport_storage *)tinfo->methods->local_storage;
int channel, NoOfChannels=local_arg->fileheader.knum;
long point;
long const channellen=local_arg->total_points*sizeof(uint16_t);
long const hdlen=local_arg->fileheader.hdlen;
uint16_t checksum=0;
local_arg->fileheaderII.dlen=hdlen+NoOfChannels*channellen;
/*{{{ Write the file headers*/
# ifdef LITTLE_ENDIAN
change_byteorder((char *)&local_arg->fileheader, sm_vitaport_fileheader);
change_byteorder((char *)&local_arg->fileheaderII, sm_vitaportII_fileheader);
change_byteorder((char *)&local_arg->fileext, sm_vitaportII_fileext);
# endif
write_struct((char *)&local_arg->fileheader, sm_vitaport_fileheader, local_arg->outfile);
write_struct((char *)&local_arg->fileheaderII, sm_vitaportII_fileheader, local_arg->outfile);
write_struct((char *)&local_arg->fileext, sm_vitaportII_fileext, local_arg->outfile);
/*}}} */
for (channel=0; channel<NoOfChannels; channel++) {
/*{{{ Write a channel header*/
/* This is the factor as we'd like to have it... */
float factor=((float)(local_arg->channelmax[channel]> -local_arg->channelmin[channel] ? local_arg->channelmax[channel] : -local_arg->channelmin[channel]))/SHRT_MAX;
if (strncmp(local_arg->channelheaders[channel].kname, VP_MARKERCHANNEL_NAME, 6)==0) {
strcpy(local_arg->channelheaders[channel].kunit, "mrk");
local_arg->channelheaders[channel].datype=VP_DATYPE_MARKER;
/* Since the marker channel is read without the conversion factors,
* set the conversion to 1.0 for this channel */
local_arg->channelheaders[channel].mulfac=local_arg->channelheaders[channel].divfac=1;
local_arg->channelheaders[channel].offset=0;
} else {
float const logdiff=log(factor)-TARGET_LOG_SHORTVAL;
local_arg->channelheaders[channel].offset=0;
if (logdiff<0) {
/*{{{ Factor is small: Better to fix divfac and calculate mulfac after that*/
double const divfac=exp(-logdiff);
if (divfac>SHRT_MAX) {
local_arg->channelheaders[channel].divfac=SHRT_MAX;
} else {
local_arg->channelheaders[channel].divfac=(unsigned short)divfac;
}
/* The +1 takes care that we never get below the `ideal' factor computed above. */
local_arg->channelheaders[channel].mulfac=(unsigned short)(factor*local_arg->channelheaders[channel].divfac+1);
if (local_arg->channelheaders[channel].mulfac==0) {
local_arg->channelheaders[channel].mulfac=1;
local_arg->channelheaders[channel].divfac=(unsigned short)(1.0/factor-1);
}
/*}}} */
} else {
/*{{{ Factor is large: Better to fix mulfac and calculate divfac after that*/
double const mulfac=exp(logdiff);
if (mulfac>SHRT_MAX) {
local_arg->channelheaders[channel].mulfac=SHRT_MAX;
} else {
local_arg->channelheaders[channel].mulfac=(unsigned short)mulfac;
}
/* The -1 takes care that we never get below the `ideal' factor computed above. */
local_arg->channelheaders[channel].divfac=(unsigned short)(local_arg->channelheaders[channel].mulfac/factor-1);
if (local_arg->channelheaders[channel].divfac==0) {
local_arg->channelheaders[channel].mulfac=(unsigned short)(factor+1);
local_arg->channelheaders[channel].divfac=1;
}
/*}}} */
}
}
/* Now see which factor we actually got constructed */
factor=((float)local_arg->channelheaders[channel].mulfac)/local_arg->channelheaders[channel].divfac;
local_arg->channelheadersII[channel].doffs=channel*channellen;
local_arg->channelheadersII[channel].dlen=channellen;
# ifdef LITTLE_ENDIAN
change_byteorder((char *)&local_arg->channelheaders[channel], sm_vitaport_channelheader);
change_byteorder((char *)&local_arg->channelheadersII[channel], sm_vitaportIIrchannelheader);
# endif
write_struct((char *)&local_arg->channelheaders[channel], sm_vitaport_channelheader, local_arg->outfile);
write_struct((char *)&local_arg->channelheadersII[channel], sm_vitaportIIrchannelheader, local_arg->outfile);
# ifdef LITTLE_ENDIAN
change_byteorder((char *)&local_arg->channelheaders[channel], sm_vitaport_channelheader);
change_byteorder((char *)&local_arg->channelheadersII[channel], sm_vitaportIIrchannelheader);
# endif
/*}}} */
}
fwrite(&checksum, sizeof(checksum), 1, local_arg->outfile);
TRACEMS(tinfo->emethods, 1, "write_vitaport_exit: Copying channels to output file...\n");
/* We close and re-open the channel file because buffering is much more
* efficient at least with DJGPP if the file is either only read or written */
fclose(local_arg->channelfile);
if ((local_arg->channelfile=fopen(local_arg->channelfilename, "rb"))==NULL) {
ERREXIT1(tinfo->emethods, "write_vitaport_exit: Can't open temp file %s\n", MSGPARM(local_arg->channelfilename));
}
for (channel=0; channel<NoOfChannels; channel++) {
/*{{{ Copy a channel to the target file */
float const factor=((float)local_arg->channelheaders[channel].mulfac)/local_arg->channelheaders[channel].divfac;
unsigned short const offset=local_arg->channelheaders[channel].offset;
for (point=0; point<local_arg->total_points; point++) {
DATATYPE dat;
int16_t s;
fseek(local_arg->channelfile, (point*NoOfChannels+channel)*sizeof(DATATYPE), SEEK_SET);
if (fread(&dat, sizeof(DATATYPE), 1, local_arg->channelfile)!=1) {
ERREXIT(tinfo->emethods, "write_vitaport_exit: Error reading temp file.\n");
}
s= (int16_t)rint(dat/factor)-offset;
# ifdef LITTLE_ENDIAN
Intel_int16((uint16_t *)&s);
# endif
if (fwrite(&s, sizeof(s), 1, local_arg->outfile)!=1) {
ERREXIT(tinfo->emethods, "write_vitaport_exit: Write error.\n");
}
}
/*}}} */
}
fclose(local_arg->channelfile);
unlink(local_arg->channelfilename);
if (local_arg->triggers.current_length!=0) {
long tagno, n_events;
uint32_t length, trigpoint;
int const nevents=local_arg->triggers.current_length/sizeof(struct trigger);
struct vitaport_idiotic_multiplemarkertablenames *markertable_entry;
/* Try to keep a security space of at least 20 free events */
for (markertable_entry=markertable_names; markertable_entry->markertable_name!=NULL && markertable_entry->idiotically_fixed_length<nevents+20; markertable_entry++);
if (markertable_entry->markertable_name==NULL) {
if ((markertable_entry-1)->idiotically_fixed_length<=nevents) {
/* Drop the requirement for at least 20 free events */
markertable_entry--;
} else {
/* No use... */
ERREXIT1(tinfo->emethods, "write_vitaport_exit: %d events wouldn't fit into the fixed-length VITAGRAPH marker tables!\nBlame the Vitaport people!\n", MSGPARM(nevents));
}
}
n_events=markertable_entry->idiotically_fixed_length;
fwrite(markertable_entry->markertable_name, 1, VP_TABLEVAR_LENGTH, local_arg->outfile);
length=n_events*sizeof(length);
#ifdef LITTLE_ENDIAN
Intel_int32((uint32_t *)&length);
#endif
fwrite(&length, sizeof(length), 1, local_arg->outfile);
for (tagno=0; tagno<n_events; tagno++) {
if (tagno<nevents) {
struct trigger * const intrig=((struct trigger *)local_arg->triggers.buffer_start)+tagno;
/* Trigger positions are given in ms units */
trigpoint=(long)rint(intrig->position*1000.0/local_arg->sfreq);
/* Make trigpoint uneven if code%2==1 */
trigpoint=trigpoint-trigpoint%2+(intrig->code-1)%2;
} else {
trigpoint= -1;
}
#ifdef LITTLE_ENDIAN
Intel_int32((uint32_t *)&trigpoint);
#endif
fwrite(&trigpoint, sizeof(trigpoint), 1, local_arg->outfile);
}
for (; tagno<n_events; tagno++) {
trigpoint= -1;
#ifdef LITTLE_ENDIAN
Intel_int32((uint32_t *)&trigpoint);
#endif
fwrite(&trigpoint, sizeof(trigpoint), 1, local_arg->outfile);
}
}
fclose(local_arg->outfile);
/*{{{ Free memory*/
free_pointer((void **)&local_arg->channelfilename);
free_pointer((void **)&local_arg->channelmax);
free_pointer((void **)&local_arg->channelmin);
free_pointer((void **)&local_arg->channelheaders);
free_pointer((void **)&local_arg->channelheadersII);
if (local_arg->triggers.buffer_start!=NULL) {
clear_triggers(&local_arg->triggers);
growing_buf_free(&local_arg->triggers);
}
/*}}} */
tinfo->methods->init_done=FALSE;
}
int
add_data_block(inode_t *inodep, int blocknum)
/* add this blocknum to the direct or indirects of the inodep
Returns 0 on success, -1 on error */
{
if (inodep->i_blocks < 106){
inodep->i_direct[inodep->i_blocks] = blocknum;
inodep->i_blocks++;
return 0;
} else if (inodep->i_blocks < 235) {
int single = inodep->i_single;
indirect_t single_indrect;
if (inodep->i_blocks == 106){
/* add single indirect first */
single = get_free_blocknum();
if (single < 0)
return -1;
inodep->i_blocks++;
inodep->i_single = single;
clear_indirect(&single_indrect);
write_struct(single, &single_indrect);
}
/* add blocknum */
read_struct(single, &single_indrect);
single_indrect.index[(inodep->i_blocks - 107)%128] = blocknum;
if (write_struct(single, &single_indrect) < 0)
return -1;
inodep->i_blocks++;
return 0;
} else {
int double_block_i = inodep->i_double;
int index_block_i;
indirect_t double_indirect;
indirect_t index_block;
int double_block_off = (inodep->i_blocks-236) / 129;
if (inodep->i_blocks == 235){
/* add double indirect block */
double_block_i = get_free_blocknum();
if (double_block_i < 0)
return -1;
inodep->i_blocks++;
inodep->i_double = double_block_i;
clear_indirect(&double_indirect);
index_block_i = get_free_blocknum();
if (index_block_i< 0)
return -1;
inodep->i_blocks++;
double_indirect.index[0] = index_block_i;
clear_indirect(&index_block);
inodep->i_blocks++;
if (write_struct(double_block_i, &double_indirect) < 0)
return -1;
if (write_struct(index_block_i, &index_block) < 0)
return -1;
}
else if ((inodep->i_blocks-236)%129 == 0){
index_block_i = get_free_blocknum();
if (index_block_i < 0)
return -1;
read_struct(double_block_i, &double_indirect);
double_indirect.index[double_block_off] = index_block_i;
inodep->i_blocks++;
clear_indirect(&index_block);
if (write_struct(double_block_i, &double_indirect) < 0)
return -1;
if (write_struct(index_block_i, &index_block) < 0)
return -1;
}
int index_block_off = inodep->i_blocks - 238 - 129 * double_block_off;
read_struct(double_block_i, &double_indirect);
index_block_i = double_indirect.index[double_block_off];
read_struct(index_block_i, &index_block);
index_block.index[index_block_off] = blocknum;
if (write_struct(index_block_i, &index_block) < 0)
return -1;
inodep->i_blocks++;
return 0;
}
}
int
format_disk(int size) /* size: total number of blocks on disk */
{
/* format disk following rules:
+ vcb
+ inode table
- root
- others
+ root dirent
+ free blocks
Returns 0 on success, or -1 on error */
int min_required_blocks;
int free_starter;
int root_dirent_block;
int valid_block;
int insert_block;
struct timespec *now;
entry_t entry;
dirent_t root_dirent;
free_t free_b;
inode_t inode;
valid_t valid;
min_required_blocks = 1 /* vcb */
+ I_TABLE_SIZE /* inode table */
+ 1 /* valid table */
+ 1 /* root dirent */;
if (size < min_required_blocks){
err("size must be at least %d", min_required_blocks);
return -1;
}
free_starter = min_required_blocks;
valid_block = free_starter -2;
vcb.vb_magic = MAGIC;
vcb.vb_blocksize = BLOCKSIZE;
vcb.vb_root = 1;
vcb.vb_free = free_starter;
vcb.vb_itable_size = I_TABLE_SIZE;
vcb.vb_clean = true;
vcb.vb_valid = valid_block;
if (write_struct(0, &vcb) < 0) /* vcb */
return -1;
vcb_initialized = true;
insert_block = free_starter - 1;
root_dirent_block = insert_block;
if (!(now = get_time()))
return -1;
inode.i_ino = 1;
inode.i_type = S_IFDIR;
inode.i_size = 2;
inode.i_uid = getuid();
inode.i_gid = getgid();
inode.i_mode = 0777;
inode.i_blocks = 1;
inode.i_atime = *now;
inode.i_mtime = *now;
inode.i_ctime = *now;
inode.i_direct[0] = root_dirent_block;
for (int i=1; i<106; i++){
inode.i_direct[i] = -1;
}
inode.i_single = -1;
inode.i_double = -1;
root = inode;
if (write_struct(1, &root) < 0) /* root inode */
return -1;
root_initialized = true;
inode.i_ino = 0;
inode.i_direct[0] = -1;
for (int i=2; i<I_TABLE_SIZE+1; i++){
if ( write_struct(i, &inode) < 0 ) /* the rest of I-node table */
return -1;
}
valid.v_entries[1] = V_USED;
for (int i=2; i<I_TABLE_SIZE+1; i++){
valid.v_entries[i] = V_UNUSED;
}
if (write_struct(valid_block, &valid) < 0) /* valid table */
return -1;
clear_dirent(&root_dirent);
entry.et_ino = 1;
strcpy(entry.et_name, "."); /* . entry */
root_dirent.d_entries[0] = entry;
strcpy(entry.et_name, ".."); /* .. entry */
root_dirent.d_entries[1] = entry;
if ( write_struct(root_dirent_block, &root_dirent) < 0 ) /* root dirent */
return -1;
for (int i=free_starter; i<size-1; i++){
free_b.f_next = i + 1;
if ( write_struct(i, &free_b) < 0 )
return -1;
}
free_b.f_next = -1;
if ( write_struct(size-1, &free_b) < 0 ) /* free blocks */
return -1;
return 0;
}
SaveResult write_bmp(const FilePath& filePath,
const Bitmap& bmp,
BitmapQuality quality)
{
BinaryWriter out(filePath);
if (!out.good()){
return SaveResult::SaveFailed(error_open_file_write(filePath));
}
const auto bitsPerPixel = bits_per_pixel(quality);
const IntSize size(bmp.GetSize());
const int rowStride = bmp_row_stride(bitsPerPixel, size.w);
switch(quality){
// Note: No default, to ensure warning if unhandled enum value
case BitmapQuality::COLOR_8BIT:
{
const auto pixelData = quantized(bmp, Dithering::ON);
PaletteColors paletteColors(pixelData.palette.size());
write_struct(out,
create_bitmap_file_header(paletteColors, rowStride, size.h));
write_struct(out,
create_bitmap_info_header_8bipp(bmp.GetSize(),
default_DPI(),
PaletteColors(pixelData.palette.size()),
false));
write_8bipp_BI_RGB(out, pixelData);
return SaveResult::SaveSuccessful();
}
case BitmapQuality::GRAY_8BIT:
{
MappedColors pixelData(desaturate_AlphaMap(bmp), grayscale_color_table());
PaletteColors paletteColors(pixelData.palette.size());
write_struct(out,
create_bitmap_file_header(paletteColors, rowStride, size.h));
write_struct(out,
create_bitmap_info_header_8bipp(bmp.GetSize(),
default_DPI(),
PaletteColors(pixelData.palette.size()),
false));
write_8bipp_BI_RGB(out, pixelData);
return SaveResult::SaveSuccessful();
}
case BitmapQuality::COLOR_24BIT:
{
write_struct(out,
create_bitmap_file_header(PaletteColors(0), rowStride, size.h));
write_struct(out,
create_bitmap_info_header_24bipp(bmp.GetSize(),
default_DPI(),
false));
write_24bipp_BI_RGB(out, bmp);
return SaveResult::SaveSuccessful();
}
}
assert(false);
return SaveResult::SaveFailed(utf8_string("Internal error in save_bitmap"));
}
/*{{{ write_synamps_init(transform_info_ptr tinfo) {*/
METHODDEF void
write_synamps_init(transform_info_ptr tinfo) {
struct write_synamps_storage *local_arg=(struct write_synamps_storage *)tinfo->methods->local_storage;
transform_argument *args=tinfo->methods->arguments;
double xmin, xmax, ymin, ymax;
int NoOfChannels=tinfo->nr_of_channels;
int channel;
growing_buf_init(&local_arg->triggers);
local_arg->output_format=(args[ARGS_OUTPUTFORMAT].is_set ? (enum output_formats)args[ARGS_OUTPUTFORMAT].arg.i : FORMAT_EEGFILE);
local_arg->SCAN=fopen(args[ARGS_OFILE].arg.s, "r+b");
if (!args[ARGS_APPEND].is_set || local_arg->SCAN==NULL) { /* target does not exist*/
/*{{{ Create file*/
if (local_arg->SCAN!=NULL) fclose(local_arg->SCAN);
/*{{{ Calculate the span in x-y channel positions*/
xmin=ymin= FLT_MAX;
xmax=ymax= -FLT_MAX;
for (channel=0; channel<tinfo->nr_of_channels; channel++) {
const double this_x=tinfo->probepos[3*channel], this_y=tinfo->probepos[3*channel+1];
if (this_x>xmax) xmax=this_x;
if (this_x<xmin) xmin=this_x;
if (this_y>ymax) ymax=this_y;
if (this_y<ymin) ymin=this_y;
}
if (xmax==xmin) {
xmax+=0.5;
xmin-=0.5;
}
if (ymax==ymin) {
ymax+=0.5;
ymin-=0.5;
}
/*}}} */
if ((local_arg->SCAN=fopen(args[ARGS_OFILE].arg.s, "wb"))==NULL) {
ERREXIT1(tinfo->emethods, "write_synamps_init: Can't open %s\n", MSGPARM(args[ARGS_OFILE].arg.s));
}
/*{{{ Many settings, taken from example files...*/
strcpy(local_arg->EEG.rev, "Version 3.0");
local_arg->EEG.AdditionalFiles=local_arg->EEG.NextFile=local_arg->EEG.PrevFile=0;
switch (local_arg->output_format) {
case FORMAT_EEGFILE:
local_arg->EEG.review = 1;
local_arg->EEG.savemode=NSM_EEGF;
local_arg->EEG.type = NTY_EPOCHED;
local_arg->EEG.ContinousType=0;
local_arg->EEG.nsweeps=local_arg->EEG.compsweeps=local_arg->EEG.acceptcnt=0;
break;
case FORMAT_CNTFILE:
local_arg->EEG.review = 1;
local_arg->EEG.savemode=NSM_CONT;
local_arg->EEG.type = 0;
local_arg->EEG.ContinousType=NST_SYNAMPS-NST_CONT0;
local_arg->EEG.nsweeps=1;
local_arg->EEG.compsweeps=local_arg->EEG.acceptcnt=0;
break;
case FORMAT_AVGFILE:
local_arg->EEG.review = 0;
local_arg->EEG.savemode=NSM_AVGD;
local_arg->EEG.type = NTY_AVERAGED;
local_arg->EEG.ContinousType=0;
local_arg->EEG.nsweeps=local_arg->EEG.compsweeps=local_arg->EEG.acceptcnt=(tinfo->nrofaverages>0 ? tinfo->nrofaverages : 1);
break;
}
/* Since the comment can be of arbitrary length and thus also larger than the
* rest of the header, we should limit ourselves to the size of the id field */
strncpy(local_arg->EEG.id, tinfo->comment, sizeof(local_arg->EEG.id));
/* The date is coded in the comment, and read_synamps appends the date and time
* from the corresponding fields and the contents of the id field, so that
* the comment2time reader could be confused by the two date/time fields if we
* would not somehow invalidate remnants of the date field here... */
{char *slash;
while ((slash=strchr(local_arg->EEG.id, '/'))!=NULL) {
*slash='|';
}
}
strcpy(local_arg->EEG.oper, "Unspecified");
strcpy(local_arg->EEG.doctor, "Unspecified");
strcpy(local_arg->EEG.referral, "Unspecified");
strcpy(local_arg->EEG.hospital, "Unspecified");
strcpy(local_arg->EEG.patient, "Unspecified");
local_arg->EEG.age = 0;
local_arg->EEG.sex = 'U';
local_arg->EEG.hand = 'U';
strcpy(local_arg->EEG.med, "Unspecified");
strcpy(local_arg->EEG.category, "Unspecified");
strcpy(local_arg->EEG.state, "Unspecified");
strcpy(local_arg->EEG.label, "Unspecified");
{short dd, mm, yy, yyyy, hh, mi, ss;
if (comment2time(tinfo->comment, &dd, &mm, &yy, &yyyy, &hh, &mi, &ss)) {
char buffer[16]; /* Must be long enough to fit date (10) and time (12) +1 */
/* This is necessary because the date field was devised for 2-digit years.
* With 4-digit years it uses all 10 bytes and the trailing zero
* does not fit in any more. */
snprintf(buffer, 16, "%02d/%02d/%04d", mm, dd, yyyy);
strncpy(local_arg->EEG.date, buffer, sizeof(local_arg->EEG.date));
snprintf(buffer, 16, "%02d:%02d:%02d", hh, mi, ss);
strncpy(local_arg->EEG.time, buffer, sizeof(local_arg->EEG.time));
}
}
local_arg->EEG.rejectcnt = 0;
local_arg->EEG.pnts=(tinfo->data_type==FREQ_DATA ? tinfo->nroffreq : tinfo->nr_of_points);
local_arg->EEG.nchannels=NoOfChannels;
local_arg->EEG.avgupdate=1;
local_arg->EEG.domain=(tinfo->data_type==FREQ_DATA ? 1 : 0);
local_arg->EEG.variance=0;
local_arg->EEG.rate=(uint16_t)rint(tinfo->sfreq);
if (tinfo->data_type==FREQ_DATA) {
/* I know that this field is supposed to contain the taper window size in %,
but we need some way to store basefreq and 'rate' is only integer... */
local_arg->EEG.SpectWinLength=tinfo->basefreq;
}
if (local_arg->EEG.rate==0) {
local_arg->EEG.rate=1;
TRACEMS(tinfo->emethods, 0, "write_synamps_init: Rate was zero, corrected to 1!\n");
}
local_arg->EEG.scale=3.4375; /* This is a common sensitivity factor, used if sensitivities for channels are zero */
local_arg->EEG.veogcorrect=0;
local_arg->EEG.heogcorrect=0;
local_arg->EEG.aux1correct=0;
local_arg->EEG.aux2correct=0;
local_arg->EEG.veogtrig=15; /* Trigger threshold in percent of the maximum */
local_arg->EEG.heogtrig=10;
local_arg->EEG.aux1trig=10;
local_arg->EEG.aux2trig=10;
local_arg->EEG.veogchnl=find_channel_number(tinfo, "VEOG");
local_arg->EEG.heogchnl=find_channel_number(tinfo, "HEOG");
local_arg->EEG.veogdir=0; /* 0=positive, 1=negative */
local_arg->EEG.veog_n=10; /* "Number of points per waveform", really: minimum acceptable # averages */
local_arg->EEG.heog_n=10;
local_arg->EEG.veogmaxcnt=(int16_t)rint(0.3*tinfo->sfreq); /* "Number of observations per point", really: event window size in points */
local_arg->EEG.heogmaxcnt=(int16_t)rint(0.5*tinfo->sfreq);
local_arg->EEG.AmpSensitivity=10; /* External Amplifier gain */
local_arg->EEG.baseline=0;
local_arg->EEG.reject=0;
local_arg->EEG.trigtype=2; /* 2=Port */
local_arg->EEG.trigval=255; /* Hold */
local_arg->EEG.dir=0; /* Invert (negative up)=0 */
local_arg->EEG.dispmin= -1; /* displayed y range */
local_arg->EEG.dispmax= +1;
local_arg->EEG.DisplayXmin=local_arg->EEG.AutoMin=local_arg->EEG.rejstart=local_arg->EEG.offstart=local_arg->EEG.xmin= -tinfo->beforetrig/tinfo->sfreq;
local_arg->EEG.DisplayXmax=local_arg->EEG.AutoMax=local_arg->EEG.rejstop=local_arg->EEG.offstop=local_arg->EEG.xmax= tinfo->aftertrig/tinfo->sfreq;
local_arg->EEG.zmin=0.0;
local_arg->EEG.zmax=0.1;
strcpy(local_arg->EEG.ref, "A1-A2");
strcpy(local_arg->EEG.screen, "--------");
local_arg->EEG.CalMode=2;
local_arg->EEG.CalMethod=0;
local_arg->EEG.CalUpdate=1;
local_arg->EEG.CalBaseline=0;
local_arg->EEG.CalSweeps=5;
local_arg->EEG.CalAttenuator=1;
local_arg->EEG.CalPulseVolt=1;
local_arg->EEG.CalPulseStart=0;
local_arg->EEG.CalPulseStop=0;
local_arg->EEG.CalFreq=10;
strcpy(local_arg->EEG.taskfile, "--------");
strcpy(local_arg->EEG.seqfile, "--------"); /* Otherwise tries to read a seqfile */
local_arg->EEG.HeadGain=150;
local_arg->EEG.FspFValue=2.5;
local_arg->EEG.FspBlockSize=200;
local_arg->EEG.fratio=1.0;
local_arg->EEG.minor_rev=12; /* Necessary ! Otherwise a different file structure is assumed... */
local_arg->EEG.eegupdate=1;
local_arg->EEG.xscale=local_arg->EEG.yscale=0;
local_arg->EEG.xsize=40;
local_arg->EEG.ysize=20;
local_arg->EEG.ACmode=0;
local_arg->EEG.XScaleValue=XSCALEVALUE;
local_arg->EEG.XScaleInterval=XSCALEINTERVAL;
local_arg->EEG.YScaleValue=YSCALEVALUE;
local_arg->EEG.YScaleInterval=YSCALEINTERVAL;
local_arg->EEG.ScaleToolX1=20;
local_arg->EEG.ScaleToolY1=170;
local_arg->EEG.ScaleToolX2=23.1535;
local_arg->EEG.ScaleToolY2=153.87;
local_arg->EEG.port=715;
local_arg->EEG.NumSamples=0;
local_arg->EEG.FilterFlag=0;
local_arg->EEG.LowCutoff=4;
local_arg->EEG.LowPoles=2;
local_arg->EEG.HighCutoff=50;
local_arg->EEG.HighPoles=2;
local_arg->EEG.FilterType=3;
local_arg->EEG.FilterDomain=1;
local_arg->EEG.SnrFlag=0;
local_arg->EEG.CoherenceFlag=0;
local_arg->EEG.ContinousSeconds=4;
local_arg->EEG.ChannelOffset=sizeof(int16_t);
local_arg->EEG.AutoCorrectFlag=0;
local_arg->EEG.DCThreshold='F';
/*}}} */
/*{{{ Write SETUP structure*/
# ifndef LITTLE_ENDIAN
change_byteorder((char *)&local_arg->EEG, sm_SETUP);
# endif
write_struct((char *)&local_arg->EEG, sm_SETUP, local_arg->SCAN);
# ifndef LITTLE_ENDIAN
change_byteorder((char *)&local_arg->EEG, sm_SETUP);
# endif
/*}}} */
if ((local_arg->Channels=(ELECTLOC *)calloc(NoOfChannels,sizeof(ELECTLOC)))==NULL) {
ERREXIT(tinfo->emethods, "write_synamps_init: Error allocating Channels list\n");
}
for (channel=0; channel<NoOfChannels; channel++) {
/*{{{ Settings in the channel structure*/
strncpy(local_arg->Channels[channel].lab, tinfo->channelnames[channel],sizeof(local_arg->Channels[channel].lab));
local_arg->Channels[channel].reference=0;
local_arg->Channels[channel].skip=0;
local_arg->Channels[channel].reject=0;
local_arg->Channels[channel].display=1;
local_arg->Channels[channel].bad=0;
local_arg->Channels[channel].n=(local_arg->output_format==FORMAT_AVGFILE ? local_arg->EEG.acceptcnt : (local_arg->output_format==FORMAT_CNTFILE ? 0 : 1));
local_arg->Channels[channel].avg_reference=0;
local_arg->Channels[channel].ClipAdd=0;
local_arg->Channels[channel].x_coord= (tinfo->probepos[3*channel ]-xmin)/(xmax-xmin)*RANGE_TO_COVER+XOFFSET;
local_arg->Channels[channel].y_coord=((ymax-tinfo->probepos[3*channel+1])/(ymax-ymin)*RANGE_TO_COVER+YOFFSET)/3;
local_arg->Channels[channel].veog_wt=0;
local_arg->Channels[channel].veog_std=0;
local_arg->Channels[channel].heog_wt=0;
local_arg->Channels[channel].heog_std=0;
local_arg->Channels[channel].baseline=0;
local_arg->Channels[channel].Filtered=0;
local_arg->Channels[channel].sensitivity=204.8/args[ARGS_CONVFACTOR].arg.d; /* This arranges for conv_factor to act as the expected product before integer truncation */
local_arg->Channels[channel].Gain=5;
local_arg->Channels[channel].HiPass=0; /* 0=DC */
local_arg->Channels[channel].LoPass=4;
local_arg->Channels[channel].Page=0;
local_arg->Channels[channel].Size=0;
local_arg->Channels[channel].Impedance=0;
local_arg->Channels[channel].PhysicalChnl=channel; /* Channel mapping */
local_arg->Channels[channel].Rectify=0;
local_arg->Channels[channel].calib=1.0;
/*}}} */
/*{{{ Write ELECTLOC struct*/
# ifndef LITTLE_ENDIAN
change_byteorder((char *)&local_arg->Channels[channel], sm_ELECTLOC);
# endif
write_struct((char *)&local_arg->Channels[channel], sm_ELECTLOC, local_arg->SCAN);
# ifndef LITTLE_ENDIAN
change_byteorder((char *)&local_arg->Channels[channel], sm_ELECTLOC);
# endif
/*}}} */
}
local_arg->SizeofHeader = ftell(local_arg->SCAN);
TRACEMS2(tinfo->emethods, 1, "write_synamps_init: Creating file %s, format `%s'\n", MSGPARM(args[ARGS_OFILE].arg.s), MSGPARM(neuroscan_subtype_names[NEUROSCAN_SUBTYPE(&local_arg->EEG)]));
/*}}} */
} else {
/*{{{ Append to file*/
enum NEUROSCAN_SUBTYPES SubType;
if (read_struct((char *)&local_arg->EEG, sm_SETUP, local_arg->SCAN)==0) {
ERREXIT(tinfo->emethods, "write_synamps_init: Can't read file header.\n");
}
# ifndef LITTLE_ENDIAN
change_byteorder((char *)&local_arg->EEG, sm_SETUP);
# endif
NoOfChannels = local_arg->EEG.nchannels;
/*{{{ Allocate channel header*/
if ((local_arg->Channels=(ELECTLOC *)malloc(NoOfChannels*sizeof(ELECTLOC)))==NULL) {
ERREXIT(tinfo->emethods, "write_synamps_init: Error allocating Channels list\n");
}
/*}}} */
for (channel=0; channel<NoOfChannels; channel++) {
if (read_struct((char *)&local_arg->Channels[channel], sm_ELECTLOC, local_arg->SCAN)==0) {
ERREXIT(tinfo->emethods, "write_synamps_init: Can't read channel headers.\n");
}
# ifndef LITTLE_ENDIAN
change_byteorder((char *)&local_arg->Channels[channel], sm_ELECTLOC);
# endif
}
local_arg->SizeofHeader = ftell(local_arg->SCAN);
SubType=NEUROSCAN_SUBTYPE(&local_arg->EEG);
switch (SubType) {
case NST_EPOCHS:
if (local_arg->output_format!=FORMAT_EEGFILE) {
TRACEMS(tinfo->emethods, 0, "write_synamps_init: Appending to epoch file, discarding option -c\n");
local_arg->output_format=FORMAT_EEGFILE;
}
fseek(local_arg->SCAN, 0, SEEK_END);
break;
case NST_CONTINUOUS:
case NST_SYNAMPS: {
TEEG TagType;
EVENT1 event;
if (local_arg->output_format!=FORMAT_CNTFILE) {
TRACEMS(tinfo->emethods, 0, "write_synamps_init: Appending to continuous file, assuming option -c\n");
local_arg->output_format=FORMAT_CNTFILE;
}
fseek(local_arg->SCAN, local_arg->EEG.EventTablePos, SEEK_SET);
/* Here we face two evils in one header: Coding enums as chars and
* allowing longs at odd addresses. Well... */
if (1==read_struct((char *)&TagType, sm_TEEG, local_arg->SCAN)) {
# ifndef LITTLE_ENDIAN
change_byteorder((char *)&TagType, sm_TEEG);
# endif
if (TagType.Teeg==TEEG_EVENT_TAB1) {
/*{{{ Read the event table*/
int tag;
int const ntags=TagType.Size/sm_EVENT1[0].offset; /* sm_EVENT1[0].offset is sizeof(EVENT1) in the file. */
for (tag=0; tag<ntags; tag++) {
if (1!=read_struct((char *)&event, sm_EVENT1, local_arg->SCAN)) {
ERREXIT(tinfo->emethods, "write_synamps_init: Can't read an event table entry.\n");
break;
}
# ifndef LITTLE_ENDIAN
change_byteorder((char *)&event, sm_EVENT1);
# endif
{
int const TrigVal=event.StimType &0xff;
int const KeyBoard=event.KeyBoard&0xf;
int const KeyPad=Event_KeyPad_value(event);
int const Accept=Event_Accept_value(event);
int code=TrigVal-KeyPad+neuroscan_accept_translation[Accept];
if (code==0) {
code= -((KeyBoard+1)<<4);
}
push_trigger(&local_arg->triggers,offset2point(tinfo, event.Offset),code,NULL);
}
}
/*}}} */
} else {
ERREXIT(tinfo->emethods, "write_synamps_init: Type 2 events are not yet supported.\n");
}
} else {
ERREXIT(tinfo->emethods, "write_synamps_init: Can't read the event table header.\n");
}
fseek(local_arg->SCAN, local_arg->EEG.EventTablePos, SEEK_SET);
}
break;
default:
ERREXIT1(tinfo->emethods, "write_synamps: Cannot append to file type `%s'\n", MSGPARM(neuroscan_subtype_names[SubType]));
break;
}
/* Conformance to the incoming epochs is checked in write_synamps */
TRACEMS1(tinfo->emethods, 1, "write_synamps_init: Appending to file %s\n", MSGPARM(args[ARGS_OFILE].arg.s));
/*}}} */
}
tinfo->methods->init_done=TRUE;
}
void testit0(void)
{
char c;
struct testbuf tb;
int i;
int fdin;
int fdout;
//start_direct();
print_direct_status();
//enable_direct_mode(60, 120);
enable_direct_mode(DIRECT_WAIT_FOREVER, DIRECT_WAIT_FOREVER);
print_direct_status();
start_direct();
exit(0);
//char new_cmd[] = {'O', 0x06, 0x0d, 0x0a, 0x31, 0x30, 0x2e, 0x36, 0x2e, 0x30, 0x2e, 0x31, 0x33, 0x37};
//printf("waiting...\n");
//print_transfer_status();
//exit(0);
//int doagain = 1;
//wlan_disable(0);
//int to_test[] = {5, 8, 9, 11, 15, 16, 255, -1};
int to_test[] = {0xFF, -1};
zero_card_files();
for (i = 0; i < 100; i++) {
print_transfer_status();
}
exit(0);
while (1) {
//fprintf(stderr, "testing...\n");
for (i = 0; i < 255; i++) {
int cmd = to_test[i];
if (cmd == -1)
break;
//zero_card_files();
card_info_cmd(cmd);
printf("UNKNOWN %3d result: ", cmd);
int printed = dumpbuf(eyefi_buf, 256);
if (!printed)
printf("\n");
print_transfer_status();
print_connected_to();
}
}
exit(0);
scan_print_nets();
printf("WLAN enabled: %d\n", wlan_enabled());
//wlan_disable();
printf("WLAN enabled: %d\n", wlan_enabled());
for (i = 10; i <= 13; i++) {
int printed;
zero_card_files();
card_info_cmd(i);
printf("UNKNOWN %d result:\n", i);
printed = dumpbuf(eyefi_buf, 64);
printf("WLAN enabled: %d\n", wlan_enabled());
}
i = 0xff;
card_info_cmd(i);
printf("UNKNOWN %d result:", i);
dumpbuf(eyefi_buf, 64);
exit(3);
card_info_cmd(3);
printf("o3 result:\n");
dumpbuf(eyefi_buf, 64);
memset(&zbuf[0], 0, EYEFI_BUF_SIZE);
zbuf[0] = 'o';
zbuf[1] = 2;
write_to(REQM, &zbuf[0], 16384);
printf("o2 written\n");
printf("seq: %x\n", (int)eyefi_seq.seq);
inc_seq();
for (i=0; i < 4; i++) {
read_from(RSPC);
printf("RSPC %d:\n", i);
dumpbuf(eyefi_buf, 64);
usleep(20000);
}
printf("RSPM1:\n");
read_from(RSPM);
dumpbuf(eyefi_buf, 64);
memset(&zbuf[0], 0, EYEFI_BUF_SIZE);
write_to(RSPM, zbuf, EYEFI_BUF_SIZE);
write_to(REQM, zbuf, EYEFI_BUF_SIZE);
fdin = open("/home/dave/projects/eyefi/EYEFIFWU.BIN.2.0001", O_RDONLY);
perror("fdin");
fdout = open("/media/EYE-FI/EYEFIFWU.BIN", O_WRONLY|O_CREAT);
perror("fdout");
if (fdin <= 0 || fdout <= 0)
exit(1);
fd_flush(fdin);
i = read(fdin, &fwbuf[0], 524288);
perror("read");
if (i != 524288)
exit(2);
i = write(fdout, &fwbuf[0], 524288);
fd_flush(fdout);
perror("write");
if (i != 524288)
exit(3);
printf("RSPM2:\n");
read_from(RSPM);
dumpbuf(eyefi_buf, 64);
reboot_card();
printf("after reboot:\n");
dumpbuf(eyefi_buf, 64);
printf("cic3:\n");
card_info_cmd(3);
dumpbuf(eyefi_buf, 64);
printf("cic2:\n");
card_info_cmd(2);
dumpbuf(eyefi_buf, 64);
memset(&zbuf[0], 0, EYEFI_BUF_SIZE);
write_to(RSPM, zbuf, EYEFI_BUF_SIZE);
write_to(REQM, zbuf, EYEFI_BUF_SIZE);
printf("cic2v2:\n");
card_info_cmd(2);
dumpbuf(eyefi_buf, 64);
exit(0);
strcpy(tb.name, "www.sr71.net/");
tb.l1 = strlen(tb.name);
for (i = 0; i < 10; i++) {
tb.cmd = 'O';
tb.l1 = i;
write_struct(RSPM, &z);
write_struct(REQM, &tb);
wait_for_response();
printf("buffer after O %d:\n", i);
dumpbuf(eyefi_buf, 64);
printf("----------------\n");
write_struct(REQM, &tb);
card_info_cmd(i);
printf("card info(%d):\n", i);
dumpbuf(eyefi_buf, 64);
printf("-----------\n");
}
return;
strcpy(tb.name, "/public/eyefi/servname");
strcpy(tb.name, "/config/networks.xml");
//tb.len = strlen(tb.name);
tb.l1 = 0;
for (c = 'O'; c <= 'O'; c++) {
tb.cmd = c;
write_struct(REQM, &tb);
wait_for_response();
printf("dumping buffer:\n");
dumpbuf(eyefi_buf, 64);
printf("buffer dump done\n");
}
}