int FillChansetStruct(SUDS *S, SUDS_CHANSET *cs, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; int j; if(!cs) return 0; bytesRead = fread(&(cs->type),1, 2,ptr); bytesRead += fread(&(cs->entries),1, 2,ptr); bytesRead += fread(cs->network,1, 4,ptr); bytesRead += fread(cs->name,1, 5,ptr); bytesRead += fread(&(cs->active),1, 4,ptr); bytesRead += fread(&(cs->inactive),1, 4,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert2(&(cs->type)); Convert2(&(cs->entries)); Convert4(&(cs->active)); Convert4(&(cs->inactive)); } if(Tag.len_data){ S->csTail->entry = (CHANSETENTRY *) malloc( cs->entries * sizeof(CHANSETENTRY) ); bytesRead = 0; for(j=0;j<cs->entries;j++){ bytesRead += fread(&(S->csTail->entry[j].inst_num), 1, 4, ptr); if(CheckByteOrder() == ENDIAN_BIG) { Convert4(&(S->csTail->entry[j].inst_num)); } bytesRead += fread(&(S->csTail->entry[j].stream_num), 1, 2, ptr); if(CheckByteOrder() == ENDIAN_BIG) { Convert2(&(S->csTail->entry[j].stream_num)); } bytesRead += fread(&(S->csTail->entry[j].chan_num), 1, 2, ptr); if(CheckByteOrder() == ENDIAN_BIG) { Convert2(&(S->csTail->entry[j].chan_num)); } bytesRead += ReadStatIdent(&(S->csTail->entry[j].st), ptr); } if(bytesRead != Tag.len_data){ printf("ERROR: Expected to read %d bytes but got %d instead.\n", Tag.len_data, bytesRead); return 0; } return 1; } return 1; }
int FillLayersStruct(SUDS_LAYERS *la, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; if(!la) return 0; bytesRead = fread(&(la->thickness),1, 4,ptr); bytesRead += fread(&(la->pveltop),1, 4,ptr); bytesRead += fread(&(la->pvelbase),1, 4,ptr); bytesRead += fread(&(la->sveltop),1, 4,ptr); bytesRead += fread(&(la->svelbase),1, 4,ptr); bytesRead += fread(&(la->function),1, 2,ptr); bytesRead += fread(&(la->spareF),1, 2,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert4(&(la->thickness)); Convert4(&(la->pveltop)); Convert4(&(la->pvelbase)); Convert4(&(la->sveltop)); Convert4(&(la->svelbase)); Convert2(&(la->function)); Convert2(&(la->spareF)); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillInstrumentStruct(SUDS_INSTRUMENT *in, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; if(!in) return 0; bytesRead = ReadStatIdent(&(in->in_name), ptr); bytesRead += fread(&(in->in_serial),1, 2,ptr); bytesRead += fread(&(in->comps),1, 2,ptr); bytesRead += fread(&(in->channel),1, 2,ptr); bytesRead += fread(&(in->sens_type),1, 1,ptr); bytesRead += fread(&(in->datatype),1, 1,ptr); bytesRead += fread(&(in->void_samp),1, 4,ptr); bytesRead += fread(&(in->dig_con),1, 4,ptr); bytesRead += fread(&(in->aa_corner),1, 4,ptr); bytesRead += fread(&(in->aa_poles),1, 4,ptr); bytesRead += fread(&(in->nat_freq),1, 4,ptr); bytesRead += fread(&(in->damping),1, 4,ptr); bytesRead += fread(&(in-> mot_con),1, 4,ptr); bytesRead += fread(&(in->gain),1, 4,ptr); bytesRead += fread(&(in->local_x),1, 4,ptr); bytesRead += fread(&(in->local_y),1, 4,ptr); bytesRead += fread(&(in->local_z),1, 4,ptr); bytesRead += fread(&(in->effective),1, 4,ptr); bytesRead += fread(&(in->pre_event),1, 4,ptr); bytesRead += fread(&(in->trig_num),1, 2,ptr); bytesRead += fread(in->study,1, 6,ptr); in->study[5] = '\0'; bytesRead += fread(&(in->sn_serial),1, 2,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert2(&(in->in_serial)); Convert2(&(in->comps)); Convert2(&(in->channel)); Convert4(&(in->void_samp)); Convert4(&(in->dig_con)); Convert4(&(in->aa_corner)); Convert4(&(in->aa_poles)); Convert4(&(in->nat_freq)); Convert4(&(in->damping)); Convert4(&(in-> mot_con)); Convert4(&(in->gain)); Convert4(&(in->local_x)); Convert4(&(in->local_y)); Convert4(&(in->local_z)); Convert4(&(in->effective)); Convert4(&(in->pre_event)); Convert2(&(in->trig_num)); Convert2(&(in->sn_serial)); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillTriggerStruct(SUDS_TRIGGERS *tr, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; if(!tr) return 0; bytesRead = ReadStatIdent(&(tr->tr_name), ptr); bytesRead += fread(&(tr->sta),1, 2,ptr); bytesRead += fread(&(tr->lta),1, 2,ptr); bytesRead += fread(&(tr->abs_sta),1, 2,ptr); bytesRead += fread(&(tr->abs_lta),1, 2,ptr); bytesRead += fread(&(tr->trig_value),1, 2,ptr); bytesRead += fread(&(tr->num_triggers),1, 2,ptr); bytesRead += fread(&(tr->trig_time),1, 8,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert2(&(tr->sta)); Convert2(&(tr->lta)); Convert2(&(tr->abs_sta)); Convert2(&(tr->abs_lta)); Convert2(&(tr->trig_value)); Convert2(&(tr->num_triggers)); Convert8(&(tr->trig_time)); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillMomentStruct(SUDS_MOMENT *mo, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; int j; if(!mo) return 0; bytesRead = fread(&(mo->datatypes),1, 1,ptr); bytesRead += fread(&(mo->constraints),1, 1,ptr); bytesRead += fread(mo->spareD,1, 2,ptr); mo->spareD[1] = '\0'; bytesRead += fread(&(mo->sc_moment),1, 4,ptr); bytesRead += fread(mo->norm_ten,1, 24,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert4(&(mo->sc_moment)); for(j=0;j<6;j++) Convert4(&(mo->norm_ten[j])); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillCommentStruct(SUDS *S, SUDS_COMMENT *co, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; if(!co) return 0; bytesRead = fread(&(co->refer),1, 2,ptr); bytesRead += fread(&(co->item),1, 2,ptr); bytesRead += fread(&(co->length),1, 2,ptr); bytesRead += fread(&(co->unused),1, 2,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert2(&(co->refer)); Convert2(&(co->item)); Convert2(&(co->length)); Convert2(&(co->unused)); } if(Tag.len_data){ S->coTail->text = (char *) calloc(1, co->length * sizeof(char) ); bytesRead = fread(S->coTail->text, 1, sizeof(char) * co->length, ptr); if(bytesRead != Tag.len_data){ printf("ERROR: Expected to read %d bytes but got %d instead.\n", Tag.len_data, bytesRead); return 0; } S->coTail->text[co->length - 1] = '\0'; return 1; } return 1; }
int FillTimeCorrectionStruct(SUDS_TIMECORRECTION *tc, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; if(!tc) return 0; bytesRead = ReadStatIdent(&(tc->tm_name), ptr); bytesRead += fread(&(tc->time_correct),1, 8,ptr); bytesRead += fread(&(tc->rate_correct),1, 4,ptr); bytesRead += fread(&(tc->sync_code),1, 1,ptr); bytesRead += fread(&(tc->program),1, 1,ptr); bytesRead += fread(&(tc->effective_time),1, 4,ptr); bytesRead += fread(&(tc->spareM),1, 2,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert8(&(tc->time_correct)); Convert4(&(tc->rate_correct)); Convert4(&(tc->effective_time)); Convert2(&(tc->spareM)); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillEVDescriptStruct(SUDS_EVDESCR *ed, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; if(!ed) return 0; bytesRead = fread(&(ed->eqname),1, 20,ptr); bytesRead += fread(&(ed->country),1, 16,ptr); bytesRead += fread(&(ed->state),1, 16,ptr); bytesRead += fread(&(ed->localtime),1, 2,ptr); bytesRead += fread(&(ed->spareB),1, 2,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; ed->eqname[19] = '\0'; ed->country[15] = '\0'; ed->state[15] = '\0'; if(CheckByteOrder() == ENDIAN_BIG) { Convert2(&(ed->localtime)); Convert2(&(ed->spareB)); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillFocalMechStruct(SUDS_FOCALMECH *fo, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; if(!fo) return 0; bytesRead = fread(&(fo->astrike),1, 4,ptr); bytesRead += fread(&(fo->adip),1, 4,ptr); bytesRead += fread(&(fo->arake),1, 4,ptr); bytesRead += fread(&(fo->bstrike),1, 4,ptr); bytesRead += fread(&(fo->bdip),1, 4,ptr); bytesRead += fread(&(fo->brake),1, 4,ptr); bytesRead += fread(&(fo->prefplane),1, 1,ptr); bytesRead += fread(&(fo->spareC),1, 3,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; fo->spareC[2] = '\0'; if(CheckByteOrder() == ENDIAN_BIG) { Convert4(&(fo->astrike)); Convert4(&(fo->adip)); Convert4(&(fo->arake)); Convert4(&(fo->bstrike)); Convert4(&(fo->bdip)); Convert4(&(fo->brake)); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillEventStruct(SUDS_EVENT *ev, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; if(!ev) return 0; bytesRead = fread(&(ev->authority),1, 2,ptr); bytesRead += fread(&(ev->number),1, 4,ptr); bytesRead += fread(&(ev->felt),1, 2,ptr); bytesRead += fread(&(ev->mintensity),1, 1,ptr); bytesRead += fread(&(ev->ev_type),1, 1,ptr); bytesRead += fread(&(ev->tectonism),1, 1,ptr); bytesRead += fread(&(ev->waterwave),1, 1,ptr); bytesRead += fread(&(ev->mechanism),1, 1,ptr); bytesRead += fread(&(ev->medium),1, 1,ptr); bytesRead += fread(&(ev->size),1, 4,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert2(&(ev->authority)); Convert4(&(ev->number)); Convert2(&(ev->felt)); Convert4(&(ev->size)); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillVelocityModelStruct(SUDS_VELMODEL *vm, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; if(!vm) return 0; bytesRead = fread(vm->netname,1, 4,ptr); vm->netname[3] = '\0'; bytesRead += fread(vm->modelname,1, 6,ptr); vm->modelname[5] = '\0'; bytesRead += fread(&(vm->spareE),1, 1,ptr); bytesRead += fread(&(vm->modeltype),1, 1,ptr); bytesRead += fread(&(vm->latA),1, 8,ptr); bytesRead += fread(&(vm->longA),1, 8,ptr); bytesRead += fread(&(vm->latB),1, 8,ptr); bytesRead += fread(&(vm->longB),1, 8,ptr); bytesRead += fread(&(vm->time_effective),1, 4,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert8(&(vm->latA)); Convert8(&(vm->longA)); Convert8(&(vm->latB)); Convert8(&(vm->longB)); Convert4(&(vm->time_effective)); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillEquipmentStruct(SUDS_EQUIPMENT *eq, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; if(!eq) return 0; bytesRead = ReadStatIdent(&(eq->thisSID), ptr); bytesRead += ReadStatIdent(&(eq->previous), ptr); bytesRead += ReadStatIdent(&(eq->next), ptr); bytesRead += fread(eq->serial,1, 8,ptr); bytesRead += fread(&(eq->model),1, 2,ptr); bytesRead += fread(&(eq->knob1),1, 2,ptr); bytesRead += fread(&(eq->knob2),1, 2,ptr); bytesRead += fread(&(eq->reason),1, 2,ptr); bytesRead += fread(&(eq->frequency),1, 4,ptr); bytesRead += fread(&(eq->effective),1, 4,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert2(&(eq->model)); Convert2(&(eq->knob1)); Convert2(&(eq->knob2)); Convert2(&(eq->reason)); Convert4(&(eq->frequency)); Convert4(&(eq->effective)); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillCalibStruct(SUDS_CALIBRATION *ca, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; if(!ca) return 0; bytesRead = ReadStatIdent(&(ca->ca_name), ptr); bytesRead += fread(&(ca->maxgain),1, 4,ptr); bytesRead += fread(&(ca->normaliz),1, 4,ptr); bytesRead += fread(ca->cal,1, NOCALPTS * sizeof(SUDS_CALIBR),ptr); bytesRead += fread(&(ca->begint),1, 4,ptr); bytesRead += fread(&(ca->endt),1, 4,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert4(&(ca->maxgain)); Convert4(&(ca->normaliz)); ConvertPZArray(ca->cal, NOCALPTS); Convert4(&(ca->begint)); Convert4(&(ca->endt)); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillStationCompStruct(SUDS_STATIONCOMP *sc, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; if(!sc) return 0; bytesRead = ReadStatIdent(&(sc->sc_name), ptr); bytesRead += fread(&(sc->azim),1, 2,ptr); bytesRead += fread(&(sc->incid),1, 2,ptr); bytesRead += fread(&(sc->st_lat),1, 8,ptr); bytesRead += fread(&(sc->st_long),1, 8,ptr); bytesRead += fread(&(sc->elev),1, 4,ptr); bytesRead += fread(&(sc->enclosure),1, 1,ptr); bytesRead += fread(&(sc->annotation),1, 1,ptr); bytesRead += fread(&(sc->recorder),1, 1,ptr); bytesRead += fread(&(sc->rockclass),1, 1,ptr); bytesRead += fread(&(sc->rocktype),1, 2,ptr); bytesRead += fread(&(sc->sitecondition),1, 1,ptr); bytesRead += fread(&(sc->sensor_type),1, 1,ptr); bytesRead += fread(&(sc->data_type),1, 1,ptr); bytesRead += fread(&(sc->data_units),1, 1,ptr); bytesRead += fread(&(sc->polarity),1, 1,ptr); bytesRead += fread(&(sc->st_status),1, 1,ptr); bytesRead += fread(&(sc->max_gain),1, 4,ptr); bytesRead += fread(&(sc->clip_value),1, 4,ptr); bytesRead += fread(&(sc->con_mvolts),1, 4,ptr); bytesRead += fread(&(sc->channel),1, 2,ptr); bytesRead += fread(&(sc->atod_gain),1, 2,ptr); bytesRead += fread(&(sc->effective),1, 4,ptr); bytesRead += fread(&(sc->clock_correct),1, 4,ptr); bytesRead += fread(&(sc->station_delay),1, 4,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert2(&(sc->azim)); Convert2(&(sc->incid)); Convert8(&(sc->st_lat)); Convert8(&(sc->st_long)); Convert4(&(sc->elev)); Convert2(&(sc->rocktype)); Convert4(&(sc->max_gain)); Convert4(&(sc->clip_value)); Convert4(&(sc->con_mvolts)); Convert2(&(sc->channel)); Convert2(&(sc->atod_gain)); Convert4(&(sc->effective)); Convert4(&(sc->clock_correct)); Convert4(&(sc->station_delay)); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
static int ReadStatIdent(SUDS_STATIDENT *si, FILE *ptr) { int bytesRead; bytesRead = fread(si->network,1, 4, ptr); si->network[4] = '\0'; bytesRead += fread(si->st_name,1, 5, ptr); si->st_name[4] = '\0'; if(bytesRead < 9)bytesRead += fread(&(si->component),1, 1, ptr); bytesRead += fread(&(si->component),1, 1, ptr); bytesRead += fread(&(si->inst_type),1, 2, ptr); if(CheckByteOrder() == ENDIAN_BIG) { Convert2(&(si->inst_type)); } return bytesRead; }
int FillAtoDStruct(SUDS_ATODINFO *ad, SUDS_STRUCTTAG Tag, FILE *ptr) { if(!ad) return 0; if( fread( ad, 1, Tag.len_struct, ptr ) != (size_t)Tag.len_struct)return 0; if(CheckByteOrder() == ENDIAN_BIG) { Convert2(&(ad->base_address)); Convert2(&(ad->device_id)); Convert2(&(ad->device_flags)); Convert2(&(ad->extended_bufs)); Convert2(&(ad->external_mux)); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillProfileStruct(SUDS_PROFILE *pr, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; if(!pr) return 0; bytesRead = fread(&(pr->junk1),1, 2,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert2(&(pr->junk1)); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillTerminatorStruct(SUDS_TERMINATOR *te, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; if(!te) return 0; bytesRead = fread(&(te->structid),1, 2,ptr); bytesRead += fread(&(te->spareA),1, 2,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert2(&(te->structid)); Convert2(&(te->spareA)); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillShotgatherStruct(SUDS_SHOTGATHER *sh, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; if(!sh) return 0; bytesRead = fread(&(sh->junk2),1, 2,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert2(&(sh->junk2)); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillFeatureStruct(SUDS_FEATURE *fe, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; if(!fe) return 0; bytesRead = ReadStatIdent(&(fe->fe_name), ptr); bytesRead += fread(&(fe->obs_phase),1, 2,ptr); bytesRead += fread(&(fe->onset),1, 1,ptr); bytesRead += fread(&(fe->direction),1, 1,ptr); bytesRead += fread(&(fe->sig_noise),1, 2,ptr); bytesRead += fread(&(fe->data_source),1, 1,ptr); bytesRead += fread(&(fe->tim_qual),1, 1,ptr); bytesRead += fread(&(fe->amp_qual),1, 1,ptr); bytesRead += fread(&(fe->ampunits),1, 1,ptr); bytesRead += fread(&(fe->gain_range),1, 2,ptr); bytesRead += fread(&(fe->time),1, 8,ptr); bytesRead += fread(&(fe->amplitude),1, 4,ptr); bytesRead += fread(&(fe->period),1, 4,ptr); bytesRead += fread(&(fe->time_of_pick),1, 4,ptr); bytesRead += fread(&(fe->pick_authority),1, 2,ptr); bytesRead += fread(&(fe->pick_reader),1, 2,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert2(&(fe->obs_phase)); Convert2(&(fe->sig_noise)); Convert2(&(fe->gain_range)); Convert8(&(fe->time)); Convert4(&(fe->amplitude)); Convert4(&(fe->period)); Convert4(&(fe->time_of_pick)); Convert2(&(fe->pick_authority)); Convert2(&(fe->pick_reader)); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillTrigSettingStruct(SUDS_TRIGSETTING *ts, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; if(!ts) return 0; bytesRead = fread(ts->netwname,1, 4,ptr); ts->netwname[4] = '\0'; bytesRead += fread(&(ts->beginttime),1, 8,ptr); bytesRead += fread(&(ts->const1),1, 2,ptr); bytesRead += fread(&(ts->const2),1, 2,ptr); bytesRead += fread(&(ts->threshold),1, 2,ptr); bytesRead += fread(&(ts-> const3),1, 2,ptr); bytesRead += fread(&(ts->const4),1, 2,ptr); bytesRead += fread(&(ts->wav_inc),1, 2,ptr); bytesRead += fread(&(ts->sweep),1, 4,ptr); bytesRead += fread(&(ts->aperture),1, 4,ptr); bytesRead += fread(&(ts->algorithm),1,1,ptr); bytesRead += fread(&(ts->spareJ),1,1,ptr); bytesRead += fread(&(ts->spareI),1, 2,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert8(&(ts->beginttime)); Convert2(&(ts->const1)); Convert2(&(ts->const2)); Convert2(&(ts->threshold)); Convert2(&(ts->const3)); Convert2(&(ts->const4)); Convert2(&(ts->wav_inc)); Convert4(&(ts->sweep)); Convert4(&(ts->aperture)); Convert2(&(ts->spareI)); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillErrorStruct(SUDS_ERROR *er, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; int j; if(!er) return 0; bytesRead = fread(er->covarr,1, Tag.len_struct, ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { for(j=0;j<10;j++) Convert4(&(er->covarr[j])); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillDetectorStruct(SUDS_DETECTOR *de, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; if(!de) return 0; bytesRead = fread( de, 1, 12, ptr ); de->net_node_id[10] = '\0'; bytesRead += fread( &(de->versionnum), 1, 4, ptr ); bytesRead += fread( &(de->event_number), 1, 4, ptr ); bytesRead += fread( &(de->spareL), 1, 4, ptr ); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert4(&(de->versionnum)); Convert4(&(de->event_number)); Convert4(&(de->spareL)); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillLoctraceStruct(SUDS_LOCTRACE *lo, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; if(!lo) return 0; bytesRead = ReadStatIdent(&(lo->lt_name), ptr); bytesRead += fread(&(lo->fileloc),1, 4,ptr); bytesRead += fread(&(lo->tapeloc),1, 4,ptr); bytesRead += fread(&(lo->beginloc),1, 4,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert4(&(lo->beginloc)); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillResidualStruct(SUDS_RESIDUAL *re, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; if(!re) return 0; bytesRead = fread(&(re->event_num),1, 4,ptr); bytesRead += ReadStatIdent(&(re->re_name), ptr); bytesRead += fread(&(re->set_phase),1, 2,ptr); bytesRead += fread(&(re->set_tim_qual),1, 1,ptr); bytesRead += fread(&(re->set_amp_qual),1, 1,ptr); bytesRead += fread(&(re->residual),1, 4,ptr); bytesRead += fread(&(re->weight_used),1, 4,ptr); bytesRead += fread(&(re->delay),1, 4,ptr); bytesRead += fread(&(re->azimuth),1, 4,ptr); bytesRead += fread(&(re->distance),1, 4,ptr); bytesRead += fread(&(re->emergence),1, 4,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert4(&(re->event_num)); Convert2(&(re->set_phase)); Convert4(&(re->residual)); Convert4(&(re->weight_used)); Convert4(&(re->delay)); Convert4(&(re->azimuth)); Convert4(&(re->distance)); Convert4(&(re->emergence)); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillEventSettingStruct(SUDS_EVENTSETTING *es, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; if(!es) return 0; bytesRead = fread(es->netwname,1, 4,ptr); es->netwname[4] = '\0'; bytesRead += fread(&(es->beginttime),1, 8,ptr); bytesRead += fread(&(es->const1),1, 2,ptr); bytesRead += fread(&(es->const2),1, 2,ptr); bytesRead += fread(&(es->threshold),1, 2,ptr); bytesRead += fread(&(es-> const3),1, 2,ptr); bytesRead += fread(&(es->minduration),1, 4,ptr); bytesRead += fread(&(es->maxduration),1, 4,ptr); bytesRead += fread(&(es->algorithm),1, 1,ptr); bytesRead += fread(&(es->spareK),1, 1,ptr); bytesRead += fread(&(es->spareI),1, 2,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert8(&(es->beginttime)); Convert2(&(es->const1)); Convert2(&(es->const2)); Convert2(&(es->threshold)); Convert2(&(es->const3)); Convert4(&(es->minduration)); Convert4(&(es->maxduration)); Convert2(&(es->spareI)); } if(Tag.len_data)fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
/* * A function to load a tga file and return the OpenGL texture object */ int LoadTgaImage(const char filename[],unsigned char** ppData,unsigned int* w,unsigned int* h,unsigned int* bpp) { /* * Create an instance of the struct to hold the tga file header */ tga_header header; /* * Create a file pointer called fp and attempt to open the file */ FILE *fp = fopen(filename,"rb"); /* * if the file pointer is equal to NULL, the file failed to open */ if(fp) { /* * A pointer to hold the memory location of allocated memory that * we will require in order to store the pixel data */ unsigned int i,j,k; /* * Read the file header */ fread(&header,1,sizeof(tga_header),fp); /* * Check the byte ordering of the computer to see if we have to swap any bytes . * It's that pesky MSB/LSB thing again.... */ if(CheckByteOrder()) { /* * Swap the 2byte variables from the tga file header so that they make * sense on a unix box... */ Swap2Bytes( (void*)&header.m_ColourMapOrigin ); Swap2Bytes( (void*)&header.m_ColourMapSize ); Swap2Bytes( (void*)&header.m_Xorigin ); Swap2Bytes( (void*)&header.m_Yorigin ); Swap2Bytes( (void*)&header.m_Width ); Swap2Bytes( (void*)&header.m_Height ); } *w = header.m_Width; *h = header.m_Height; /* skip the image identification field if present */ for( i=0; i!=header.m_ImageIdent; ++i ) { fgetc(fp); } /* store bytes per pixel */ *bpp = header.m_PixelIndexSize/8; /* * Determine the size (in bytes) of the pixel data size contained * in the file. width * height * 3 bytes per colour (RGB). * * Use malloc to allocate the required memory size */ *ppData = (unsigned char*)malloc( (*bpp) * header.m_Width * header.m_Height ); /* * Use assert to ensure that the allocation succeeded */ assert( *ppData != NULL); /* an 8bit colour mapped image */ if( header.m_ImageType == 1 ) { /* This pointer holds reference to the actual 8bit data */ unsigned char* tempptr = *ppData,*pd=0,*pData=0; /* number of bytes per row */ unsigned int rowsize = (header.m_ColourMapESize/8) * header.m_Width; /* allocate and then read in the colour map.... */ unsigned char* colourMap = (unsigned char*) malloc ( header.m_ColourMapSize * (header.m_ColourMapESize/8) ); /* check allocation */ assert( colourMap ); /* store the new bytes per pixel (as given by the colour map entry size) */ *bpp = ( header.m_ColourMapESize / 8 ); /* read colour map data */ fread( colourMap, header.m_ColourMapSize *(*bpp), 1, fp ); /* flip colour map from BGR to RGB */ BGR_TO_RGB( colourMap, header.m_ColourMapSize, *bpp ); /* read the data in one go, we'll flip it upside down when expanding the colour map data.... */ fread( tempptr, 1, header.m_Width * header.m_Height, fp ); /* allocate memory for the new expanded image data... */ *ppData = (unsigned char*) malloc( header.m_Height * rowsize ); assert( *ppData ); /* this pointer is used as an iterator */ pData = (*ppData); /* now going to run backwards through 8bit image and write it upside down when expanding the colour map */ for( i=0; i != header.m_Height; ++i ) { /* get a pointer to the data row */ pd = tempptr + ( (header.m_Height-i-1) * header.m_Width ); /* loop till the end of the row */ for( j=0; j != rowsize; ++pd ) { /* get pointer to actual colour in colour map */ unsigned char *col = &colourMap[ 3*(*pd) ]; /* get end of colour */ unsigned char *colend = col + *bpp; /* copy the colour over (3 or 4bytes probably...) */ for( ; col != colend; ++col, ++j, ++pData ) { /* copy colour from colour map into correct place in expanded image */ *pData = *col; } } } /* free up any data... */ free( tempptr ); free( colourMap ); } else /* uncompressed grey/RGB/RGBA data */ if( header.m_ImageType == 2 ) { /* number of bytes per row */ unsigned int rowsize = (*bpp) * header.m_Width; /* pointer to last row in image data */ unsigned char* pd = *ppData + (*bpp) * (header.m_Height-1) * header.m_Width; /* * read the pixel data from the file in rows cos tga files are upside down... */ for( i = 0; i < header.m_Height; ++i, pd -= rowsize ) { fread( pd, 1, rowsize, fp ); } /* don't bother flipping bytes if greyscale image */ if( *bpp != 1 ) { /* * the tga file stores pixel data as bgr values. OpenGL however requires * the data in RGB. Therefore we have to traverse the array and swap the * pixel data around abit. */ BGR_TO_RGB( (*ppData), header.m_Height * header.m_Width, *bpp ); } } else /* RLE colour mapped images */ if( header.m_ImageType == 9 ) { /* This pointer holds reference to the actual 8bit data */ /* unsigned char* tempptr = *ppData;*/ /* number of bytes per row */ unsigned int rowsize = (header.m_ColourMapESize/8) * header.m_Width; /* allocate and then read in the colour map.... */ unsigned char* colourMap = (unsigned char*) malloc ( header.m_ColourMapSize * (header.m_ColourMapESize/8) ); /* temporary iterator pointers */ unsigned char *pde,*pData; /* check allocation */ assert( colourMap ); /* store the new bytes per pixel (as given by the colour map entry size) */ *bpp = ( header.m_ColourMapESize / 8 ); /* read colour map data */ fread( colourMap, header.m_ColourMapSize * (*bpp), 1, fp ); /* flip colour map from BGR to RGB */ BGR_TO_RGB( colourMap, header.m_ColourMapSize, *bpp ); /* allocate memory for the uncompressed image... */ *ppData = (unsigned char*) malloc ( header.m_Height * header.m_Width * (*bpp) ); /* get ptr to first element */ pData = *ppData; /* get end pointer marker */ pde = pData + header.m_Height * header.m_Width * (*bpp); /* now the reading process begins!! */ while( pde != pData ) { unsigned char byte; fread( &byte, 1, 1, fp ); /* * if the flag is zero, then the count indicates a run of raw data */ if( (byte & 0x80) == 0 ) { byte++; for(j=0;j<byte; ++j) { unsigned char c = fgetc(fp); for( k = 0; k != *bpp; ++k, ++pData ) { *pData = colourMap[ (*bpp)*c + k ]; } } } /* * If the flag is one, then the count represents the amount of times that the next byte * is repeated. This is the RLE bit.... */ else { unsigned char c = fgetc(fp); byte -= 0x7F; for(j=0;j<byte; ++j) { for( k = 0; k != *bpp; ++k, ++pData ) { *pData = colourMap[ (*bpp)*c + k ]; } } } } /* turn the image upside down .... */ FlipDaImage( *ppData, rowsize, header.m_Height ); } else /* RLE compressed grey/RGB/RGBA images */ if( header.m_ImageType == 10 ) { /* This pointer holds reference to the actual 8bit data */ /* unsigned char* tempptr = *ppData;*/ /* number of bytes per row */ unsigned int rowsize = (*bpp) * header.m_Width; /* temporary iterator pointers */ unsigned char* pde,*pData; /* get ptr to first element */ pData = *ppData; /* get end pointer marker */ pde = pData + header.m_Height * header.m_Width * (*bpp); /* now the reading process begins!! */ while( pData < pde ) { unsigned char colour[10] = {0,0,0,0}; unsigned char byte; fread( &byte, 1, 1, fp ); /* * if the flag is zero, then the count indicates a run of raw data */ if( (byte & 0x80) == 0 ) { byte++; for(j=0;j<byte; ++j) { fread( colour, 1, *bpp, fp ); for( k = 0; k != *bpp; ++k, ++pData ) { *pData = colour[ k ]; } } } /* * If the flag is one, then the count represents the amount of times that the next byte * is repeated. This is the RLE bit.... */ else { byte -= 0x7F; fread( colour, 1, *bpp, fp ); for(j=0;j<byte; ++j) { for( k = 0; k != *bpp; ++k, ++pData ) { *pData = colour[ k ]; } } } } /* flip colour map from BGR to RGB */ BGR_TO_RGB( *ppData, header.m_Width*header.m_Height, *bpp ); /* turn the image upside down .... */ FlipDaImage( *ppData, rowsize, header.m_Height ); } /* unsupported image type... */ else { switch( header.m_ImageType ) { case 0: printf("[ERROR] The file %s contains no image data\n",filename); break; case 3: printf("[ERROR] The file %s contains black & white data which is unsupported\n",filename); break; case 11: printf("[ERROR] The file %s contains compressed black & white data which is unsupported\n",filename); break; case 32: printf("[ERROR] The file %s contains compressed color map data which is un-supported\n",filename); break; case 33: printf("[ERROR] The file %s contains compressed color map data which is un-supported (4pass quad tree process)\n",filename); break; default: printf("[ERROR] The file %s does not appear to be valid\n",filename); break; } } /* * close the file */ fclose(fp); return 1; } return 0; }
static int WriteWfdiscRecord(const char *basename, struct wfdiscList *w, FILE* ptr) { char datafile[100]; FILE* fptr; int ptsOut; char buffer[400]; char *slashPtr; if(!CSSchrDefined(w->element->sta) || !CSSchrDefined(w->element->chan) || !CSSdblDefined(w->element->time) ) { if(!CSSlngDefined(w->element->wfid) ){ css_warning("Skipping wfdisc record because of missing key...\n"); return 1; } } sprintf(datafile, "%s%s%08d.w", basename, w->element->sta, w->element->wfid); if(strlen(datafile) > 32) { css_warning("File name longer than 32 characters\n"); css_warning(" basename[%3d]: %s\n", strlen(basename), basename); css_warning(" station[%3d]: %s\n", strlen(w->element->sta), w->element->sta); css_warning(" wfid[ 8]: %08d\n", w->element->wfid); css_warning(" extension[ 2]: .w\n"); css_warning(" filename[%3d]: %s\n", strlen(datafile), datafile); css_warning("Skipping wfdisc record because file name is too long...\n"); return 1; } slashPtr = strrchr(datafile, '/'); if( slashPtr ){ *slashPtr = '\0'; strcpy(w->element->dfile, slashPtr + 1); strcpy(w->element->dir, datafile ); *slashPtr = '/'; } else{ strcpy(w->element->dir, "."); strcpy(w->element->dfile, datafile); } if(w->seis->i && w->seis->r) strcpy(w->element->dattype, "ri"); else { /* Find the Machine Byte order and write the data as in that format in 4-byte floating points */ if( CheckByteOrder() == ENDIAN_BIG ) { strcpy(w->element->dattype, DATATYPE_SUN_4_BYTE_IEEE_SINGLE_REAL); } else if( CheckByteOrder() == ENDIAN_LITTLE ) { strcpy(w->element->dattype, DATATYPE_VAX_4_BYTE_IEEE_SINGLE_REAL); } else { css_warning("Unknown Machine Byte Order, skipping ...\n"); return 1; } } w->element->foff = 0; *buffer = '\0'; StrAppend(buffer, "%-6s", 6, w->element->sta); StrAppend(buffer, "%-8s", 8, w->element->chan); DblAppend(buffer, "%17.5f", 17, w->element->time); LngAppend(buffer, "%8d", 8, w->element->wfid); LngAppend(buffer, "%8d", 8, w->element->chanid); LngAppend(buffer, "%8d", 8, w->element->jdate); DblAppend(buffer, "%17.5f", 17, w->element->endtime); LngAppend(buffer, "%8d", 8, w->element->nsamp); DblAppend(buffer, "%11.7f", 11, w->element->samprate); DblAppend(buffer, "%16.6f", 16, w->element->calib); DblAppend(buffer, "%16.6f", 16, w->element->calper); StrAppend(buffer, "%-6s", 6, w->element->instype); StrAppend(buffer, "%-1s", 1, w->element->segtype); StrAppend(buffer, "%-2s", 2, w->element->dattype); StrAppend(buffer, "%-1s", 1, w->element->clip); StrAppend(buffer, "%-64s", 64, w->element->dir); StrAppend(buffer, "%-32s", 32, w->element->dfile); LngAppend(buffer, "%10d", 10, w->element->foff); LngAppend(buffer, "%8d", 8, w->element->commid); StrAppend(buffer, "%-17s", 17, w->element->lddate); buffer[ 283 ] = '\0' ; if( fprintf(ptr, "%s\n", buffer) == EOF )return 0; if(!w->seis->i){ css_warning("No data associated with wfdisc struct.\n"); return 1; } if( !(fptr = fopen(datafile,"wb")) ){ css_warning("Error: Could not open (%s).\n", datafile); return 0; } if(w->seis->r){ ptsOut = fwrite(w->seis->r, sizeof(float), w->element->nsamp, fptr); if(ptsOut != w->element->nsamp){ css_warning("Error writing (%s).\n", datafile); return 0; } } ptsOut = fwrite(w->seis->i, sizeof(float), w->element->nsamp, fptr); if(ptsOut != w->element->nsamp){ css_warning("Error writing (%s).\n", datafile); return 0; } fclose(fptr); return 1; }
int FillMuxDataStruct(SUDS *S, SUDS_MUXDATA *mu, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; int j; if(!mu) return 0; bytesRead = fread(mu->netname,1, 4,ptr); mu->netname[3] = '\0'; bytesRead += fread(&(mu->begintime),1, 8,ptr); bytesRead += fread(&(mu->loctime),1, 2,ptr); bytesRead += fread(&(mu->numchans),1, 2,ptr); bytesRead += fread(&(mu->dig_rate),1, 4,ptr); bytesRead += fread(&(mu->typedata),1, 1,ptr); bytesRead += fread(&(mu->descript),1, 1,ptr); bytesRead += fread(&(mu->spareG),1, 2,ptr); bytesRead += fread(&(mu->numsamps),1, 4,ptr); bytesRead += fread(&(mu->blocksize),1, 4,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert8(&(mu->begintime)); Convert2(&(mu->loctime)); Convert2(&(mu->numchans)); Convert4(&(mu->dig_rate)); Convert2(&(mu->spareG)); Convert4(&(mu->numsamps)); Convert4(&(mu->blocksize)); } mu->numsamps = mu->numchans * mu->blocksize; if(Tag.len_data){ switch (mu->typedata){ case 's': case 'q': case 'u': case 'i': S->muTail->i2data = (short *) malloc( Tag.len_data ); if(!S->muTail->i2data){ printf("ERROR: Could not allocate data array in FillMuxDataStruct.\n"); return 0; } bytesRead = fread(S->muTail->i2data, 1, Tag.len_data, ptr); if(bytesRead != Tag.len_data){ printf("ERROR: Expected to read %d bytes but got %d instead.\n", Tag.len_data, bytesRead); return 0; } if(CheckByteOrder() == ENDIAN_BIG) { for(j=0;j<mu->numsamps;j++)Convert2(S->muTail->i2data + j); } return 1; case '2': case 'l': S->muTail->i4data = (int *) malloc( Tag.len_data ); if(!S->muTail->i4data){ printf("ERROR: Could not allocate data array in FillMuxDataStruct.\n"); return 0; } bytesRead = fread(S->muTail->i4data, 1, Tag.len_data, ptr); if(bytesRead != Tag.len_data){ printf("ERROR: Expected to read %d bytes but got %d instead.\n", Tag.len_data, bytesRead); return 0; } if(CheckByteOrder() == ENDIAN_BIG) { for(j=0;j<mu->numsamps;j++)Convert4(S->muTail->i4data + j); } return 1; case 'f': S->muTail->r4data = (float *) malloc( Tag.len_data ); if(!S->muTail->r4data){ printf("ERROR: Could not allocate data array in FillMuxDataStruct.\n"); return 0; } bytesRead = fread(S->muTail->r4data, 1, Tag.len_data, ptr); if(bytesRead != Tag.len_data){ printf("ERROR: Expected to read %d bytes but got %d instead.\n", Tag.len_data, bytesRead); return 0; } if(CheckByteOrder() == ENDIAN_BIG) { for(j=0;j<mu->numsamps;j++)Convert4(S->muTail->r4data + j); } return 1; case 'd': S->muTail->r8data = (double *) malloc( Tag.len_data ); if(!S->muTail->r8data){ printf("ERROR: Could not allocate data array in FillMuxDataStruct.\n"); return 0; } bytesRead = fread(S->muTail->r8data, 1, Tag.len_data, ptr); if(bytesRead != Tag.len_data){ printf("ERROR: Expected to read %d bytes but got %d instead.\n", Tag.len_data, bytesRead); return 0; } if(CheckByteOrder() == ENDIAN_BIG) { /* for(j=0;j<mu->numsamps;j++)Convert8(S->muTail->r8data + j); */ } return 1; } } /* default is to skip data if not a recognized type */ fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }
int FillDescripTraceStruct(SUDS *S, SUDS_DESCRIPTRACE *dt, SUDS_STRUCTTAG Tag, FILE *ptr) { int bytesRead; int j; if(!dt) return 0; bytesRead = ReadStatIdent(&(dt->dt_name), ptr); bytesRead += fread(&(dt->begintime),1, 8,ptr); bytesRead += fread(&(dt->localtime),1, 2,ptr); bytesRead += fread(&(dt->datatype),1, 1,ptr); bytesRead += fread(&(dt->descriptor),1, 1,ptr); bytesRead += fread(&(dt->digi_by),1, 2,ptr); bytesRead += fread(&(dt->processed),1, 2,ptr); bytesRead += fread(&(dt->length),1, 4,ptr); bytesRead += fread(&(dt->rate),1, 4,ptr); bytesRead += fread(&(dt->mindata),1, 4,ptr); bytesRead += fread(&(dt->maxdata),1, 4,ptr); bytesRead += fread(&(dt->avenoise),1, 4,ptr); bytesRead += fread(&(dt->numclip),1, 4,ptr); bytesRead += fread(&(dt->time_correct),1, 8,ptr); bytesRead += fread(&(dt->rate_correct),1, 4,ptr); if(bytesRead > Tag.len_struct) return 0; else fseek ( ptr , Tag.len_struct - bytesRead , SEEK_CUR ) ; if(CheckByteOrder() == ENDIAN_BIG) { Convert8(&(dt->begintime)); Convert2(&(dt->localtime)); Convert2(&(dt->digi_by)); Convert2(&(dt->processed)); Convert4(&(dt->length)); Convert4(&(dt->rate)); Convert4(&(dt->mindata)); Convert4(&(dt->maxdata)); Convert4(&(dt->avenoise)); Convert4(&(dt->numclip)); Convert8(&(dt->time_correct)); Convert4(&(dt->rate_correct)); } if(Tag.len_data){ switch (dt->datatype){ case 's': case 'q': case 'u': case 'i': S->dtTail->i2data = (short *) malloc( dt->length * sizeof(short) ); if(!S->dtTail->i2data){ printf("ERROR: Could not allocate data array in FillDescripTraceStruct.\n"); return 0; } bytesRead = fread(S->dtTail->i2data, 1, sizeof(short) * dt->length, ptr); if(bytesRead != Tag.len_data){ printf("ERROR: Expected to read %d bytes but got %d instead.\n", Tag.len_data, bytesRead); return 0; } if(CheckByteOrder() == ENDIAN_BIG) { for(j=0;j<dt->length;j++)Convert2(S->dtTail->i2data + j); } return 1; case '2': case 'l': S->dtTail->i4data = (int *) malloc( dt->length * sizeof(int) ); if(!S->dtTail->i4data){ printf("ERROR: Could not allocate data array in FillDescripTraceStruct.\n"); return 0; } bytesRead = fread(S->dtTail->i4data, 1, sizeof(int) * dt->length, ptr); if(bytesRead != Tag.len_data){ printf("ERROR: Expected to read %d bytes but got %d instead.\n", Tag.len_data, bytesRead); return 0; } if(CheckByteOrder() == ENDIAN_BIG) { for(j=0;j<dt->length;j++)Convert4(S->dtTail->i4data + j); } return 1; case 'f': S->dtTail->r4data = (float *) malloc( dt->length * sizeof(float) ); if(!S->dtTail->r4data){ printf("ERROR: Could not allocate data array in FillDescripTraceStruct.\n"); return 0; } bytesRead = fread(S->dtTail->r4data, 1, sizeof(float) * dt->length, ptr); if(bytesRead != Tag.len_data){ printf("ERROR: Expected to read %d bytes but got %d instead.\n", Tag.len_data, bytesRead); return 0; } if(CheckByteOrder() == ENDIAN_BIG) { for(j=0;j<dt->length;j++)Convert4(S->dtTail->r4data + j); } return 1; case 'd': S->dtTail->r8data = (double *) malloc( dt->length * sizeof(double) ); if(!S->dtTail->r8data){ printf("ERROR: Could not allocate data array in FillDescripTraceStruct.\n"); return 0; } bytesRead = fread(S->dtTail->r8data, 1, sizeof(double) * dt->length, ptr); if(bytesRead != Tag.len_data){ printf("ERROR: Expected to read %d bytes but got %d instead.\n", Tag.len_data, bytesRead); return 0; } if(CheckByteOrder() == ENDIAN_BIG) { for(j=0;j<dt->length;j++)Convert8(S->dtTail->r8data + j); } return 1; } } /* default is to skip data if not a recognized type */ fseek(ptr,Tag.len_data,SEEK_CUR); return 1; }