read_data.c

speech signal process tools

		  if (nread >= 1)
		  {
		     for (i = 0; i < dim; i++)
			for (j = 0, p = spp[i] + loc, q = buf + i;
			     j++ < nread; q += dim)
			   *p++ = *q;
		     loc += nread;
		  }

	       } while (nread == bsize && loc < s->buff_size);

	       free((char *) feasd_rec);
	    }
	    free((char *) buf);
	 }
      }

      if (loc == 0)
	 fprintf(stderr, "get_esps_sd: Unable to read any data.\n");
      else
      {
	 if (loc < s->buff_size)
	 {
	    s->buff_size = loc;
	    check_file_size(s, TRUE);

	    for (i = 0; i < dim; i++)
	    {
	       char *sp = realloc((char *) spp[i], loc * sizeof(short));

	       if (sp)
		  spp[i] = (short *) sp;
	       else
		  break;
	    }
	 }
	 else
	    check_file_size(s, FALSE);

	 return TRUE;
      }
   }

   for (i = 0; i < dim; i++)
      if (spp[i])
	 free((char *) spp[i]);
   s->buff_size = 0;
   free(s->data);
   s->data = NULL;

   return FALSE;
}

/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* Read spectrogram data from ESPS FEA_SPEC file. */

get_esps_fspec(s, start, page_size)
   Signal         *s;
   double          start, page_size;
{
   int             i, dim, istagged = IS_TAGGED_FEA(s);
   int             sam_to_skip, old_size, loc;
   struct feaspec *buf;
   char          **spp = (char **) s->data;
   FILE           *strm = s->header->strm;
   struct header  *hdr = s->header->esps_hdr;
   int             max_buff_size = max_buff_bytes / (s->dim * sizeof(char));
   double          ssf, get_genhd_val();
   int             truncate = 0; /* flag for too-short files */

   sam_to_skip = ((start - s->start_time) * s->freq) + 0.5;
   ssf = 8000.0;
   if (istagged && (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;
   old_size = s->buff_size;
   s->buff_size = (int) (0.5 + (page_size * s->freq));
   if (s->buff_size > max_buff_size) {
      s->buff_size = max_buff_size;
      /*
       * fprintf(stderr,"%s: read request exceeds max_buff_size; limiting to
       * %f sec.\n", "get_esps_fspec", ((double)s->buff_size)/s->freq);
       */
   }
   if (s->data && (old_size == s->buff_size)
       && (sam_to_skip == s->start_samp))
      return TRUE;

   if (s->file_size <= sam_to_skip) {
      fprintf(stderr, "File %s too small to reach requested segment at time %g\n",
	      s->name, start);
      return (FALSE);
   }

   s->start_samp = sam_to_skip;
   check_file_size(s, FALSE);

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

   if (!spp) {
      spp = (char **) malloc(dim * sizeof(char *));
      if (!spp) {
	 fprintf(stderr, "get_esps_fspec: Can't allocate data pointer array.\n");
	 return FALSE;
      }
      for (i = 0; i < dim; i++)
	 spp[i] = NULL;
      old_size = 0;
   }
   s->data = (caddr_t) spp;
   if (old_size != s->buff_size) {
      if (istagged) {
	 if (s->x_dat)
	 {
	    free((char *) s->x_dat);
	    s->x_dat = NULL;
	 }
	 if (!(s->x_dat = (double *) malloc(sizeof(double) * s->buff_size))) {
	    fprintf(stderr, "Allocation failure for tag array in get_esps_fspec()\n");
	    return (FALSE);
	 }
      }
      for (i = 0; i < dim; i++) {	/* Allocate an array for each freq. */
	 if (spp[i])
	    free((char *) spp[i]);
	 if (!(spp[i] = (char *) malloc(s->buff_size * sizeof(char)))) {
	    fprintf(stderr, "get_esps_fspec: Can't allocate data array.\n");
	    while (--i >= 0)
	       free((char *) spp[i]);
	    free(s->data);
	    s->data = NULL;
	    s->buff_size = 0;
	    return FALSE;
	 }
      }
   }
   buf = allo_feaspec_rec(hdr, BYTE);
   loc = 0;
   while (loc < s->buff_size) {
      if (get_feaspec_rec(buf, hdr, strm) == EOF)
      {
	 s->buff_size = loc;
	 truncate = 1;
	 for (i = 0; i < dim; i++) /* Reallocate array for each freq. */
	 {
	    char *sp = realloc((char *) spp[i], loc * sizeof(char));

	    if (sp)
	       spp[i] = sp;
	    else
	       break;
	 }
	 if (istagged)
	 {
	    char *sp = realloc((char *) s->x_dat, loc * sizeof(double));

	    if (sp)
	       s->x_dat = (double *) sp;
	 }
      }
      else {
	 if (istagged)
	    s->x_dat[loc] = s->start_time + ((double) (*buf->tag - 1)) / ssf;

	 for (i = 0; i < dim; i++)
	    spp[i][loc] = buf->re_spec_val_b[i];

	 loc++;
      }
   }
   /* Should free buf here, but no ESPS free_feaspec_rec(). */

   check_file_size(s, truncate);

   return TRUE;
}

/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/*
 * Allocate an ESPS FEA record and an array of pointers for accessing each
 * element of each field.
 */
int
allo_esps_fea(hdr, dim, bufp, ptrp)
   struct header  *hdr;
   int             dim;
   struct fea_data **bufp;
   caddr_t       **ptrp;
{
   *bufp = allo_fea_rec(hdr);
   return (setup_fea_pointers(hdr, dim, *bufp, ptrp));
}

/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
setup_fea_pointers(hdr, dim, buf, ptrp)
   struct header  *hdr;
   int             dim;
   struct fea_data *buf;
   caddr_t       **ptrp;
{
   int             n, j;
   int             i;
   caddr_t        *ptr;

   ptr = (caddr_t *) malloc((unsigned) dim * sizeof(caddr_t));
   if (!ptr) {
      fprintf(stderr, "setup_fea_pointers: Can't allocate element pointer array.\n");
      return FALSE;
   }
   n = 0;
   for (i = 0; i < hdr->hd.fea->field_count; i++) {
      struct fea_header *fea = hdr->hd.fea;

#define	ALLO_R(type, member) { \
	    {	type    *fld = buf->member + fea->starts[i]; \
		for (j = 0; j < fea->sizes[i]; j++) \
		    ptr[n++] = (caddr_t) &fld[j]; } \
	    break; }
#define	ALLO_C(type, member) { \
	    {	type    *fld = buf->member + fea->starts[i]; \
		for (j = 0; j < fea->sizes[i]; j++) { \
		    ptr[n++] = (caddr_t) &fld[j].real; \
		    ptr[n++] = (caddr_t) &fld[j].imag; } } \
	    break; }

      switch (fea->types[i]) {
      case BYTE:
      case CHAR:
	 ALLO_R(char, b_data);
      case SHORT:
      case CODED:
	 ALLO_R(short, s_data);
      case LONG:
	 ALLO_R(long, l_data);
      case FLOAT:
	 ALLO_R(float, f_data);
      case DOUBLE:
	 ALLO_R(double, d_data);
      case BYTE_CPLX:
	 ALLO_C(byte_cplx, bc_data);
      case SHORT_CPLX:
	 ALLO_C(short_cplx, sc_data);
      case LONG_CPLX:
	 ALLO_C(long_cplx, lc_data);
      case FLOAT_CPLX:
	 ALLO_C(float_cplx, fc_data);
      case DOUBLE_CPLX:
	 ALLO_C(double_cplx, dc_data);
      default:
	 printf("%s: unrecognized ESPS data type.\n",
		"allo_esps_fea");
	 free((char *) ptr);
	 return FALSE;
      }
   }
   *ptrp = ptr;
   return TRUE;
}

/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* Storage required for each element of a given Signal type. */

static int
sig_type_size(type)
   int     type;
{
   int     typsize;

   switch (type)
   {
   case P_SHORTS:
   case P_USHORTS:
      typsize = sizeof(short);
      break;
   case P_INTS:
   case P_UINTS:
      typsize = sizeof(int);
      break;
   case P_FLOATS:
      typsize = sizeof(float);
      break;
   case P_DOUBLES:
      typsize = sizeof(double);
      break;
   case P_CHARS:
   case P_UCHARS:
      typsize = sizeof(char);
      break;
   default:
      typsize = 0;
      break;
   }

   return typsize;
}

/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* Read data from ESPS FEA file. */

get_esps_fea(s, start, page_size)
   Signal         *s;
   double          start, page_size;
{
   int             i, j, n, dim;
   int             sam_to_skip, old_size, loc;
   struct fea_data *buf;	/* FEA record */
   caddr_t        *ptr;		/* pointers to field elements in buf */
   caddr_t        *spp = (caddr_t *) s->data;
   FILE           *strm = s->header->strm;
   struct header  *hdr = s->header->esps_hdr;
   int             max_buff_size = max_buff_bytes / intern_size_rec(hdr);
   extern char    *fea_file_type[];
   int             truncate = 0; /* flag for too-short files */

   if (hdr->common.tag)
      return (get_esps_fea_tag(s, start, page_size));

   sam_to_skip = ((start - s->start_time) * s->freq) + 0.5;
   dim = s->dim;
   old_size = s->buff_size;
   s->buff_size = (int) (0.5 + (page_size * s->freq));
   if (s->buff_size > max_buff_size) {
      s->buff_size = max_buff_size;
      fprintf(stderr, "%s: read request exceeds max_buff_size; limiting to %f sec.\n",
	      "get_esps_fea", ((double) s->buff_size) / s->freq);
   }
   if (s->data && (old_size == s->buff_size)
       && (sam_to_skip == s->start_samp))
      return TRUE;

   if (s->file_size <= sam_to_skip) {
      fprintf(stderr, "File %s too small to reach requested segment at time %g\n",
	      s->name, start);
      return (FALSE);
   }

   s->start_samp = sam_to_skip;
   check_file_size(s, FALSE);

   if (fseek(strm, (long) s->bytes_skip, 0)) {
      fprintf(stderr, "get_esps_fea: Can't skip header of ESPS FEA file.\n");
      return FALSE;
   }

   fea_skiprec(strm, (long) sam_to_skip, hdr);

   if (!allo_esps_fea(hdr, dim, &buf, &ptr)) {
      fprintf(stderr, "%s: trouble allocating FEA record & pointer array.\n",
	      "get_esps_fea");
      return FALSE;
   }
   if (!spp) {
      spp = (caddr_t *) malloc(dim * sizeof(caddr_t));
      if (!spp) {
	 fprintf(stderr,
		 "get_esps_fea: Can't allocate data pointer array.\n");
	 free((char *) ptr);
	 return FALSE;
      }
      for (i = 0; i < dim; i++)
	 spp[i] = NULL;
      old_size = 0;
   }
   s->data = (caddr_t) spp;
   if (old_size != s->buff_size)
      for (i = 0; i < dim; i++) /* Allocate an array for each element. */
      {
	 int     typsize = sig_type_size(s->types[i]);

	 if (typsize == 0)
	 {
	    fprintf(stderr,
		    "get_esps_fea: Unknown data type %d.\n", s->types[i]);
	    return FALSE;
	    break;
	 }
	 if (spp[i])
	    free((char *) spp[i]);
	 if (!(spp[i] = (caddr_t) malloc((size_t)(s->buff_size * typsize))))
	 {
	    fprintf(stderr, "get_esps_fea: Can't allocate data array.\n");
	    while (--i >= 0)
	       free((char *) spp[i]);
	    free(s->data);
	    s->data = NULL;
	    s->buff_size = 0;
	    free((char *) ptr);
	    return FALSE;
	 }
      }

   loc = 0;
   while (loc < s->buff_size) {
      if (get_fea_rec(buf, hdr, strm) == EOF)
      {
	 s->buff_size = loc;
	 truncate = 1;
	 for (i = 0; i < dim; i++) /* Reallocate array for each element. */
	 {
	    int     typsize = sig_type_size(s->types[i]);
	    char    *sp = realloc((char *) spp[i], (size_t)(loc * typsize));

	    if (sp)
	       spp[i] = (caddr_t) sp;
	    else
	       break;
	 }
      }
      else {
	 for (i = 0; i < dim; i++)
	    switch (s->types[i]) {
	    case P_SHORTS:
	    case P_USHORTS:
	       ((short *) spp[i])[loc] = *(short *) ptr[i];
	       break;
	    case P_INTS:
	    case P_UINTS:
	       ((int *) spp[i])[loc] = *(int *) ptr[i];
	       break;
	    case P_FLOATS:
	       ((float *) spp[i])[loc] = *(float *) ptr[i];
	       break;
	    case P_DOUBLES:
	       ((double *) spp[i])[loc] = *(double *) ptr[i];
	       break;
	    case P_CHARS:
	    case P_UCHARS:
	       ((char *) spp[i])[loc] = *(char *) ptr[i];
	       break;
	    }

	 loc += 1;
      }
   }

   free((char *) ptr);
   free_fea_rec(buf);

   check_file_size(s, truncate);

   return TRUE;
}

/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
double
tag_index_to_time(s, ind)
   Signal         *s;
   int             ind;
{
   if (s && s->x_dat) {
      if (ind < 0)
	 ind = 0;
      if (ind >= s->buff_size)
	 ind = s->buff_size - 1;
      return (s->x_dat[ind]);
   }
   return (0.0);
}

/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
int
tag_time_to_index(s, time)
   Signal         *s;
   double          time;
{
   if (s && s->x_dat && (s->start_time < time)) {
      register int    i = s->buff_size - 1;
      while ((i > 0) && (time < s->x_dat[i]))
	 i--;
      if ((i < s->buff_size - 1) &&
	  ((time - s->x_dat[i]) > (s->x_dat[i + 1] - time)))
	 i++;
      return (i);
   }
   return (0);
}

/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
double
tag_buf_end(s)
   Signal         *s;
{
   if (s && s->x_dat)
      return (s->x_dat[s->buff_size - 1]);
}

/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
double
tag_buf_start(s)
   Signal         *s;
{
   if (s && s->x_dat)
      return (s->x_dat[0]);
}

/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */