segdread.c

su 的源代码库

  ghn->x1[2]=GET_C(tapeun);
  ghn->sln[0]=GET_UC(tapeun);
  
  ghn->sln[1]=GET_UC(tapeun);
  ghn->sln[2]=GET_UC(tapeun);
  ghn->sln[3]=GET_UC(tapeun);
  ghn->sln[4]=GET_UC(tapeun);
  
  ghn->spn[0]=GET_UC(tapeun);
  ghn->spn[1]=GET_UC(tapeun);
  ghn->spn[2]=GET_UC(tapeun);
  ghn->spn[3]=GET_UC(tapeun);
  
  ghn->spn[4]=GET_UC(tapeun);
  ghn->spi=GET_UC(tapeun);
  ghn->pc=GET_UC(tapeun);
  ghn->v=GET_UC(tapeun);
  
  ghn->pa=GET_S(tapeun);
  ghn->bn=GET_UC(tapeun);
  ghn->ss=GET_UC(tapeun);
  
  ghn->x2[0]=GET_C(tapeun);
  ghn->x2[1]=GET_C(tapeun);
  ghn->x2[2]=GET_C(tapeun);
  ghn->x2[3]=GET_C(tapeun);
  
  ghn->x2[4]=GET_C(tapeun);
  ghn->x2[5]=GET_C(tapeun);
  ghn->x2[6]=GET_C(tapeun);
  ghn->x2[7]=GET_C(tapeun);
  
  ghn->x2[8]=GET_C(tapeun);
  ghn->x2[9]=GET_C(tapeun);
  ghn->x2[10]=GET_C(tapeun);
  ghn->x2[11]=GET_C(tapeun);

  status = (sferror(tapeun)||sfeof(tapeun));

  return (status?EXIT_FAILURE:EXIT_SUCCESS);
}

int
get_gn_sn358(gen_head_sn358 * gh358, Sfio_t *tapeun)
{
  int status;
  
  gh358->fc1=GET_UC(tapeun);
  gh358->lc1=GET_UC(tapeun);
  gh358->fc2=GET_UC(tapeun);
  gh358->f_lc2=GET_UC(tapeun);
  
  gh358->lc2=GET_UC(tapeun);
  gh358->fc3=GET_UC(tapeun);
  gh358->f_lc3=GET_UC(tapeun);
  gh358->lc3=GET_UC(tapeun);
  
  gh358->fc4=GET_UC(tapeun);
  gh358->f_lc4=GET_UC(tapeun);
  gh358->lc4=GET_UC(tapeun);
  gh358->f_lac1=GET_UC(tapeun);
  
  gh358->fsc1=GET_UC(tapeun);
  gh358->f_lsc1=GET_UC(tapeun);
  gh358->lsc1=GET_UC(tapeun);
  gh358->sam_int1=GET_UC(tapeun);
  
  gh358->fac2=GET_UC(tapeun);
  gh358->fsc2=GET_UC(tapeun);
  gh358->f_lsc2=GET_UC(tapeun);
  gh358->lsc2=GET_UC(tapeun);
  
  gh358->sam_int2=GET_UC(tapeun);
  gh358->bl_sig_le=GET_UC(tapeun);
  gh358->rec_length[0]=GET_UC(tapeun);
  gh358->rec_length[1]=GET_UC(tapeun);
  
  gh358->dyn_swit_del[0]=GET_UC(tapeun);
  gh358->dyn_swit_del[1]=GET_UC(tapeun);
  gh358->rec_del[0]=GET_UC(tapeun);
  gh358->rec_del[1]=GET_UC(tapeun);
  
  gh358->ty_a_cha12=GET_UC(tapeun);
  gh358->ty_a_cha34=GET_UC(tapeun);
  gh358->ty_a_cha56=GET_UC(tapeun);
  gh358->ty_a_cha78=GET_UC(tapeun);
  
  gh358->mode_num=GET_UC(tapeun);
  gh358->an_sys_co=GET_UC(tapeun);
  gh358->reel_num[0]=GET_UC(tapeun);
  gh358->reel_num[1]=GET_UC(tapeun);
  
  gh358->file_num[0]=GET_UC(tapeun);
  gh358->file_num[1]=GET_UC(tapeun);
  gh358->sp_num[0]=GET_UC(tapeun);
  gh358->sp_num[1]=GET_UC(tapeun);
  
  gh358->lc_nf=GET_UC(tapeun);
  gh358->fg_ic=GET_UC(tapeun);
  gh358->of1=GET_UC(tapeun);
  gh358->of2=GET_UC(tapeun);
  
  gh358->of3=GET_UC(tapeun);
  gh358->osc_att=GET_UC(tapeun);
  gh358->t_sig_ph=GET_UC(tapeun);
  gh358->m_gain=GET_UC(tapeun);
  
  gh358->dum[0]=GET_UC(tapeun);
  gh358->dum[1]=GET_UC(tapeun);
  gh358->dum[2]=GET_UC(tapeun);
  gh358->dum[3]=GET_UC(tapeun);
  
  gh358->dum[4]=GET_UC(tapeun);
  gh358->dum[5]=GET_UC(tapeun);
  gh358->dum[6]=GET_UC(tapeun);
  gh358->dum[7]=GET_UC(tapeun);
  
  gh358->dum[8]=GET_UC(tapeun);
  gh358->dum[9]=GET_UC(tapeun);
  gh358->dum[10]=GET_UC(tapeun);
  gh358->dum[11]=GET_UC(tapeun);
  
  gh358->dum[12]=GET_UC(tapeun);
  gh358->dum[13]=GET_UC(tapeun);
  gh358->dum[14]=GET_UC(tapeun);
  gh358->dum[15]=GET_UC(tapeun);

  status = (sferror(tapeun)||sfeof(tapeun));

  return (status?EXIT_FAILURE:EXIT_SUCCESS);
}

int
get_csh(channel_set_header * csh, Sfio_t *tapeun)
{
  int status;
  
  csh->st=GET_UC(tapeun);
  csh->cn=GET_UC(tapeun);
  csh->tf=GET_US(tapeun);
  
  csh->te=GET_US(tapeun);
  csh->mp[0]=GET_UC(tapeun);
  csh->mp[1]=GET_UC(tapeun);
  
  csh->cs[0]=GET_UC(tapeun);
  csh->cs[1]=GET_UC(tapeun);
  csh->c=GET_UC(tapeun);
  csh->sc_j=GET_UC(tapeun);
  
  csh->af=GET_US(tapeun);
  csh->as=GET_US(tapeun);
  
  csh->lc=GET_US(tapeun);
  csh->ls=GET_US(tapeun);
  
  csh->nt[0]=GET_US(tapeun);
  csh->nt[1]=GET_US(tapeun);
  
  csh->nt[2]=GET_US(tapeun);
  csh->ecs=GET_US(tapeun);
  
  csh->efh=GET_UC(tapeun);
  csh->vs=GET_UC(tapeun);
  csh->cab=GET_UC(tapeun);
  csh->ary=GET_UC(tapeun);

  status = (sferror(tapeun)||sfeof(tapeun));

  return (status?EXIT_FAILURE:EXIT_SUCCESS);
}


int
get_the(trace_header_ext * the, Sfio_t *tapeun)
{
  int status;

  the->rln[0]=GET_UC(tapeun);
  the->rln[1]=GET_UC(tapeun);
  the->rln[2]=GET_UC(tapeun);
  the->rpn[0]=GET_UC(tapeun);
  
  the->rpn[1]=GET_UC(tapeun);
  the->rpn[2]=GET_UC(tapeun);
  the->rpi=GET_UC(tapeun);
  the->nbs[0]=GET_UC(tapeun);
  
  the->nbs[1]=GET_UC(tapeun);
  the->nbs[2]=GET_UC(tapeun);
  the->x[0]=GET_C(tapeun);
  the->x[1]=GET_C(tapeun);
  
  the->x[2]=GET_C(tapeun);
  the->x[3]=GET_C(tapeun);
  the->x[4]=GET_C(tapeun);
  the->x[5]=GET_C(tapeun);
  
  the->x[6]=GET_C(tapeun);
  the->x[7]=GET_C(tapeun);
  the->x[8]=GET_C(tapeun);
  the->x[9]=GET_C(tapeun);
  
  the->x[10]=GET_C(tapeun);
  the->x[11]=GET_C(tapeun);
  the->x[12]=GET_C(tapeun);
  the->x[13]=GET_C(tapeun);
  
  the->x[14]=GET_C(tapeun);
  the->x[15]=GET_C(tapeun);
  the->x[16]=GET_C(tapeun);
  the->x[17]=GET_C(tapeun);
  
  the->x[18]=GET_C(tapeun);
  the->x[19]=GET_C(tapeun);
  the->x[20]=GET_C(tapeun);
  the->x[21]=GET_C(tapeun);
  
 status = (sferror(tapeun)||sfeof(tapeun));

  return (status?EXIT_FAILURE:EXIT_SUCCESS);
}

int get_ssh(sample_skew * ssh, Sfio_t *tapeun)
{
  int status;
  int i;

  for(i=0; i<32; i++ ) {
	ssh->skew[i] = GET_UC(tapeun);
	}

  status = (sferror(tapeun)||sfeof(tapeun));

  return (status?EXIT_FAILURE:EXIT_SUCCESS);
}

int get_ech(extended_header * ech, Sfio_t *tapeun)
{
  int status;
  int i;

  for(i=0; i<32; i++ ) {
	ech->dummy[i] = GET_UC(tapeun);
	}

  status = (sferror(tapeun)||sfeof(tapeun));

  return (status?EXIT_FAILURE:EXIT_SUCCESS);
}

int get_exh(external_header * exh, Sfio_t *tapeun)
{
  int status;
  int i;

  for(i=0; i<32; i++ ) {
	exh->dummy[i] = GET_UC(tapeun);
	}

  status = (sferror(tapeun)||sfeof(tapeun));

  return (status?EXIT_FAILURE:EXIT_SUCCESS);
}

int get_gt(general_trailer * gt, Sfio_t *tapeun)
{
  int status;
  int i;

  gt->gt = GET_US(tapeun);
  for(i=0; i<8; i++ ) {
	gt->x1[i] = GET_C(tapeun);
  }

  gt->c = GET_UC(tapeun);

  for(i=0; i<21; i++ ) {
	gt->x2[i] = GET_C(tapeun);
  }

  status = (sferror(tapeun)||sfeof(tapeun));

  return (status?EXIT_FAILURE:EXIT_SUCCESS);
}

int get_dth(dem_trace_header * dth, Sfio_t *tapeun)
{
  int status;

  dth->f = GET_S(tapeun);
  dth->st = GET_UC(tapeun);
  dth->cn = GET_UC(tapeun);
  dth->tn[0] = GET_UC(tapeun);
  dth->tn[1] = GET_UC(tapeun);
  dth->t[0] = GET_UC(tapeun);
  dth->t[1] = GET_UC(tapeun);
  dth->t[2] = GET_UC(tapeun);
  dth->the = GET_UC(tapeun);
  dth->ss = GET_UC(tapeun);
  dth->tr = GET_UC(tapeun);
  dth->tw[0] = GET_UC(tapeun);
  dth->tw[1] = GET_UC(tapeun);
  dth->tw[2] = GET_UC(tapeun);
  dth->en[0] = GET_UC(tapeun);
  dth->en[1] = GET_UC(tapeun);
  dth->efn[0] = GET_UC(tapeun);
  dth->efn[1] = GET_UC(tapeun);
  dth->efn[2] = GET_UC(tapeun);

  status = (sferror(tapeun)||sfeof(tapeun));

  return (status?EXIT_FAILURE:EXIT_SUCCESS);
}


void info_gh1(general_header_1 * gh1)
{
int n_gh, n_str, n_cs;
 n_gh = (*gh1).gh_dy1 >> 4;
 n_str = bcd ((unsigned char *)  (&(gh1->str)), 0, 2);
 n_cs = bcd ((unsigned char *) (&(gh1->cs)), 0, 2);

 warn("\n********************************\n"
 	"segd_general_header_1 (%2d bytes)\n"
 	"********************************", sizeof(*gh1));
 warn("file number: %d", tr.fldr);
 warn("\t\tformat code: %0.4hx\n", gh1->y);
 warn("general constants K1-K12 not decoded");
 warn("\t\tyear: %d\n", tr.year % 100);
 warn("#blks in general header extension: %d\n", n_gh);
 warn("day: %02d", tr.day);
 warn("\t\thour: %02d", tr.hour);
 warn("\t\tminute: %02d", tr.minute);
 warn("\t\tsecond: %02d\n", tr.sec);
 warn("manufacturer s code: %2x", (*gh1).m[0]);
 warn("\t\tmanufacturer's serial number: %02x%02x\n", (*gh1).m[1], (*gh1).m[2]);
 warn("bytes per scan (multiplexed formats) : not decoded");
 warn("\t\tbase scan interval: %d microseconds\n", tr.dt);
 warn("polarity: %x", (*gh1).p_sbx >> 4);
 warn("\t\tscan/block: %d x 2 **%d\n", (*gh1).sb, ((*gh1).p_sbx & 0xff));
 warn("record type (8=normal record) : %x", (*gh1).z_r1 >> 4);
 warn("\t\trecord length: %d units\n", bcd ((unsigned char *) &(*gh1).z_r1, 1, 3));
 warn("scan types / records: %d", n_str);
 warn("\t\tchannel sets per scan type: %d\n", n_cs);
 warn("number of 32-bytes fields for sample skew: %x\n", (*gh1).sk);
 warn("extended header length: %x", (*gh1).ec);
 warn("\t\texternal header length: %x\n", (*gh1).ex);
}

void info_gh2(general_header_2 *gh2)
{
 warn("\n********************************\n"
 	"segd_general_header_2 (%2d bytes)\n"
 	"********************************\n", sizeof(*gh2));
 warn("expanded file number: %2x%2x%2x\n", (*gh2).ef[0], (*gh2).ef[1], (*gh2).ef[1] );    
 warn("extended channel sets/scantype: %02x%02x\n", (*gh2).en[0], (*gh2).en[1]);
 warn("extended header blocks: %02x%02x\n", (*gh2).ecx[0], (*gh2).ecx[1] );
 warn("external header blocks: %02x%02x\n", (*gh2).eh[0], (*gh2).eh[1]);
 warn("seg-d revision number: %02x%02x\n", (*gh2).rev[0], (*gh2).rev[1]);
 warn("general trailer number of blocks:  %d\n", (*gh2).gt);
 warn("extended record length: %02x%02x%02x\n", (*gh2).erl[0], (*gh2).erl[1], (*gh2).erl[2]); 
}

void info_ghn(general_header_n *ghn)
{
 warn("\n********************************\n"
 	"segd_general_header_n (%2d bytes)\n"
 	"********************************\n", sizeof(*ghn));
 warn("source line number: %02x%02x%02x%02x%02x\n", (*ghn).sln[0], (*