write_data.c

speech signal process tools

      return FALSE;
      break;
   }

   return TRUE;
}

/****************************************************************/

put_esps_fspec(s, start, page_size)
   Signal         *s;
   double          start, page_size;
{
   int             i, j, dim;
   int             sam_to_skip, nsamp;
   int             loc, istagged = IS_TAGGED_FEA(s);
   struct feaspec *buf;
   char          **spp = (char **) s->data;
   FILE           *strm = s->header->strm;
   struct header  *hdr = s->header->esps_hdr;
   double          ssf, get_genhd_val();

   sam_to_skip = ((start - s->start_time) * s->freq) + 0.5;
   if ((ssf = get_genhd_val("src_sf", hdr,
			    get_genhd_val("sf", hdr, -1.0))) <= 0.0) {
      fprintf(stderr,
	      "Warning: src_sf not present in tagged file; guessing 8kHz\n");
      ssf = 8000.0;
   }
   dim = s->dim;
   loc = sam_to_skip - s->start_samp;
   nsamp = (int) (0.5 + page_size * s->freq);

   if (fseek(strm, (long) s->bytes_skip, 0)) {
      printf("write_data: Can't skip header of ESPS file.\n");
      return FALSE;
   }
   fea_skiprec(strm, (long) sam_to_skip, hdr);

   buf = allo_feaspec_rec(hdr, BYTE);

   for (i = 0; i < nsamp; i++, loc++) {
      for (j = 0; j < dim; j++)
	 buf->re_spec_val_b[j] = spp[j][loc];
      if (istagged && s->x_dat)
	 *buf->tag = (int) (1.5 + ((s->x_dat[loc] - s->start_time) * ssf));
      put_feaspec_rec(buf, hdr, strm);
   }

   return TRUE;
}

/****************************************************************/

put_binary(s, start, page_size, sizof)
   Signal         *s;
   double          start, page_size;
   int             sizof;
{
   register int    i, j, dim, nlim, bsize = 500;
   int             sam_to_skip, nbytes, bytes_per_sam, seek, nelem, loc,
                   buf_bytes, nwrit, samples;

   sam_to_skip = ((start - s->start_time) * s->freq) + 0.5;
   dim = s->dim;
   bytes_per_sam = dim * sizof;
   seek = s->bytes_skip + (sam_to_skip * sizof * dim);
   if (lseek(s->file, seek, L_SET) == seek) {
      nelem = dim * (samples = (int) (0.5 + (page_size * s->freq)));
      nbytes = sizof * nelem;
      buf_bytes = bytes_per_sam * bsize;

      switch (sizof) {
      case sizeof(char):
	 {
	    char          **spp, *buf, *p, *q;

	    spp = (char **) s->data;
	    loc = sam_to_skip - s->start_samp;
	    if (dim > 1) {
	       if ((buf = (char *) malloc(buf_bytes))) {
		  do {
		     if ((loc + bsize) <= s->buff_size)
			nlim = bsize;
		     else
			nlim = s->buff_size - loc;
		     buf_bytes = nlim * bytes_per_sam;
		     for (i = 0; i < dim; i++)
			for (j = 0, p = spp[i] + loc, q = buf + i; j++ < nlim;
			     q += dim)
			   *q = *p++;
		     loc += nlim;
		     if ((nwrit = write(s->file, buf, buf_bytes)) != buf_bytes) {
			printf("error while writing data in write_data()\n");
			return (FALSE);
		     }
		  } while (loc < s->buff_size);
		  free(buf);
		  return (TRUE);
	       } else
		  printf("Can't allocate scratch buffer in write_data()\n");
	    } else {		/* one dimensional chars */
	       if ((nwrit = write(s->file, spp[0] + loc, nbytes)) == nbytes)
		  return (TRUE);
	       else
		  printf("Error during write (%d) in write_data()\n", nwrit);
	    }
	 }
	 break;
      case sizeof(short):
	 {
	    short         **spp, *buf, *p, *q;

	    spp = (short **) s->data;
	    loc = sam_to_skip - s->start_samp;
	    if (dim > 1) {
	       if ((buf = (short *) malloc(buf_bytes))) {
		  do {
		     if ((loc + bsize) <= s->buff_size)
			nlim = bsize;
		     else
			nlim = s->buff_size - loc;
		     buf_bytes = nlim * bytes_per_sam;
		     for (i = 0; i < dim; i++)
			for (j = 0, p = spp[i] + loc, q = buf + i; j++ < nlim;
			     q += dim)
			   *q = *p++;
		     loc += nlim;
		     if ((nwrit = write(s->file, buf, buf_bytes)) != buf_bytes) {
			printf("error while writing data in write_data()\n");
			return (FALSE);
		     }
		  } while (loc < s->buff_size);
		  free(buf);
		  return (TRUE);
	       } else
		  printf("Can't allocate scratch buffer in write_data()\n");
	    } else {		/* one dimensional shorts */
	       if ((nwrit = write(s->file, spp[0] + loc, nbytes)) == nbytes)
		  return (TRUE);
	       else
		  printf("Error during write (%d) in write_data()\n", nwrit);
	    }
	 }
	 break;
      case sizeof(int):
	 {
	    register int  **spp, *buf, *p, *q;

	    spp = (int **) s->data;
	    loc = sam_to_skip - s->start_samp;
	    if (dim > 1) {
	       if ((buf = (int *) malloc(buf_bytes))) {
		  do {
		     if ((loc + bsize) <= s->buff_size)
			nlim = bsize;
		     else
			nlim = s->buff_size - loc;
		     buf_bytes = nlim * bytes_per_sam;
		     for (i = 0; i < dim; i++)
			for (j = 0, p = spp[i] + loc, q = buf + i; j++ < nlim;
			     q += dim)
			   *q = *p++;
		     loc += nlim;
		     if ((nwrit = write(s->file, buf, buf_bytes)) != buf_bytes) {
			printf("error while writing data in write_data()\n");
			return (FALSE);
		     }
		  } while (loc < s->buff_size);
		  free(buf);
		  return (TRUE);
	       } else
		  printf("Can't allocate scratch buffer in write_data()\n");
	    } else {		/* one dimensional ints */
	       if ((nwrit = write(s->file, spp[0] + loc, nbytes)) == nbytes)
		  return (TRUE);
	       else
		  printf("Error during write (%d) in write_data()\n", nwrit);
	    }
	 }
	 break;
#ifdef FLOATS_AND_INTS_DIFFER
      case sizeof(float):
	 {
	    float         **spp, *buf, *p, *q;

	    spp = (float **) s->data;
	    loc = sam_to_skip - s->start_samp;
	    if (dim > 1) {
	       if ((buf = (float *) malloc(buf_bytes))) {
		  do {
		     if ((loc + bsize) <= s->buff_size)
			nlim = bsize;
		     else
			nlim = s->buff_size - loc;
		     buf_bytes = nlim * bytes_per_sam;
		     for (i = 0; i < dim; i++)
			for (j = 0, p = spp[i] + loc, q = buf + i; j++ < nlim;
			     q += dim)
			   *q = *p++;
		     loc += nlim;
		     if ((nwrit = write(s->file, buf, buf_bytes)) != buf_bytes) {
			printf("error while writing data in write_data()\n");
			return (FALSE);
		     }
		  } while (loc < s->buff_size);
		  free(buf);
		  return (TRUE);
	       } else
		  printf("Can't allocate scratch buffer in write_data()\n");
	    } else {		/* one dimensional floats */
	       if ((nwrit = write(s->file, spp[0] + loc, nbytes)) == nbytes)
		  return (TRUE);
	       else
		  printf("Error during write (%d) in write_data()\n", nwrit);
	    }
	 }
	 break;
#endif
      case sizeof(double):
	 {
	    double        **spp, *buf, *p, *q;

	    spp = (double **) s->data;
	    loc = sam_to_skip - s->start_samp;
	    if (dim > 1) {
	       if ((buf = (double *) malloc(buf_bytes))) {
		  do {
		     if ((loc + bsize) <= s->buff_size)
			nlim = bsize;
		     else
			nlim = s->buff_size - loc;
		     buf_bytes = nlim * bytes_per_sam;
		     for (i = 0; i < dim; i++)
			for (j = 0, p = spp[i] + loc, q = buf + i; j++ < nlim;
			     q += dim)
			   *q = *p++;
		     loc += nlim;
		     if ((nwrit = write(s->file, buf, buf_bytes)) != buf_bytes) {
			printf("error while writing data in write_data()\n");
			return (FALSE);
		     }
		  } while (loc < s->buff_size);
		  free(buf);
		  return (TRUE);
	       } else
		  printf("Can't allocate scratch buffer in write_data()\n");
	    } else {		/* one dimensional doubles */
	       if ((nwrit = write(s->file, spp[0] + loc, nbytes)) == nbytes)
		  return (TRUE);
	       else
		  printf("Error during write (%d) in write_data()\n", nwrit);
	    }
	 }
	 break;
      default:
	 printf("Unknown data type (size) in put_binary(%d)\n", sizof);
	 break;
      }
   } else
      printf("Failure in seek before write in write_data()\n");
   return (FALSE);
}

/****************************************************************/

put_ascii(si, start, page_size)
   Signal         *si;
   double          start, page_size;
{
   Signal         *s, *convert();
   FILE           *fp, *fdopen();
   register int    i, j, dim, nlim;
   int             sam_to_skip, bytes_per_sam, seek, loc, samples, its_ok;
   double        **spp;

   its_ok = FALSE;
   if (si) {
      /*
       * bytes_per_sam can be set to the actual number of bytes required per
       * sample provided that a fixed format is agreed upon.  For now we'll
       * keep seven significant figures and output things in scientific
       * notation.
       */

      bytes_per_sam = (si->dim * 14) + 1;
      /* (assumes "%13.6e " for each element, and one "\n" per sample) */

      if ((s = convert(si, P_DOUBLES))) {
	 s->file = si->file;
	 s->bytes_skip = si->bytes_skip;
	 sam_to_skip = ((start - s->start_time) * s->freq) + 0.5;
	 dim = s->dim;
	 seek = s->bytes_skip + (sam_to_skip * bytes_per_sam);
	 if ((fp = fdopen(s->file, "r+"))) {
	    if (!fseek(fp, seek, 0)) {
	       samples = 0.5 + (page_size * s->freq);

	       spp = (double **) s->data;
	       loc = sam_to_skip - s->start_samp;
	       nlim = samples + loc;
	       its_ok = TRUE;
	       for (j = loc; j < nlim; j++) {
		  for (i = 0; i < dim; i++) {
		     if (fprintf(fp, "%13.6e ", spp[i][j]) == EOF)
			its_ok = FALSE;
		  }
		  if (fprintf(fp, "\n") == EOF)
		     its_ok = FALSE;
	       }
	       if (!its_ok)
		  printf("Problems during write in put_ascii()\n");
	       fclose(fp);
	       close_sig_file(s);
	    } else
	       printf("Can't seek before writing data in put_ascii()\n");
	 } else
	    printf("Can't open file %s for formatted output in put_ascii()\n", s->name);
      } else
	 printf("Can't convert signal to doubles for put_ascii\n");
      if (s && (s != si)) {
	 s->file = SIG_UNKNOWN;
	 free_signal(s);
      }
   } else
      printf("Null signal pointer passed to put_ascii()\n");
   return (its_ok);
}