/*
* Name: BIO_dump_cmd
* Description: Dump the output of invoking a command
* to a BIO.
*
* Arguments: cmd - Command to invoke
* bio - BIO to dump output of command to
* only 'stdout' is dumped.
* Returns : 0 - success
* nonzero - failure. errors printed to screen.
*/
int
BIO_dump_cmd(char *cmd, BIO *bio)
{
char buf[BLK_SIZE];
FILE *fp;
int rc;
/* start up the process */
if ((fp = epopen(cmd, "r")) == NULL) {
rpterr();
return (1);
}
/* read output in chunks, transfer to BIO */
while (fread(buf, BLK_SIZE, 1, fp) == 1) {
if (BIO_write(bio, buf, BLK_SIZE) != BLK_SIZE) {
(void) sighold(SIGINT);
(void) sighold(SIGHUP);
(void) epclose(fp);
(void) sigrelse(SIGINT);
(void) sigrelse(SIGHUP);
rpterr();
return (1);
}
}
/* done with stream, make sure no errors were encountered */
if (ferror(fp)) {
(void) epclose(fp);
rpterr();
return (1);
}
/* done, close stream, report any errors */
(void) sighold(SIGINT);
(void) sighold(SIGHUP);
rc = epclose(fp);
(void) sigrelse(SIGINT);
(void) sigrelse(SIGHUP);
if (rc != 0) {
rpterr();
return (1);
}
return (rc);
}
int main(int argc, char **argv)
{
char *plotcmd; /* build pswigb command for popen */
float *trbuf; /* trace buffer */
FILE *plotfp; /* fp for plot data */
int nt; /* number of samples on trace */
int ntr; /* number of traces */
int verbose; /* verbose flag */
float d1; /* time/depth sample rate */
float d2; /* trace/dx sample rate */
float f1; /* tmin/zmin */
float f2; /* tracemin/xmin */
cwp_Bool seismic; /* is this seismic data? */
cwp_Bool have_ntr=cwp_false;/* is ntr known from header or user? */
char *tmpdir; /* directory path for tmp files */
cwp_Bool istmpdir=cwp_false;/* true for user given path */
char *cwproot; /* value of CWPROOT environment variable*/
char *bindir; /* directory path for tmp files */
/* Support for irregularly spaced data */
cwp_String key; /* header key word with x2 information */
cwp_String type1=NULL; /* ... its type */
int index1=0; /* ... its index */
Value val; /* value of key */
Value scale; /* Value of scaler */
cwp_String type2=NULL; /* ... its type */
int index2=0; /* ... its index */
cwp_Bool isDepth=cwp_false; /* Is this key a type of depth? */
cwp_Bool isCoord=cwp_false; /* Is this key a type of coordinate? */
cwp_Bool irregular=cwp_false; /* if true, reading x2 from header */
cwp_String x2string; /* string of x2 values */
off_t x2len; /* ... its length */
cwp_String style; /* style parameter */
/* Initialize */
initargs(argc, argv);
requestdoc(1);
/* Get info from first trace */
if (!gettr(&tr)) err("can't get first trace");
seismic = ISSEISMIC(tr.trid);
nt = tr.ns;
ntr = tr.ntr;
if (ntr) have_ntr = cwp_true;
if (!getparint("verbose", &verbose)) verbose=0;
if (!getparfloat("d1", &d1)) {
if (tr.d1) d1 = tr.d1;
else if (tr.dt) d1 = ((double) tr.dt)/1000000.0;
else {
if (seismic) {
d1 = 0.004;
warn("tr.dt not set, assuming dt=0.004");
} else { /* non-seismic data */
d1 = 1.0;
warn("tr.d1 not set, assuming d1=1.0");
}
}
}
if (!getparfloat("f1", &f1)) {
if (tr.f1) f1 = tr.f1;
else if (tr.delrt) f1 = (float) tr.delrt/1000.0;
else f1 = 0.0;
}
/* Get or set ntr */
if (getparint("n2", &ntr) || getparint("ntr", &ntr)) have_ntr = cwp_true;
if (!getparfloat("d2", &d2)) d2 = (tr.d2) ? tr.d2 : 1.0;
if (!getparfloat("f2", &f2)) {
if (tr.f2) f2 = tr.f2;
else if (tr.tracr) f2 = (float) tr.tracr;
else if (tr.tracl) f2 = (float) tr.tracl;
else if (seismic) f2 = 1.0;
else f2 = 0.0;
}
if (!getparstring("style", &style)) style = "seismic";
if (getparstring("key", &key)) {
type1 = hdtype(key);
if ( (index1 = getindex(key)) == -1 )
err("%s: keyword not in segy.h: '%s'", __FILE__, key);
irregular = cwp_true;
isDepth = IS_DEPTH(key);
isCoord = IS_COORD(key);
if (isDepth) {
index2 = getindex("scalel");
type2 = hdtype("scalel");
} else if (isCoord) {
index2 = getindex("scalco");
type2 = hdtype("scalco");
}
}
/* Look for user-supplied tmpdir */
if (!getparstring("tmpdir",&tmpdir) &&
!(tmpdir = getenv("CWP_TMPDIR"))) tmpdir="";
if (!STREQ(tmpdir, "") && access(tmpdir, WRITE_OK))
err("you can't write in %s (or it doesn't exist)", tmpdir);
/* See if CWPBIN environment variable is not set */
if (!(bindir = getenv("CWPBIN"))) { /* construct bindir from CWPROOT */
bindir = (char *) emalloc(BUFSIZ);
/* Get value of CWPROOT environment variable */
if (!(cwproot = getenv("CWPROOT"))) cwproot ="" ;
if (STREQ(cwproot, "")) {
warn("CWPROOT environment variable is not set! ");
err("Set CWPROOT in shell environment as per instructions in CWP/SU Installation README files");
}
/* then bindir = $CWPROOT/bin */
sprintf(bindir, "%s/bin", cwproot);
}
strcat(bindir,"/"); /* put / at the end of bindir */
/* Allocate trace buffer */
trbuf = ealloc1float(nt);
if (!have_ntr || irregular ) { /* count traces */
if (verbose) {
if (irregular) {
warn("trace spacing from header field %s",key);
warn("... getting positions");
} else {
warn("n2 not getparred and "
"ntr header field not set");
warn(".... counting traces");
}
}
/* Create temporary "file" to hold data */
if (STREQ(tmpdir,"")) {
datafp = etmpfile();
if (irregular) x2fp = etmpfile();
if (verbose) warn("using tmpfile() call");
} else { /* user-supplied tmpdir */
char directory[BUFSIZ];
strcpy(directory, tmpdir);
strcpy(datafile, temporary_filename(directory));
strcpy(x2file, temporary_filename(directory));
/* Handle user interrupts */
signal(SIGINT, (void (*) (int)) closefiles);
signal(SIGQUIT, (void (*) (int)) closefiles);
signal(SIGHUP, (void (*) (int)) closefiles);
signal(SIGTERM, (void (*) (int)) closefiles);
datafp = efopen(datafile, "w+");
if (irregular) x2fp = efopen(x2file, "w+");
istmpdir=cwp_true;
if (verbose)
warn("putting temporary files in %s", directory);
}
/* Loop over input data and read to temporary file */
ntr = 0;
if(irregular ) {
float x,xmin=FLT_MAX,xmax=-FLT_MAX;
fprintf(x2fp,"x2=");
do {
if(ntr) fprintf(x2fp,",");
++ntr;
gethval(&tr,index1,&val);
if (isDepth || isCoord) {
gethval(&tr,index2,&scale);
x = (float) (vtod(type1,val) *
pow(10.0,vtod(type2,scale)));
} else
x = vtof(type1,val);
fprintf(x2fp,"%g",x);
xmin = MIN(xmin,x);
xmax = MAX(xmax,x);
if (isDepth && STREQ(style,"vsp")) {
int i;
for (i = 0; i < nt; ++i) tr.data[i] *= -1.0;
}
efwrite(tr.data, FSIZE, nt, datafp);
} while (gettr(&tr));
/* Flip vertical axis if style = vsp */
if (isDepth && STREQ(style,"vsp")) {
fprintf(x2fp," x2beg=%g x2end=%g",xmax,xmin);
style = "normal";
}
if(xmin==xmax) {
warn("values in header %s all equal,",key);
warn("using f2=%f d2=%f",f2,d2);
irregular=cwp_false;
have_ntr=cwp_false;
efclose(x2fp);
if (istmpdir) eremove(x2file);
}
} else {
do {
++ntr;
efwrite(tr.data, FSIZE, nt, datafp);
} while (gettr(&tr));
/* Save naive user */
if (STREQ(style,"vsp")) {
style = "normal";
warn("style=vsp requires key= to be set");
}
}
}
/* Set up pswigb command line */
if (irregular ) {
x2len = (off_t) eftell( x2fp );
x2string = (char *) emalloc( ++x2len );
rewind(x2fp);
fread(x2string,sizeof(char),x2len,x2fp);
plotcmd = (char *) emalloc(x2len+BUFSIZ);
if (STREQ(style,"vsp")) {
style = "normal";
}
sprintf(plotcmd, "%spswigb n1=%d d1=%f f1=%f %s style=%s", bindir,
nt, d1, f1, x2string, style);
free(x2string);
} else {
if (STREQ(style,"vsp")) {
style = "normal";
}
plotcmd = (char *) emalloc(BUFSIZ);
sprintf(plotcmd,
"%spswigb n1=%d n2=%d d1=%f d2=%f f1=%f f2=%f style=%s", bindir,
nt, ntr, d1, d2, f1, f2, style);
}
for (--argc, ++argv; argc; --argc, ++argv) {
if (strncmp(*argv, "d1=", 3) && /* skip those already set */
strncmp(*argv, "d2=", 3) &&
strncmp(*argv, "f1=", 3) &&
strncmp(*argv, "f2=", 3) &&
strncmp(*argv, "style=", 6)){
strcat(plotcmd, " "); /* put a space between args */
strcat(plotcmd, "\""); /* user quotes are stripped */
strcat(plotcmd, *argv); /* add the arg */
strcat(plotcmd, "\""); /* user quotes are stripped */
}
}
/* Open pipe to pswigb and send the traces */
plotfp = epopen(plotcmd, "w");
free(plotcmd);
if (!have_ntr || irregular) { /* send out stored traces one by one */
rewind(datafp);
{ register int itr;
for (itr = 0; itr < ntr; ++itr) {
efread (trbuf, FSIZE, nt, datafp);
efwrite(trbuf, FSIZE, nt, plotfp);
}
}
} else { /* just pump out traces and let pswigb do the work */
do {
efwrite(tr.data, FSIZE, nt, plotfp);
} while (gettr(&tr));
}
/* Clean up */
epclose(plotfp);
if (!have_ntr) {
efclose(datafp);
if (istmpdir) eremove(datafile);
}
if (irregular) {
efclose(x2fp);
if (istmpdir) eremove(x2file);
}
return EXIT_SUCCESS;
}
main(int argc, char **argv)
{
char plotcmd[BUFSIZ]; /* build ximage command for popen */
float *trbuf; /* trace buffer */
FILE *datafp; /* fp for trace data file */
FILE *plotfp; /* fp for plot data */
int nt; /* number of samples on trace */
int ntr; /* number of traces */
float d1; /* time/depth sample rate */
float d2; /* trace/dx sample rate */
float f1; /* tmin/zmin */
float f2; /* tracemin/xmin */
bool seismic; /* is this seismic data? */
int panel; /* panel to pick */
int dtype; /* type of display */
int ppos; /* position of the panel */
FILE *infp=stdin;
int n3,n2,n1;
/* Initialize */
initargs(argc, argv);
askdoc(1);
/* Get info from headers and first trace */
fgethdr(infp,&ch,&bh);
n1 = bh.hns;
if(!getparint("ntpp",&n2)) {
if (bh.tsort==2) {
n2 = bh.fold;
} else {
n2 = bh.ntrpr;
}
}
if (!fgettr(infp,&tr)) err("can't get first trace");
nt = tr.ns;
if ( n1!=nt )
warn("samples/trace in bhdr and trhdr different; trhdr used! \n");
n1 = nt;
fseek(infp,0L,2);
n3=(ftell(infp)-EBCBYTES-BNYBYTES)/(n1*sizeof(float)+HDRBYTES)/n2;
if(n3==0) {
n3=1;
n2=(ftell(infp)-EBCBYTES-BNYBYTES)/(n1*sizeof(float)+HDRBYTES);
warn("less traces were found in input! \n");
}
fseek(infp,0L,0);
seismic = (tr.trid == 0 || tr.trid == TREAL);
if (!getparint("panel", &panel)) panel=1;
if (!getparint("dtype", &dtype)) dtype=0;
if (!getparfloat("d1", &d1)) {
if (seismic) {
/* sampling interval in ms or in m (ft) */
if ( tr.dz!=0. ) {
d1 = tr.dz;
} else if (tr.dt) {
d1 = (float) tr.dt / 1000.0;
if (tr.dt<1000) d1 = tr.dt;
} else {
d1 = 0.004 * 1000.;
warn("tr.dt not set, assuming dt=4");
}
} else { /* non-seismic data */
if (tr.d1) {
d1 = tr.d1;
} else {
d1 = 1.0;
warn("tr.d1 not set, assuming d1=1.0");
}
}
}
if (!getparfloat("d2", &d2)) {
if(bh.tsort==2) {
d2 = tr.offset;
}
else {
d2 = tr.cdp;
}
}
if (!getparfloat("f1", &f1)) {
if (seismic) {
f1 = (tr.delrt) ? (float) tr.delrt/1000.0 : 0.0;
if(tr.delrt<1000) f1=tr.delrt;
if(tr.dz!=0.) f1=tr.fz;
} else {
f1 = (tr.f1) ? tr.f1 : 0.0;
}
}
if (!getparfloat("f2", &f2)) {
if (bh.tsort==2) {
f2 = tr.offset;
}
else {
f2 = tr.cdp;
}
}
/* Allocate trace buffer */
trbuf = ealloc1float(nt);
/* Create temporary "file" to hold data */
datafp = etempfile(NULL);
/* Loop over input traces & put them into the data file */
ntr = 0;
fseek(infp,EBCBYTES+BNYBYTES+(panel-1)*n2*(n1*sizeof(float)+HDRBYTES),0);
for(ntr=0;ntr<n2;ntr++) {
if(!fgettr(infp,&tr)) err("get trace error \n");
efwrite(tr.data, FSIZE, nt, datafp);
if(ntr==1) {
if (bh.tsort==2) {
if(!getparfloat("d2",&d2)) d2 = tr.offset-d2;
if (!getparint("ppos", &ppos)) ppos = tr.cdp;
} else {
if(!getparfloat("d2",&d2)) d2 = tr.cdp-d2;
if (!getparint("ppos", &ppos)) ppos = tr.offset;
}
}
}
/* Set up xipick or xwpick command line */
if ( dtype == 0 ) {
sprintf(plotcmd,
"mipick n1=%d n2=%d d1=%f d2=%f f1=%f f2=%f ppos=%d",
n1, n2, d1, d2, f1, f2, ppos);
} else {
sprintf(plotcmd,
"mwpick n1=%d n2=%d d1=%f d2=%f f1=%f f2=%f ppos=%d",
n1, n2, d1, d2, f1, f2, ppos);
}
for (--argc, ++argv; argc; --argc, ++argv) {
if (strncmp(*argv, "d1=", 3) && /* skip those already set */
strncmp(*argv, "d2=", 3) &&
strncmp(*argv, "f1=", 3) &&
strncmp(*argv, "f2=", 3)) {
strcat(plotcmd, " "); /* put a space between args */
strcat(plotcmd, "\""); /* user quotes are stripped */
strcat(plotcmd, *argv); /* add the arg */
strcat(plotcmd, "\""); /* user quotes are stripped */
}
}
/* Open pipe; read data to buf; write buf to plot program */
plotfp = epopen(plotcmd, "w");
rewind(datafp);
{ register int itr;
for (itr = 0; itr < ntr; ++itr) {
efread (trbuf, FSIZE, nt, datafp);
efwrite(trbuf, FSIZE, nt, plotfp);
}
}
/* Clean up */
epclose(plotfp);
efclose(datafp);
return EXIT_SUCCESS;
}
static int
pkgxfer(char *srcinst, int options)
{
int r;
struct pkginfo info;
FILE *fp, *pp;
char *pt, *src, *dst;
char dstdir[PATH_MAX],
temp[PATH_MAX],
srcdir[PATH_MAX],
cmd[CMDSIZE],
pkgname[NON_ABI_NAMELNGTH];
int i, n, part, nparts, maxpartsize, curpartcnt, iscomp;
char volnos[128], tmpvol[128];
struct statvfs64 svfsb;
longlong_t free_blocks;
struct stat srcstat;
info.pkginst = NULL; /* required initialization */
/*
* when this routine is entered, the first part of
* the package to transfer is already available in
* the directory indicated by 'src' --- unless the
* source device is a datstream, in which case only
* the pkginfo and pkgmap files are available in 'src'
*/
src = srcdev.dirname;
dst = dstdev.dirname;
if (!(options & PT_SILENT))
(void) fprintf(stderr, pkg_gt(MSG_TRANSFER), srcinst);
(void) strlcpy(dstinst, srcinst, sizeof (dstinst));
if (!(options & PT_ODTSTREAM)) {
/* destination is a (possibly mounted) directory */
(void) snprintf(dstdir, sizeof (dstdir),
"%s/%s", dst, dstinst);
/*
* need to check destination directory to assure
* that we will not be duplicating a package which
* already resides there (though we are allowed to
* overwrite the same version)
*/
pkgdir = src;
if (fpkginfo(&info, srcinst)) {
progerr(pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_NOEXISTS), srcinst);
(void) fpkginfo(&info, NULL);
return (1);
}
pkgdir = dst;
(void) strlcpy(temp, srcinst, sizeof (temp));
if (pt = strchr(temp, '.'))
*pt = '\0';
(void) strlcat(temp, ".*", sizeof (temp));
if (pt = fpkginst(temp, info.arch, info.version)) {
/*
* the same instance already exists, although
* its pkgid might be different
*/
if (options & PT_OVERWRITE) {
(void) strlcpy(dstinst, pt, sizeof (dstinst));
(void) snprintf(dstdir, sizeof (dstdir),
"%s/%s", dst, dstinst);
} else {
progerr(pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_DUPVERS), srcinst);
(void) fpkginfo(&info, NULL);
(void) fpkginst(NULL);
return (2);
}
} else if (options & PT_RENAME) {
/*
* find next available instance by appending numbers
* to the package abbreviation until the instance
* does not exist in the destination directory
*/
if (pt = strchr(temp, '.'))
*pt = '\0';
for (i = 2; (access(dstdir, 0) == 0); i++) {
(void) snprintf(dstinst, sizeof (dstinst),
"%s.%d", temp, i);
(void) snprintf(dstdir, sizeof (dstdir),
"%s/%s", dst, dstinst);
}
} else if (options & PT_OVERWRITE) {
/*
* we're allowed to overwrite, but there seems
* to be no valid package to overwrite, and we are
* not allowed to rename the destination, so act
* as if we weren't given permission to overwrite
* --- this keeps us from removing a destination
* instance which is named the same as the source
* instance, but really reflects a different pkg!
*/
options &= (~PT_OVERWRITE);
}
(void) fpkginfo(&info, NULL);
(void) fpkginst(NULL);
if (ckoverwrite(dst, dstinst, options))
return (2);
if (isdir(dstdir) && mkdir(dstdir, 0755)) {
progerr(pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_MKDIR), dstdir);
return (1);
}
(void) snprintf(srcdir, sizeof (srcdir),
"%s/%s", src, srcinst);
if (stat(srcdir, &srcstat) != -1) {
if (chmod(dstdir, (srcstat.st_mode & S_IAMB)) == -1) {
progerr(pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_CHMODDIR), dstdir);
return (1);
}
} else {
progerr(pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_STATDIR), srcdir);
return (1);
}
}
if (!(options & PT_SILENT) && strcmp(dstinst, srcinst))
(void) fprintf(stderr, pkg_gt(MSG_RENAME), dstinst);
(void) snprintf(srcdir, sizeof (srcdir), "%s/%s", src, srcinst);
if (chdir(srcdir)) {
progerr(pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_CHDIR), srcdir);
return (1);
}
if (ids_name) { /* unpack the datatstream into a directory */
/*
* transfer pkginfo & pkgmap first
*/
(void) snprintf(cmd, sizeof (cmd),
"%s -pudm %s", CPIOPROC, dstdir);
if ((pp = epopen(cmd, "w")) == NULL) {
rpterr();
progerr(pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_POPEN), cmd, errno);
return (1);
}
(void) fprintf(pp, "%s\n%s\n", PKGINFO, PKGMAP);
(void) sighold(SIGINT);
(void) sighold(SIGHUP);
r = epclose(pp);
(void) sigrelse(SIGINT);
(void) sigrelse(SIGHUP);
if (r != 0) {
rpterr();
progerr(pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_PCLOSE), cmd, errno);
return (1);
}
if (options & PT_INFO_ONLY)
return (0); /* don't transfer objects */
if (chdir(dstdir)) {
progerr(pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_CHDIR), dstdir);
return (1);
}
/*
* for each part of the package, use cpio() to
* unpack the archive into the destination directory
*/
nparts = ds_findpkg(srcdev.cdevice, srcinst);
if (nparts < 0) {
progerr(pkg_gt(ERR_TRANSFER));
return (1);
}
for (part = 1; part <= nparts; /* void */) {
if (ds_getpkg(srcdev.cdevice, part, dstdir)) {
progerr(pkg_gt(ERR_TRANSFER));
return (1);
}
part++;
if (dstdev.mount) {
(void) chdir("/");
if (pkgumount(&dstdev))
return (1);
if (part <= nparts) {
if (n = pkgmount(&dstdev, NULL, part+1,
nparts, 1))
return (n);
if (ckoverwrite(dst, dstinst, options))
return (1);
if (isdir(dstdir) &&
mkdir(dstdir, 0755)) {
progerr(
pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_MKDIR),
dstdir);
return (1);
}
/*
* since volume is removable, each part
* must contain a duplicate of the
* pkginfo file to properly identify the
* volume
*/
if (chdir(srcdir)) {
progerr(
pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_CHDIR),
srcdir);
return (1);
}
if ((pp = epopen(cmd, "w")) == NULL) {
rpterr();
progerr(
pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_POPEN),
cmd, errno);
return (1);
}
(void) fprintf(pp, "pkginfo");
(void) sighold(SIGINT);
(void) sighold(SIGHUP);
r = epclose(pp);
(void) sigrelse(SIGINT);
(void) sigrelse(SIGHUP);
if (r != 0) {
rpterr();
progerr(
pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_PCLOSE),
cmd, errno);
return (1);
}
if (chdir(dstdir)) {
progerr(
pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_CHDIR),
dstdir);
return (1);
}
}
}
}
return (0);
}
if ((fp = fopen(PKGMAP, "r")) == NULL) {
progerr(pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_NOPKGMAP), srcinst);
return (1);
}
nparts = 1;
if (!rd_map_size(fp, &nparts, &maxpartsize, &compressedsize))
return (1);
else
(void) fclose(fp);
if (srcdev.mount) {
if (ckvolseq(srcdir, 1, nparts)) {
progerr(pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_SEQUENCE));
return (1);
}
}
/* write each part of this package */
if (options & PT_ODTSTREAM) {
char line[128];
(void) mgets(line, 128);
curpartcnt = -1;
/* LINTED E_SEC_SCANF_UNBOUNDED_COPY */
if (sscanf(line, "%s %d %d %[ 0-9]", pkgname, &nparts,
&maxpartsize, volnos) == 4) {
(void) sscanf(volnos,
"%d %[ 0-9]", &curpartcnt, tmpvol);
(void) strlcpy(volnos, tmpvol, sizeof (volnos));
}
}
for (part = 1; part <= nparts; /* void */) {
if (curpartcnt == 0 && (options & PT_ODTSTREAM)) {
char prompt[128];
int index;
ds_volno++;
(void) ds_close(0);
(void) sprintf(prompt,
pkg_gt("Insert %%v %d of %d into %%p"),
ds_volno, ds_volcnt);
if (n = getvol(ods_name, NULL, DM_FORMAT, prompt))
return (n);
if ((ds_fd = open(dstdev.cdevice, O_WRONLY)) < 0) {
progerr(pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_OPEN), dstdev.cdevice,
errno);
return (1);
}
if (ds_ginit(dstdev.cdevice) < 0) {
progerr(pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_OPEN), dstdev.cdevice,
errno);
(void) ds_close(0);
return (1);
}
(void) sscanf(volnos, "%d %[ 0-9]", &index, tmpvol);
(void) strlcpy(volnos, tmpvol, sizeof (volnos));
curpartcnt += index;
}
if (options & PT_INFO_ONLY)
nparts = 0;
if (part == 1) {
(void) snprintf(cmd, sizeof (cmd),
"find %s %s", PKGINFO, PKGMAP);
if (nparts && (isdir(INSTALL) == 0)) {
(void) strlcat(cmd, " ", sizeof (cmd));
(void) strlcat(cmd, INSTALL, sizeof (cmd));
}
} else
(void) snprintf(cmd, sizeof (cmd), "find %s", PKGINFO);
if (nparts > 1) {
(void) snprintf(temp, sizeof (temp),
"%s.%d", RELOC, part);
if (iscpio(temp, &iscomp) || isdir(temp) == 0) {
(void) strlcat(cmd, " ", sizeof (cmd));
(void) strlcat(cmd, temp, sizeof (cmd));
}
(void) snprintf(temp, sizeof (temp),
"%s.%d", ROOT, part);
if (iscpio(temp, &iscomp) || isdir(temp) == 0) {
(void) strlcat(cmd, " ", sizeof (cmd));
(void) strlcat(cmd, temp, sizeof (cmd));
}
(void) snprintf(temp, sizeof (temp),
"%s.%d", ARCHIVE, part);
if (isdir(temp) == 0) {
(void) strlcat(cmd, " ", sizeof (cmd));
(void) strlcat(cmd, temp, sizeof (cmd));
}
} else if (nparts) {
for (i = 0; reloc_names[i] != NULL; i++) {
if (iscpio(reloc_names[i], &iscomp) ||
isdir(reloc_names[i]) == 0) {
(void) strlcat(cmd, " ", sizeof (cmd));
(void) strlcat(cmd, reloc_names[i],
sizeof (cmd));
}
}
for (i = 0; root_names[i] != NULL; i++) {
if (iscpio(root_names[i], &iscomp) ||
isdir(root_names[i]) == 0) {
(void) strlcat(cmd, " ", sizeof (cmd));
(void) strlcat(cmd, root_names[i],
sizeof (cmd));
}
}
if (isdir(ARCHIVE) == 0) {
(void) strlcat(cmd, " ", sizeof (cmd));
(void) strlcat(cmd, ARCHIVE, sizeof (cmd));
}
}
if (options & PT_ODTSTREAM) {
(void) snprintf(cmd + strlen(cmd),
sizeof (cmd) - strlen(cmd),
" -print | %s -ocD -C %d",
CPIOPROC, (int)BLK_SIZE);
} else {
if (statvfs64(dstdir, &svfsb) == -1) {
progerr(pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_STATVFS), dstdir, errno);
return (1);
}
free_blocks = (((long)svfsb.f_frsize > 0) ?
howmany(svfsb.f_frsize, DEV_BSIZE) :
howmany(svfsb.f_bsize, DEV_BSIZE)) * svfsb.f_bavail;
if ((has_comp_size ? compressedsize : maxpartsize) >
free_blocks) {
progerr(pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_NOSPACE),
has_comp_size ?
(long)compressedsize : (long)maxpartsize,
free_blocks);
return (1);
}
(void) snprintf(cmd + strlen(cmd),
sizeof (cmd) - strlen(cmd),
" -print | %s -pdum %s",
CPIOPROC, dstdir);
}
n = esystem(cmd, -1, (options & PT_ODTSTREAM) ? ds_fd : -1);
if (n) {
rpterr();
progerr(pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_CMDFAIL), cmd, n);
return (1);
}
part++;
if (srcdev.mount && (nparts > 1)) {
/* unmount current source volume */
(void) chdir("/");
if (pkgumount(&srcdev))
return (1);
/* loop until volume is mounted successfully */
while (part <= nparts) {
/* read only */
n = pkgmount(&srcdev, NULL, part, nparts, 1);
if (n)
return (n);
if (chdir(srcdir)) {
progerr(pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_CORRUPT));
(void) chdir("/");
(void) pkgumount(&srcdev);
continue;
}
if (ckvolseq(srcdir, part, nparts)) {
(void) chdir("/");
(void) pkgumount(&srcdev);
continue;
}
break;
}
}
if (!(options & PT_ODTSTREAM) && dstdev.mount) {
/* unmount current volume */
if (pkgumount(&dstdev))
return (1);
/* loop until next volume is mounted successfully */
while (part <= nparts) {
/* writable */
n = pkgmount(&dstdev, NULL, part, nparts, 1);
if (n)
return (n);
if (ckoverwrite(dst, dstinst, options))
continue;
if (isdir(dstdir) && mkdir(dstdir, 0755)) {
progerr(pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_MKDIR), dstdir);
continue;
}
break;
}
}
if ((options & PT_ODTSTREAM) && part <= nparts) {
if (curpartcnt >= 0 && part > curpartcnt) {
char prompt[128];
int index;
ds_volno++;
if (ds_close(0))
return (1);
(void) sprintf(prompt,
pkg_gt("Insert %%v %d of %d into %%p"),
ds_volno, ds_volcnt);
if (n = getvol(ods_name, NULL, DM_FORMAT,
prompt))
return (n);
if ((ds_fd = open(dstdev.cdevice, 1)) < 0) {
progerr(pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_OPEN),
dstdev.cdevice, errno);
return (1);
}
if (ds_ginit(dstdev.cdevice) < 0) {
progerr(pkg_gt(ERR_TRANSFER));
logerr(pkg_gt(MSG_OPEN),
dstdev.cdevice, errno);
(void) ds_close(0);
return (1);
}
(void) sscanf(volnos, "%d %[ 0-9]", &index,
tmpvol);
(void) strlcpy(volnos, tmpvol, sizeof (volnos));
curpartcnt += index;
}
}
}
return (0);
}
int
main(int argc, char **argv)
{
char plotcmd[BUFSIZ]; /* build psmovie command for popen */
float *trbuf; /* trace buffer */
FILE *plotfp; /* fp for plot data */
int nt; /* number of samples on trace */
int n2; /* number of traces per frame */
int n3; /* number of frames in data */
int ntr; /* number of traces */
int verbose; /* verbose flag */
float d1; /* time/depth sample rate */
float d2; /* trace/dx sample rate */
float f1; /* tmin/zmin */
float f2; /* tracemin/xmin */
cwp_Bool seismic; /* is this seismic data? */
cwp_Bool have_n2 = cwp_false;/* was n2 getparred? */
cwp_Bool have_n3 = cwp_false;/* was n3 getparred? */
cwp_Bool have_ntr = cwp_false;/* was ntr set in header? */
char *tmpdir; /* directory path for tmp files */
cwp_Bool istmpdir=cwp_false;/* true for user given path */
char *cwproot; /* value of CWPROOT environment variable*/
char *bindir; /* directory path for tmp files */
/* Initialize */
initargs(argc, argv);
requestdoc(1);
/* Get info from first trace */
if (!gettr(&tr)) err("can't get first trace");
seismic = ISSEISMIC(tr.trid);
nt = tr.ns;
ntr = tr.ntr;
if (ntr) have_ntr = cwp_true;
if (!getparint("verbose", &verbose)) verbose=0;
if (!getparfloat("d1", &d1)) {
if (tr.d1) d1 = tr.d1;
else if (tr.dt) d1 = ((double) tr.dt)/1000000.0;
else {
if (seismic) {
d1 = 0.004;
warn("tr.dt not set, assuming dt=0.004");
} else { /* non-seismic data */
d1 = 1.0;
warn("tr.d1 not set, assuming d1=1.0");
}
}
}
if (!getparfloat("d2", &d2)) d2 = (tr.d2) ? tr.d2 : 1.0;
if (!getparfloat("f1", &f1)) {
if (tr.f1) f1 = tr.f1;
else if (tr.delrt) f1 = (float) tr.delrt/1000.0;
else f1 = 0.0;
}
if (!getparfloat("f2", &f2)) {
if (tr.f2) f2 = tr.f2;
else if (tr.tracr) f2 = (float) tr.tracr;
else if (tr.tracl) f2 = (float) tr.tracl;
else if (seismic) f2 = 1.0;
else f2 = 0.0;
}
if (!getparfloat("f2", &f2)) f2 = 1.0;
/* Look for user-supplied tmpdir */
if (!getparstring("tmpdir",&tmpdir) &&
!(tmpdir = getenv("CWP_TMPDIR"))) tmpdir="";
if (!STREQ(tmpdir, "") && access(tmpdir, WRITE_OK))
err("you can't write in %s (or it doesn't exist)", tmpdir);
/* See if CWPBIN environment variable is not set */
if (!(bindir = getenv("CWPBIN"))) { /* construct bindir from CWPROOT */
bindir = (char *) emalloc(BUFSIZ);
/* Get value of CWPROOT environment variable */
if (!(cwproot = getenv("CWPROOT"))) cwproot ="" ;
if (STREQ(cwproot, "")) {
warn("CWPROOT environment variable is not set! ");
err("Set CWPROOT in shell environment as per instructions in CWP/SU Installation README files");
}
/* then bindir = $CWPROOT/bin */
sprintf(bindir, "%s/bin", cwproot);
}
strcat(bindir,"/"); /* put / at the end of bindir */
/* Allocate trace buffer */
trbuf = ealloc1float(nt);
/* Get or set n2 and n3 */
if (getparint("n2", &n2)) have_n2 = cwp_true;
if (getparint("n3", &n3)) have_n3 = cwp_true;
if (have_n2 && have_n3) have_ntr = cwp_true;
if (!have_ntr) { /* count traces */
if (verbose) {
warn("n2 or n3 not getparred, or ntr header field not set");
warn(" ... counting traces");
}
/* Create temporary "file" to hold data */
if (STREQ(tmpdir,"")) {
tracefp = etmpfile();
if (verbose) warn("using tmpfile() call");
} else { /* user-supplied tmpdir */
char directory[BUFSIZ];
strcpy(directory, tmpdir);
strcpy(tracefile, temporary_filename(directory));
/* Handle user interrupts */
signal(SIGINT, (void (*) (int)) closefiles);
signal(SIGTERM, (void (*) (int)) closefiles);
tracefp = efopen(tracefile, "w+");
istmpdir=cwp_true;
if (verbose)
warn("putting temporary files in %s", directory);
}
/* Loop over input frames & put them into the data file */
ntr = 0;
do {
++ntr;
efwrite(tr.data, FSIZE, nt, tracefp);
} while (gettr(&tr));
}
/* Set dimensions of movie */
if (!have_n2 && !have_n3) { n2 = ntr; n3=1; }
if (have_n2 && !have_n3) n3 = ntr/n2;
if (!have_n2 && have_n3) n2 = ntr/n3;
/* Set up psmovie command line */
sprintf(plotcmd,
"%spsmovie n1=%d n2=%d n3=%d d1=%f d2=%f f1=%f f2=%f", bindir,
nt, n2, n3, d1, d2, f1, f2);
fprintf(stderr, "%s\n", plotcmd);
for (--argc, ++argv; argc; --argc, ++argv) {
if (strncmp(*argv, "d1=", 3) && /* skip those already set */
strncmp(*argv, "d2=", 3) &&
strncmp(*argv, "f1=", 3) &&
strncmp(*argv, "f2=", 3)) {
strcat(plotcmd, " "); /* put a space between args */
strcat(plotcmd, "\""); /* user quotes are stripped */
strcat(plotcmd, *argv); /* add the arg */
strcat(plotcmd, "\""); /* user quotes are stripped */
}
}
/* Open pipe to psmovie and send the traces */
plotfp = epopen(plotcmd, "w");
if (!have_ntr){
/* send out stored traces one by one */
rewind(tracefp);
{ register int itr;
for (itr = 0; itr < ntr; ++itr) {
efread (trbuf, FSIZE, nt, tracefp);
efwrite(trbuf, FSIZE, nt, plotfp);
}
}
} else { /* just pump out traces and let psmovie do the work */
do {
efwrite(tr.data, FSIZE, nt, plotfp);
} while (gettr(&tr));
}
/* Clean up */
epclose(plotfp);
if (!have_ntr) {
efclose(tracefp);
if (istmpdir) eremove(tracefile);
}
return EXIT_SUCCESS;
}
int
pkgmount(struct pkgdev *devp, char *pkg, int part, int nparts, int getvolflg)
{
int n;
char *pt, prompt[64], cmd[CMDSIZ];
FILE *pp;
if (getuid()) {
progerr(pkg_gt(ERR_NOTROOT));
return (99);
}
if (part && nparts) {
if (pkg) {
(void) snprintf(prompt, sizeof (prompt),
pkg_gt(LABEL0), part, nparts, pkg);
} else {
(void) snprintf(prompt, sizeof (prompt),
pkg_gt(LABEL1), part, nparts);
}
} else if (pkg)
(void) snprintf(prompt, sizeof (prompt), pkg_gt(LABEL2), pkg);
else
(void) snprintf(prompt, sizeof (prompt), pkg_gt(LABEL3));
n = 0;
for (;;) {
if (!getvolflg && n)
/*
* Return to caller if not prompting
* and error was encountered.
*/
return (-1);
if (getvolflg && (n = getvol(devp->bdevice, NULL,
(devp->rdonly ? 0 : DM_FORMFS|DM_WLABEL), prompt))) {
if (n == 3)
return (3);
if (n == 2)
progerr(pkg_gt("unknown device <%s>"),
devp->bdevice);
else
progerr(
pkg_gt("unable to obtain package volume"));
return (99);
}
if (devp->fstyp == NULL) {
(void) snprintf(cmd, sizeof (cmd),
"%s %s", FSTYP, devp->bdevice);
if ((pp = epopen(cmd, "r")) == NULL) {
rpterr();
logerr(pkg_gt(ERR_FSTYP), devp->bdevice);
n = -1;
continue;
}
cmd[0] = '\0';
if (fgets(cmd, CMDSIZ, pp) == NULL) {
logerr(pkg_gt(ERR_FSTYP), devp->bdevice);
(void) pclose(pp);
n = -1;
continue;
}
if (epclose(pp)) {
rpterr();
logerr(pkg_gt(ERR_FSTYP), devp->bdevice);
n = -1;
continue;
}
if (pt = strpbrk(cmd, " \t\n"))
*pt = '\0';
if (cmd[0] == '\0') {
logerr(pkg_gt(ERR_FSTYP), devp->bdevice);
n = -1;
continue;
}
devp->fstyp = strdup(cmd);
}
if (devp->rdonly) {
n = pkgexecl(NULL, NULL, NULL, NULL, MOUNT, "-r", "-F",
devp->fstyp, devp->bdevice, devp->mount, NULL);
} else {
n = pkgexecl(NULL, NULL, NULL, NULL, MOUNT, "-F",
devp->fstyp, devp->bdevice, devp->mount, NULL);
}
if (n) {
progerr(pkg_gt("mount of %s failed"), devp->bdevice);
continue;
}
devp->mntflg++;
break;
}
return (0);
}
main(int argc, char **argv)
{
FILE *ifp; /* file pointer for input */
FILE *hfp; /* file pointer for popen write */
int bfd; /* file descriptor for bfile */
string tape; /* name of raw tape device */
int clean; /* clean trace header */
int verbose; /* echo every 20th trace */
int over; /* check format */
int convert; /* convert ibm fpt to ieee fpt */
string hfile; /* name of ascii header file */
string bfile; /* name of binary header file */
int trmin; /* first trace to read */
int trmax; /* last trace to read */
int nt; /* number of data samples */
char cmdbuf[BUFSIZ]; /* dd command buffer */
char ebcbuf[EBCBYTES]; /* ebcdic data buffer */
int itr = 0; /* current trace number */
bool nsflag = FALSE; /* flag for error in tr.ns */
char hdr_buf[10]; /* 1st 10 bytes of header in ascii */
char tmp_buf[3600]; /* temp. buffer to read in header */
unsigned int nsamp; /* number of samples per trace */
int i; /* loop counter to zero trace samples */
int *ibstart,*ibyte,*itype;
int *obstart,*obyte,*otype;
int nmap=0, imap;
int ibs,iby,ity,obs,oby,oty;
short itmp2;
int itmp4;
float tmp;
int ntg=0;
int rmbadtrace, ibt, nbt;
/* initialize */
initargs(argc, argv);
askdoc(1);
/* make sure stdout is a file or pipe */
switch(filestat(STDOUT)) {
case TTY:
err("stdout can't be tty");
break;
case DIRECTORY:
err("stdout must be a file, not a directory");
break;
case BADFILETYPE:
err("stdout is illegal filetype");
break;
}
/* set filenames */
if (!getparstring("tape", &tape)) {
ifp = stdin;
file2g(ifp);
} else {
/* open files - first the tape */
ifp = efopen(tape, "r");
}
file2g(stdout);
/* set parameters */
if (!getparint("clean", &clean)) clean = 1;
if (!getparint("verbose", &verbose)) verbose = 0;
if (!getparint("over", &over)) over = 0;
if (!getparint("convert", &convert)) convert = 1;
if (!getparint("trmin", &trmin)) trmin = 1;
if (!getparint("trmax", &trmax)) trmax = LONG_MAX;
if (!getparint("rmbadtrace",&rmbadtrace)) rmbadtrace=0;
nmap = countparval("ibstart");
if(nmap>0) {
ibstart = (int*) malloc(nmap*sizeof(int));
ibyte = (int*) malloc(nmap*sizeof(int));
itype = (int*) malloc(nmap*sizeof(int));
obstart = (int*) malloc(nmap*sizeof(int));
obyte = (int*) malloc(nmap*sizeof(int));
otype = (int*) malloc(nmap*sizeof(int));
if(getparint("ibstart",ibstart)!=nmap) err(" check ibstart");
if(getparint("ibyte",ibyte)!=nmap) err(" check ibyte");
if(getparint("itype",itype)!=nmap) err(" check itype");
if(getparint("obstart",obstart)!=nmap) err(" check obstart");
if(getparint("obyte",obyte)!=nmap) err(" check obyte");
if(getparint("otype",otype)!=nmap) err(" check otype");
}
/* read ebcdic and binary headers */
efread(ebcbuf, 1, EBCBYTES, ifp);
efread((char *)&bh, 1, BNYBYTES, ifp);
if (bh.format != 1)
(over) ? warn("ignore bh.format ... continue") :
err("format not IBM floating point");
if (!convert) warn(
"assuming data is IEEE floating point, no conversion will be done");
/* set nt parameter */
if (!getparint("nt", &nt)) {
nt = bh.hns;
ntg = 0;
} else {
ntg = 1;
}
/* if needed, save ebcbuf into hfile */
if (getparstring("hfile", &hfile)) {
/* Open pipe to use dd to convert ebcdic to ascii */
sprintf(cmdbuf,
"dd ibs=3200 of=%s conv=ascii cbs=80 count=1", hfile);
hfp = epopen(cmdbuf, "w");
/* Write ascii stream from buffer into pipe */
efwrite(ebcbuf, EBCBYTES, 1, hfp);
epclose(hfp);
}
/* save the binary file, if needed */
if (getparstring("bfile", &bfile)) {
/* - the binary data file */
bfd = eopen(bfile, O_WRONLY | O_CREAT | O_TRUNC, 0644);
/* Write binary header from bhed structure to binary file */
ewrite(bfd, (char *)&bh, BNYBYTES);
eclose(bfd);
}
/* convert ebcdic to ascii for output data */
tascii_((unsigned char*)ebcbuf, (unsigned char*)&ch, EBCBYTES, 0);
if (strncmp((char*)&ch, "C 1 CLIENT",10) != 0 ) {
memcpy((char *)&ch, "C 1 CLIENT", 10);
}
/* test if number of samples set in binary header */
if (!bh.hns) {
warn("samples/trace not set in binary header \n");
if (nt == 0)
warn("samples/trace in 1st trace used \n");
else
warn("nt in input used for samples/trace \n");
}
if ((nt != bh.hns) && (nt != 0)) {
warn("samples/trace reset in binary header =%d \n",nt);
bh.hns = nt;
}
/* output ascii and binary headers to stdout */
puthdr(&ch, &bh);
nbt = 0;
/* convert the traces */
while (efread((char *)&tr, 1, HDRBYTES, ifp) && (itr < trmax)) {
/* check first 10 bytes to look for ebcdic header,
if found, this probably indicates a tape switch */
/*
tascii_((unsigned char*)&tr, &hdr_buf, 10, 0);
if ((strncmp(hdr_buf, "C 1 CLIENT", 10) == 0)
|| (strncmp(hdr_buf, "C CLIENT ", 10) == 0)
|| (strncmp(hdr_buf, "C 1 ", 4) == 0)) {
fprintf(stderr," %
efread(tmp_buf, 1, 3600 - HDRBYTES, ifp);
} else {
*/
/* read in the trace data */
if(tr.ns==0) tr.ns = nt;
if(ntg==0) {
nsamp = tr.ns * 4;
} else {
nsamp = nt * 4;
}
efread((char *)&tr + HDRBYTES, 1, nsamp, ifp);
ibt = 0;
/* Check bh.hns with tr.ns */
if (bh.hns != tr.ns) {
nsflag = true;
ibt = 1;
nbt = nbt + 1;
/* print warning message */
if(verbose==1 || nbt<1000) warn("discrepant tr.ns = %d with bh.hns = %d\n"
"\t... noted on trace %d", tr.ns, bh.hns, itr + 1);
/* if user wants to leave things the way they are (nt=0) */
/* otherwise, modify number of samples per trace */
if (nt != 0) {
if (nt > tr.ns) {
for (i = tr.ns; i < nt; i++)
tr.data[i] = 0.0;
}
nsamp = nt * 4;
tr.ns = nt;
}
}
/* convert and write desired traces */
if (++itr >= trmin) {
/* Convert IBM floats to native floats */
if (convert)
conv_float((char *)tr.data, (char *)tr.data, tr.ns, 1);
/* write the trace to disk */
if(nmap==0) {
/* clean up trace header beyond 180 bytes */
if (clean == 1) bzero((char *)&tr + 180, 60);
if (ibt==0 || rmbadtrace==0)
efwrite((char *)&tr, 1, nsamp + HDRBYTES, stdout);
} else {
bcopy((char*)&tr,(char*)&tro,nsamp+HDRBYTES);
for(imap=0;imap<nmap;imap++) {
ibs = ibstart[imap];
iby = ibyte[imap];
ity = itype[imap];
obs = obstart[imap];
oby = obyte[imap];
oty = otype[imap];
/*
fprintf(stderr,"ibs=%d iby=%d ity=%d obs=%d oby=%d oty=%d \n",
ibs,iby,ity,obs,oby,oty);
*/
if(iby==oby && ity==oty && ity!=1 ) {
bcopy((char*)&tr+ibs-1,(char*)&tro+obs-1,iby);
} else {
if(ity==1) {
conv_float((char*)&tr+ibs-1,(char*)&tmp,1,1);
} else {
if(iby==2) {
bcopy((char*)&tr+ibs-1,(char*)&itmp2,iby);
tmp = itmp2;
} else if(iby==4) {
bcopy((char*)&tr+ibs-1,(char*)&itmp4,iby);
tmp = itmp4;
}
}
if(oty==1) {
bcopy((char*)&tmp,(char*)&tro+obs-1,oby);
} else {
tmp = tmp + 0.5;
if(oby==2) {
itmp2 = (short) tmp;
bcopy((char*)&itmp2,(char*)&tro+obs-1,oby);
} else {
itmp4 = (int) tmp;
bcopy((char*)&itmp4,(char*)&tro+obs-1,oby);
}
}
}
}
/* clean up trace header beyond 180 bytes */
if (clean == 1) bzero((char *)&tro + 180, 60);
if (ibt==0 || rmbadtrace==0)
efwrite((char *)&tro, 1, nsamp + HDRBYTES, stdout);
}
/* echo under verbose option */
if (verbose && itr % 20 == 0)
warn(" %d traces from tape", itr);
}
/*
}
*/
} /* while loop */
/* re-iterate error in case not seen during run */
if ((nsflag) && (nt != 0))
warn("discrepancy found in header and trace ns values\n"
"\theader value (%d) was used to extract traces", bh.hns);
/* clean up */
efclose(ifp);
if(nmap>0) {
free(ibstart);
free(ibyte);
free(itype);
free(obstart);
free(obyte);
free(otype);
}
return EXIT_SUCCESS;
}
int
main(int argc, char **argv)
{
char plotcmd[BUFSIZ]; /* build command for popen */
FILE *plotfp; /* fp for plot data */
float d1; /* time/depth sample rate */
float d2; /* trace/dx sample rate */
float f1; /* tmin/zmin */
float f2; /* tracemin/xmin */
int nt; /* number of samples on trace */
int ntr; /* number of traces */
int verbose; /* verbose flag */
cwp_Bool seismic; /* is this seismic data? */
cwp_Bool have_ntr=cwp_false;/* is ntr known from header or user? */
cwp_String mode; /* sumax mode parameter */
char *tmpdir; /* directory path for tmp files */
cwp_Bool istmpdir=cwp_false;/* true for user given path */
char *cwproot; /* value of CWPROOT environment variable*/
char *bindir; /* directory path for tmp files */
/* Initialize */
initargs(argc, argv);
requestdoc(1);
/* Get info from first trace */
if (!gettr(&tr)) err("can't get first trace");
seismic = ISSEISMIC(tr.trid);
nt = tr.ns;
ntr = tr.ntr;
if (ntr) have_ntr = cwp_true;
if (!getparint("verbose", &verbose)) verbose=0;
if (!getparfloat("d1", &d1)) {
if (tr.d1) d1 = tr.d1;
else if (tr.dt) d1 = ((double) tr.dt)/1000000.0;
else {
if (seismic) {
d1 = 0.004;
warn("tr.dt not set, assuming dt=0.004");
} else { /* non-seismic data */
d1 = 1.0;
warn("tr.d1 not set, assuming d1=1.0");
}
}
}
if (!getparfloat("d2", &d2)) d2 = (tr.d2) ? tr.d2 : 1.0;
if (!getparfloat("f1", &f1)) {
if (tr.f1) f1 = tr.f1;
else if (tr.delrt) f1 = (float) tr.delrt/1000.0;
else f1 = 0.0;
}
if (!getparfloat("f2", &f2)) {
if (tr.f2) f2 = tr.f2;
else if (tr.tracr) f2 = (float) tr.tracr;
else if (tr.tracl) f2 = (float) tr.tracl;
else if (seismic) f2 = 1.0;
else f2 = 0.0;
}
if (getparint("n2", &ntr) || getparint("ntr", &ntr)) have_ntr = cwp_true;
if (!getparstring("mode", &mode)) mode = "max";
/* Look for user-supplied tmpdir */
if (!getparstring("tmpdir",&tmpdir) &&
!(tmpdir = getenv("CWP_TMPDIR"))) tmpdir="";
if (!STREQ(tmpdir, "") && access(tmpdir, WRITE_OK))
err("you can't write in %s (or it doesn't exist)", tmpdir);
/* See if CWPBIN environment variable is not set */
if (!(bindir = getenv("CWPBIN"))) { /* construct bindir from CWPROOT */
bindir = (char *) emalloc(BUFSIZ);
/* Get value of CWPROOT environment variable */
if (!(cwproot = getenv("CWPROOT"))) cwproot ="" ;
if (STREQ(cwproot, "")) {
warn("CWPROOT environment variable is not set! ");
err("Set CWPROOT in shell environment as per instructions in CWP/SU Installation README files");
}
/* then bindir = $CWPROOT/bin */
sprintf(bindir, "%s/bin", cwproot);
}
strcat(bindir,"/"); /* put / at the end of bindir */
/* Allocate trace buffer */
if (!have_ntr) {
/* Store traces and headers in tmpfile while getting a count */
if (verbose) {
warn(" n2 not getparred or header field ntr not set");
warn(" .... counting traces");
}
/* Store traces and headers in tmpfile while getting a count */
if (STREQ(tmpdir,"")) {
tracefp = etmpfile();
headerfp = etmpfile();
if (verbose) warn("using tmpfile() call");
} else { /* user-supplied tmpdir */
char directory[BUFSIZ];
strcpy(directory, tmpdir);
strcpy(tracefile, temporary_filename(directory));
strcpy(headerfile, temporary_filename(directory));
/* Trap signals so can remove temp files */
signal(SIGINT, (void (*) (int)) closefiles);
signal(SIGQUIT, (void (*) (int)) closefiles);
signal(SIGHUP, (void (*) (int)) closefiles);
signal(SIGTERM, (void (*) (int)) closefiles);
tracefp = efopen(tracefile, "w+");
headerfp = efopen(headerfile, "w+");
istmpdir=cwp_true;
if (verbose)
warn("putting temporary files in %s", directory);
}
/* Loop over input data and read to temporary file */
ntr = 0;
do {
++ntr;
efwrite(&tr, 1, HDRBYTES, headerfp);
efwrite(tr.data, FSIZE, nt, tracefp);
} while (gettr(&tr));
}
/* System call to xgraph */
sprintf(plotcmd, "%ssumax output=binary mode=%s | %sxgraph n=%d",
bindir, mode, bindir, ntr);
for (--argc, ++argv; argc; --argc, ++argv) {
if (
strncmp(*argv, "output=", 7) &&
strncmp(*argv, "mode=", 5) &&
strncmp(*argv, "n=", 2) &&
strncmp(*argv, "n2=", 3) &&/*xgraph honors n2,nplot*/
strncmp(*argv, "nplot=", 6) ) {
strcat(plotcmd, " "); /* put a space between args */
strcat(plotcmd, "\""); /* user quotes are stripped */
strcat(plotcmd, *argv); /* add the arg */
strcat(plotcmd, "\""); /* user quotes are stripped */
}
}
/* Open pipe; write data to plotcmd */
plotfp = epopen(plotcmd, "w");
if (!have_ntr) {
rewind(headerfp);
rewind(tracefp);
{ register int itr;
for (itr = 0; itr < ntr; ++itr) {
efread(&tr, 1, HDRBYTES, headerfp);
efread(tr.data, FSIZE, nt, tracefp);
fputtr(plotfp, &tr);
}
}
} else { /* pump out traces and let sumax and psimage do the work */
do {
fputtr(plotfp,&tr);
} while (gettr(&tr));
}
/* Clean up */
epclose(plotfp);
efclose(headerfp);
if (istmpdir) eremove(headerfile);
if (!have_ntr) {
efclose(tracefp);
if (istmpdir) eremove(tracefile);
}
return EXIT_SUCCESS;
}
main(int argc, char **argv)
{
int nt; /* number of points on trace */
int databytes; /* ... in bytes */
int ntr; /* number of traces */
string stype; /* noise type (gauss, flat) as string */
int itype; /* ... as integer (for use in switch) */
float sn; /* signal to noise ratio */
unsigned int seed; /* random number seed */
FILE *hdrfp; /* fp for header storage file */
FILE *sigfp; /* fp for data ("signal") */
int nfloats; /* number of floats in "signal" */
float *noise; /* noise vector */
float noiscale; /* scale for noise */
float absmaxsig; /* absolute maximum in signal */
float noipow; /* a measure of noise power */
float f1; /* left lower corner frequency */
float f2; /* left upper corner frequency */
float f4; /* right lower corner frequency */
float f3; /* right upper corner frequency */
char * scrdir; /* scratch dir to put temporary data set */
/* Initialize */
initargs(argc, argv);
askdoc(1);
/* Get noise type */
if (!getparstring("noise", &stype)) stype = "gauss";
if (STREQ(stype, "gauss")) itype = GAUSS;
else if (STREQ(stype, "flat")) itype = FLAT;
else err("noise=\"%s\", must be gauss or flat", stype);
/* Get signal to noise ratio */
if (!getparfloat("sn", &sn)) sn = SN;
if (sn <= 0) err("sn=%d must be positive", sn);
/* Set seed */
if (!getparuint("seed", &seed)) { /* if not supplied, use clock */
if (-1 == (seed = (uint) time((time_t *) NULL))) {
err("time() failed to set seed");
}
}
(itype == GAUSS) ? srannor(seed) : sranuni(seed);
if( !getparstring("scrdir",&scrdir) ) {
scrdir = getenv("SU_SCRATCHDIR") ;
}
/* Prepare temporary files to hold headers and data */
/*
hdrfp = etmpfile();
sigfp = etmpfile();
*/
hdrfp = etempfile(NULL);
sigfp = etempfile(NULL);
/* Get info from first trace */
if (!gettr(&tr)) err("can't get first trace");
nt = tr.ns;
databytes = nt * FSIZE;
/* Loop over input traces & write headers and data to tmp files */
ntr = 0;
do {
++ntr;
efwrite(&tr, 1, HDRBYTES, hdrfp);
efwrite(tr.data, 1, databytes, sigfp);
} while (gettr(&tr));
nfloats = ntr * nt;
/* Compute absmax of signal over entire data set */
rewind(sigfp);
absmaxsig = 0.0;
{ register int i;
for (i = 0; i < nfloats; ++i) {
float sigval;
efread(&sigval, FSIZE, 1, sigfp);
absmaxsig = MAX(absmaxsig, ABS(sigval));
}
}
/* Compute noise vector elements in [-1, 1] */
noise = ealloc1float(nfloats);
switch (itype) {
register int i;
case GAUSS: /* frannor gives elements in N(0,1)--ie. pos & negs */
for (i = 0; i < nfloats; ++i) noise[i] = frannor();
break;
case FLAT: /* franuni gives elements in [0, 1] */
for (i = 0; i < nfloats; ++i) noise[i] = 2.0*franuni() - 1.0;
break;
default: /* defensive programming */
err("%d: mysterious itype = %d", __LINE__, itype);
}
/* Band limit noise traces if user getpars any of the f's */
if (getparfloat("f1", &f1) || getparfloat("f2", &f2) ||
getparfloat("f3", &f3) || getparfloat("f4", &f4) ) {
/* Set up call to suband */
char cmdbuf[BUFSIZ]; /* build suband command */
FILE *bandinfp; /* fp for input file */
FILE *fp; /* fp for pipe to suband */
int nsegy = HDRBYTES + databytes;
char *segybuf = ealloc1(nsegy, 1);
/* Trap signals so can remove tmpnam file */
signal(SIGINT, (void *) trapsig);
signal(SIGQUIT, (void *) trapsig);
signal(SIGHUP, (void *) trapsig);
signal(SIGTERM, (void *) trapsig);
/* Prepare temporary files to hold traces */
/*bandinfp = etmpfile();*/
bandinfp = etempfile(NULL);
/*bandoutfp = efopen(etmpnam(bandoutfile), "w+");*/
bandoutfile = etempnam(scrdir,NULL) ;
bandoutfp = efopen(bandoutfile, "w+");
/* Paste headers on noise traces and put in tmpfile */
rewind(hdrfp);
{ register int itr;
for (itr = 0; itr < ntr; ++itr) {
efread(&tr, 1, HDRBYTES, hdrfp);
memcpy(tr.data, noise + itr*nt, databytes);
fputtr(bandinfp, &tr);
}
}
/* Pipe to suband - suband handles the getpars */
sprintf(cmdbuf, "suband >%s", bandoutfile);
fp = epopen(cmdbuf, "w");
rewind (bandinfp);
{ register int itr;
for (itr = 0; itr < ntr; ++itr) {
efread(segybuf, 1, nsegy, bandinfp);
efwrite(segybuf, 1, nsegy, fp);
}
}
efclose(bandinfp);
epclose(fp);
/* Load bandlimited traces back into noise vector */
rewind(bandoutfp);
{ register int itr;
for (itr = 0; itr < ntr; ++itr) {
fgettr(bandoutfp, &tr);
memcpy(noise + itr*nt, tr.data, databytes);
}
}
efclose(bandoutfp);
eremove(bandoutfile);
} /* End optional bandlimiting */
/* Compute noise power */
noipow = 0.0;
{ register int i;
for (i = 0; i < nfloats; ++i) {
register float noiseval = noise[i];
noipow += noiseval * noiseval;
}
}
/* Compute noise scale for desired noise/signal ratio */
absmaxsig /= sqrt(2.0); /* make it look like a rmsq value */
noipow /= nfloats; /* make it the square of rmsq value */
noiscale = absmaxsig / (sn * sqrt(noipow));
/* Add scaled noise to trace and output sum */
rewind(hdrfp);
rewind(sigfp);
{ register int itr;
for (itr = 0; itr < ntr; ++itr) {
register int trshift = itr*nt;
register int i;
efread(&tr, 1, HDRBYTES, hdrfp);
efread(tr.data, 1, databytes, sigfp);
for (i = 0; i < nt; ++i)
tr.data[i] += noiscale * noise[trshift + i];
puttr(&tr);
}
}
return EXIT_SUCCESS;
}
main(int argc, char **argv)
{
char plotcmd[BUFSIZ]; /* build ximage command for popen */
float *trbuf; /* trace buffer */
FILE *datafp; /* fp for trace data file */
FILE *plotfp; /* fp for plot data */
int nt; /* number of samples on trace */
int ntr; /* number of traces */
float d1; /* time/depth sample rate */
float d2; /* trace/dx sample rate */
float f1; /* tmin/zmin */
float f2; /* tracemin/xmin */
bool seismic; /* is this seismic data? */
int min, max, mtr;
/* Initialize */
initargs(argc, argv);
askdoc(1);
/* Get info from first trace */
if (!gettr(&tr)) err("can't get first trace");
seismic = (tr.trid == 0 || tr.trid == TREAL);
nt = tr.ns;
if (!getparfloat("d1", &d1)) {
if (seismic) {
if (tr.dt) {
d1 = (float) tr.dt / 1000000.0;
} else {
d1 = 0.004;
warn("tr.dt not set, assuming dt=0.004");
}
} else { /* non-seismic data */
if (tr.d1) {
d1 = tr.d1;
} else {
d1 = 1.0;
warn("tr.d1 not set, assuming d1=1.0");
}
}
}
if (!getparfloat("d2", &d2)) d2 = (tr.d2) ? tr.d2 : 1.0;
if (!getparfloat("f1", &f1)) {
if (seismic) {
f1 = (tr.delrt) ? (float) tr.delrt/1000.0 : 0.0;
} else {
f1 = (tr.f1) ? tr.f1 : 0.0;
}
}
if (!getparfloat("f2", &f2)) {
if (tr.f2) f2 = tr.f2;
else if (tr.tracr) f2 = (float) tr.tracr;
else if (tr.tracl) f2 = (float) tr.tracl;
else if (seismic) f2 = 1.0;
else f2 = 0.0;
}
if (!getparint("min", &min)) min = 1;
if (!getparint("max", &max)) max = 2000;
/* Allocate trace buffer */
trbuf = ealloc1float(nt);
/* Create temporary "file" to hold data */
/*datafp = etmpfile();*/
datafp = etempfile(NULL);
/* Loop over input traces & put them into the data file */
ntr = 0;
mtr = 0;
do {
++mtr;
if(mtr>=min && mtr<=max) {
++ntr;
efwrite(tr.data, FSIZE, nt, datafp);
}
} while (gettr(&tr) && mtr <=max );
/* Set up ximage command line */
sprintf(plotcmd, "ximage n1=%d n2=%d d1=%f d2=%f f1=%f f2=%f",
nt, ntr, d1, d2, f1, f2);
for (--argc, ++argv; argc; --argc, ++argv) {
if (strncmp(*argv, "d1=", 3) && /* skip those already set */
strncmp(*argv, "d2=", 3) &&
strncmp(*argv, "f1=", 3) &&
strncmp(*argv, "f2=", 3)) {
strcat(plotcmd, " "); /* put a space between args */
strcat(plotcmd, "\""); /* user quotes are stripped */
strcat(plotcmd, *argv); /* add the arg */
strcat(plotcmd, "\""); /* user quotes are stripped */
}
}
/* Open pipe; read data to buf; write buf to plot program */
plotfp = epopen(plotcmd, "w");
rewind(datafp);
{ register int itr;
for (itr = 0; itr < ntr; ++itr) {
efread (trbuf, FSIZE, nt, datafp);
efwrite(trbuf, FSIZE, nt, plotfp);
}
}
/* Clean up */
epclose(plotfp);
efclose(datafp);
return EXIT_SUCCESS;
}
main(int argc, char **argv)
{
char plotcmd[BUFSIZ]; /* build command for popen */
float *trbuf; /* trace buffer */
FILE *datafp; /* fp for trace data file */
FILE *plotfp; /* fp for plot data */
float d1; /* time/depth sample rate */
float d2; /* trace/dx sample rate */
float f1; /* tmin/zmin */
float f2; /* tracemin/xmin */
int nt; /* number of samples on trace */
int ntr; /* number of traces */
/* Initialize */
initargs(argc, argv);
askdoc(1);
/* Get info from first trace */
if (!gettr(&tr)) err("can't get first trace");
nt = tr.ns;
if (!getparfloat("d1", &d1)) {
if (tr.dt) { /* is dt field set? */
d1 = tr.dt / 1000000.0;
} else { /* dt not set, assume 4 ms */
d1 = 0.004;
warn("tr.dt not set, assuming dt=%g", d1);
}
}
if (!getparfloat("d2", &d2)) d2 = 1.0; /* default count by traces */
if (!getparfloat("f1", &f1)) f1 = tr.delrt/1000.0;
/* Allocate trace buffer */
trbuf = ealloc1float(nt);
/* Create temporary "file" to hold data */
datafp = etmpfile();
/*datafp = etempfile(NULL); */
/* Loop over input traces & put them into the xdata file */
ntr = 0;
do {
++ntr;
efwrite(tr.data, FSIZE, nt, datafp);
} while (gettr(&tr));
/* System call to xgraph */
sprintf(plotcmd, "xgraph n=%d nplot=%d d1=%f f1=%f style=%s",
nt, ntr, d1, f1, "seismic");
for (--argc, ++argv; argc; --argc, ++argv) {
if (strncmp(*argv, "n=", 2) && /* skip those already set */
strncmp(*argv, "nplot=", 6) &&
strncmp(*argv, "d1=", 3) &&
strncmp(*argv, "f1=", 3) &&
strncmp(*argv, "style=", 6)) {
strcat(plotcmd, " "); /* put a space between args */
strcat(plotcmd, "\""); /* user quotes are stripped */
strcat(plotcmd, *argv); /* add the arg */
strcat(plotcmd, "\""); /* user quotes are stripped */
}
}
/* Open pipe; read data to buf; write buf to plot program */
plotfp = epopen(plotcmd, "w");
{ register int itr;
rewind(datafp);
for (itr = 0; itr < ntr; ++itr) {
efread (trbuf, FSIZE, nt, datafp);
efwrite(trbuf, FSIZE, nt, plotfp);
}
}
/* Clean up */
epclose(plotfp);
efclose(datafp);
return EXIT_SUCCESS;
}
