header.c

speech signal process tools

int
read_esps_hdr(sig, hdr)
   Signal         *sig;
   struct header  *hdr;
{
   switch (hdr->common.type) {
   case FT_SD:
      {

	 sig->idents = (List *) malloc(sizeof(List));
	 sig->idents->str = savestring("samples");
	 sig->idents->next = NULL;
      }
      sig->header->e_scrsd = 1;

      if (get_sd_type(hdr) == SHORT) {
	 sig->header->e_short = 1;
	 if (debug_level >= 1)
	    printf("read_esps_hdr: FT_SD is SHORT, setting e_short\n");
      }
      sig->version = 1;

      sig->dim = 1;
      sig->file_size = hdr->common.ndrec;
      if (debug_level >= 1)
	 printf("read_esps_hdr: sig->file_size = %d.\n", sig->file_size);

      sig->band = 0.5 * hdr->hd.sd->sf;
      sig->freq = hdr->hd.sd->sf;
      if (debug_level >= 1)
	 printf("read_esps_hdr: sig->freq = %g.\n", sig->freq);
      sig->type = P_SHORTS;

      sig->start_time = get_genhd_val("start_time", hdr, 0.0);
      if (genhd_type("start_time", (int *) NULL, hdr) == HD_UNDEF)
	 *add_genhd_d("start_time", (double *) NULL, 1, hdr) =
	    sig->start_time;

      sig->end_time =
	 get_genhd_val("end_time", hdr,
		       sig->file_size / sig->freq + sig->start_time);
      if (genhd_type("end_time", (int *) NULL, hdr) == HD_UNDEF)
	 *add_genhd_d("end_time", (double *) NULL, 1, hdr) =
	    sig->end_time;

      break;

   case FT_FEA:
      switch (hdr->hd.fea->fea_type) {
      case FEA_SPEC:
	 {
	    double          sf;
	    short           freq_format;
	    float          *hd_freqs;
	    double         *sig_freqs;
	    int             i;

	    if (genhd_type("freq_format", (int *) NULL, hdr) != CODED) {
	       BAD_HDR_ITEM("freq_format", "CODED");
	       return FALSE;
	    } else
	       switch (freq_format = *get_genhd_s("freq_format", hdr)) {
	       case SPFMT_SYM_CTR:
		  printf("%s: freq_format SYM_CTR not supported.\n",
			 "read_esps_hdr");
		  return FALSE;
		  break;
	       case SPFMT_ASYM_CTR:
		  printf("%s: freq_format ASYM_CTR not supported.\n",
			 "read_esps_hdr");
		  return FALSE;
		  break;
	       case SPFMT_ARB_VAR:
		  printf("%s: freq_format ARB_VAR not supported.\n",
			 "read_esps_hdr");
		  return FALSE;
		  break;
	       default:
		  break;
	       }

	    if (genhd_type("spec_type", (int *) NULL, hdr) != CODED) {
	       BAD_HDR_ITEM("spec_type", "CODED");
	       return FALSE;
	    } else
	       switch (*get_genhd_s("spec_type", hdr)) {
	       case SPTYP_DB:
		  break;
	       default:
		  printf(
		     "%s: only spec_type SPTYP_DB supported in FEA_SPEC.\n",
			 "read_esps_hdr");
		  return FALSE;
		  break;
	       }

/*!*//* idents? */

	    sig->version = 1;

	    if (genhd_type("num_freqs", (int *) NULL, hdr) == LONG)
	       sig->dim = *get_genhd_l("num_freqs", hdr);
	    else {
	       BAD_HDR_ITEM("num_freqs", "LONG");
	       return FALSE;
	    }

	    if (hdr->common.ndrec == -1)
	    {
	       /* Pipe or variable record size (e.g. Esignal Ascii).
		* Can't get the file size without reading the whole
		* file and counting, so use an overestimate
		* and assume that "check_file_size" will supply the
		* right value when we actually reach the end of file.
		*/
	       sig->file_size = est_file_size(sig);
	    }
	    else
	       sig->file_size = hdr->common.ndrec;

	    if (debug_level >= 1)
		printf("read_esps_hdr: sig->file_size = %d.\n",
		       sig->file_size);

	    switch (freq_format) {
	    case SPFMT_SYM_EDGE:
	    case SPFMT_ASYM_EDGE:
	    case SPFMT_SYM_CTR:
	    case SPFMT_ASYM_CTR:
	       if (genhd_type("sf", (int *) NULL, hdr) == FLOAT)
		  sf = *get_genhd_f("sf", hdr);
	       else {
		  BAD_HDR_ITEM("sf", "FLOAT");
		  return FALSE;
	       }
	       break;
	    default:
/*!*//* assign dummy value to sf? */
	       break;
	    }

	    switch (freq_format) {
	    case SPFMT_ASYM_EDGE:
	       sig->band = sf;
	       sig->band_low = -0.5 * sf;
	       sig->y_dat = NULL;
	       break;
	    case SPFMT_SYM_EDGE:
	       sig->band = 0.5 * sf;
	       sig->band_low = 0.0;
	       sig->y_dat = NULL;
	       break;
	    case SPFMT_ARB_FIXED:
	       if (genhd_type("freqs", (int *) NULL, hdr) == FLOAT)
		  hd_freqs = get_genhd_f("freqs", hdr);
	       else {
		  BAD_HDR_ITEM("freqs", "FLOAT");
		  return FALSE;
	       }

	       sig_freqs = (double *) malloc(sig->dim * sizeof(double));
	       if (!sig_freqs) {
		  printf("%s: can't allocate space for freqs array.\n",
			 "read_esps_hdr");
		  return FALSE;
	       }
	       sig->y_dat = sig_freqs;
	       for (i = 0; i < sig->dim; i++)
		  sig_freqs[i] = hd_freqs[i];

	       /*
	        * FEA_SPEC support functions assumed to enforce monotone
	        * increasing frequencies.  If not, add code to the loop to
	        * find the max and min freqs.
	        */

	       sig->band_low = hd_freqs[0];
	       sig->band = hd_freqs[sig->dim - 1] - sig->band_low;
	       break;
	    default:
	       break;
	    }

	    sig->freq = get_genhd_val("record_freq", hdr, 1.0);
	    if (sig->freq == 0.0)
	       sig->freq = 1.0;

	    sig->type = SIG_SPECTROGRAM | P_CHARS;

	    sig->start_time = get_genhd_val("start_time", hdr, 0.0);

	    sig->end_time
	       = sig->start_time + sig->file_size / sig->freq;
	 }
	 break;
      case FEA_SD:
	 /*
	  * if single-channel, non-complex, and if the the data is SHORT or
	  * the fea_sd_special global is set, treat here; otherwise, drop
	  * through to general FEA file
	  */

	 if ((is_field_complex(hdr, "samples") == NO
	      && hdr->hd.fea->field_count == 1
	      && (fea_sd_special || (get_fea_type("samples", hdr) == SHORT)))
	     || get_genhd_val("encoding", hdr, (double) 0.0)) {

	    List            feasd_ident;
	    List           *end_ptr = &feasd_ident;
	    char            buf[250];

	    if ((get_fea_siz("samples", hdr, (short *) NULL, (long **) NULL)
		 == 1)) {
	       sig->header->e_scrsd = 1;

	       if (debug_level >= 1)
		  fprintf(stderr,
			  "read_esps_hdr: 1-chan., non-complex, FEA_SD; setting e_scrsd flag\n");
	    }
	    if (get_fea_type("samples", hdr) == SHORT) {
	       sig->header->e_short = 1;
	       if (debug_level >= 1)
		  fprintf(stderr,
		  "read_esps_hdr: \"samples\" is SHORT, setting e_short\n");
	    }
	    if (sig->header->e_scrsd != 1) {
               int i;
	       for (i = 0; i < get_fea_siz("samples", hdr, (short *) NULL,
					   (long **) NULL); i++) {
		  sprintf(buf, "samples[%d]", i);
		  end_ptr->next = (List *) malloc(sizeof(List));
		  end_ptr = end_ptr->next;
		  if (!end_ptr) {
		     fprintf(stderr, "%s: can't allocate ident node.\n",
			     "read_esps_hdr");
		     return FALSE;
		  }
		  end_ptr->str = savestring(buf);
	       }
	       end_ptr->next = NULL;
	       sig->idents = feasd_ident.next;
	    } else {
	       sig->idents = (List *) malloc(sizeof(List));
	       sig->idents->str = savestring("samples");
	       sig->idents->next = NULL;
	    }

	    sig->version = 1;

	    sig->dim =
	       get_fea_siz("samples", hdr, (short *) NULL, (long **) NULL);

	    if (hdr->common.ndrec == -1)
	    {
	       /* Pipe or variable record size (e.g. Esignal Ascii).
		* Can't get the file size without reading the whole
		* file and counting, so use an overestimate
		* and assume that "check_file_size" will supply the
		* right value when we actually reach the end of file.
		*/
	       sig->file_size = est_file_size(sig);
	    }
	    else
	       sig->file_size = hdr->common.ndrec;

	    if (debug_level >= 1)
	       printf("read_esps_hdr: sig->file_size = %d.\n", sig->file_size);

	    sig->band = 0.5 * get_genhd_val("record_freq", hdr, 1.0);

	    sig->freq = get_genhd_val("record_freq", hdr, 1.0);
	    if (debug_level >= 1)
	       printf("read_esps_hdr: sig->freq = %g.\n", sig->freq);
	    sig->type = P_SHORTS;

	    sig->start_time = get_genhd_val("start_time", hdr, 0.0);
	    if (genhd_type("start_time", (int *) NULL, hdr) == HD_UNDEF)
	       *add_genhd_d("start_time", (double *) NULL, 1, hdr) =
		  sig->start_time;

	    sig->end_time =
	       get_genhd_val("end_time", hdr,
			     sig->file_size / sig->freq + sig->start_time);
	    if (genhd_type("end_time", (int *) NULL, hdr) == HD_UNDEF)
	       *add_genhd_d("end_time", (double *) NULL, 1, hdr) =
		  sig->end_time;
	    break;
	 }			/* if not e_src FEA_SD, fall through to
				 * general FEA */
      default:			/* General FEA file. */
	 sig->version = 1;
	 sig->dim = get_rec_len(hdr);

	 if (hdr->common.ndrec == -1)
	 {
	    /* Pipe or variable record size (e.g. Esignal Ascii).
	     * Can't get the file size without reading the whole
	     * file and counting, so use an overestimate
	     * and assume that "check_file_size" will supply the
	     * right value when we actually reach the end of file.
	     */
	    sig->file_size = est_file_size(sig);
	 }
	 else
	    sig->file_size = hdr->common.ndrec;

	 if (debug_level >= 1)
	     printf("read_esps_hdr: sig->file_size = %d.\n", sig->file_size);

	 sig->band = 0.5 * get_genhd_val("record_freq", hdr, 1.0);
	 sig->freq = get_genhd_val("record_freq", hdr, 1.0);
	 if (sig->freq == 0.0)
	    sig->freq = 1.0;

	 sig->start_time = get_genhd_val("start_time", hdr, 0.0);

	 if (!hdr->common.tag)
	    sig->end_time = sig->file_size / sig->freq + sig->start_time;
	 else
	    sig->end_time = get_genhd_val("end_time", hdr,
					  sig->start_time - 1.0);	/* to flag not known! */

	 sig->type = P_MIXED;
	 sig->types = (int *) malloc(sig->dim * sizeof(int));
	 if (!sig->types) {
	    printf("%s: can't allocate space for type array.\n",
		   "read_esps_hdr");
	    return FALSE;
	 }

	 {
	    int             i, k;
	    int             j;
	    List            fea_idents;	/* dummy node precedes first actual
					 * node while list is being built */
	    List           *end_ptr = &fea_idents;
	    int             n = 0;

	    for (i = 0; i < hdr->hd.fea->field_count; i++) {
	       int             type, real;
	       int             rank;
	       long            size, *dim;
	       static unsigned maxrank;
	       static int     *coords = NULL;
	       char            buf[250], *suffix;

	       switch (hdr->hd.fea->types[i]) {
	       case BYTE:
	       case CHAR:
		  type = P_CHARS;
		  real = YES;
		  break;
	       case SHORT:
	       case CODED:
		  type = P_SHORTS;
		  real = YES;
		  break;
	       case LONG:
		  type = P_INTS;
		  real = YES;
		  break;
	       case FLOAT:
		  type = P_FLOATS;
		  real = YES;
		  break;
	       case DOUBLE:
		  type = P_DOUBLES;
		  real = YES;
		  break;
	       case BYTE_CPLX:
		  type = P_CHARS;
		  real = NO;
		  break;
	       case SHORT_CPLX:
		  type = P_SHORTS;
		  real = NO;
		  break;
	       case LONG_CPLX:
		  type = P_INTS;
		  real = NO;
		  break;
	       case FLOAT_CPLX:
		  type = P_FLOATS;
		  real = NO;
		  break;
	       case DOUBLE_CPLX:
		  type = P_DOUBLES;
		  real = NO;
		  break;
	       default:
		  printf("%s: unrecognized ESPS data type.\n",
			 "read_esps_hdr");
		  return FALSE;
	       }

	       size = hdr->hd.fea->sizes[i];
	       rank = (hdr->hd.fea->ranks)
		  ? hdr->hd.fea->ranks[i] : 1;
	       dim = (hdr->hd.fea->dimens && rank != 1)
		  ? hdr->hd.fea->dimens[i] : &size;

	       if (debug_level) {
		  fprintf(stderr,
			  "%s: size %d,  rank %d,\n\tdim  ",
			  "read_esps_hdr", size, rank);
		  for (k = 0; k < rank; k++)
		     fprintf(stderr, "%d ", dim[k]);
		  fprintf(stderr, "\n");
	       }
	       if (!coords) {
		  if ((maxrank = rank) > 0) {
		     coords = (int *)
			malloc(maxrank * sizeof(int));
		     if (!coords) {
			printf("%s: can't allocate coordinate array.\n",
			       "read_esps_hdr");
			return FALSE;
		     }
		  }
	       } else if (maxrank < rank) {
		  if ((maxrank = rank) > 0) {
		     coords = (int *)
			realloc((char *) coords,
				maxrank * sizeof(int));
		     if (!coords) {
			printf("%s: can't realloc coordinate array.\n",
			       "read_esps_hdr");
			return FALSE;
		     }
		  }
	       }
	       for (k = 0; k < rank; k++)
		  coords[k] = 0;

	       strcpy(buf, hdr->hd.fea->names[i]);
	       suffix = buf + strlen(buf);

	       for (j = 0; j < size; j++) {
		  int             h;
		  char           *end = suffix;

		  for (k = 0; k < rank; k++) {
		     sprintf(end, "[%d]", coords[k]);
		     end = end + strlen(end);
		  }

		  for (h = 0; h < (real ? 1 : 2); h++) {
		     static char    *re_im[2] = {".r", ".i"};

		     sig->types[n++] = type;

		     end_ptr->next = (List *) malloc(sizeof(List));
		     end_ptr = end_ptr->next;
		     if (!end_ptr) {
			printf("%s: can't allocate ident node.\n",
			       "read_esps_hdr");
			return FALSE;
		     }
		     if (!real)
			strcpy(end, re_im[h]);
		     end_ptr->str = savestring(buf);
		  }

		  /* Advance coordinates; check overflow */

		  for (k = rank - 1;
		       k >= 0 && coords[k] == dim[k] - 1;
		       k--)
		     coords[k] = 0;	/* propagate carries */
		  if (k >= 0)
		     coords[k]++;
		  else if (j < size - 1) {
		     printf("%s: field %s has inconsistent size and dimensions.\n",
			    "read_esps_hdr", hdr->hd.fea->names[i]);
		     return FALSE;
		  }
	       }
	       if (k >= 0) {
		  printf("%s: field %s has inconsistent size and dimensions.\n",
			 "read_esps_hdr", hdr->hd.fea->names[i]);
		  return FALSE;
	       }
	    }

	    end_ptr->next = NULL;
	    sig->idents = fea_idents.next;
	 }

	 break;
      }
      break;
   case FT_SPEC:
   default:
      printf("The only ESPS files supported so far are %s, %s, and %s.\n",
	     "sampled-data", "FEA_SPEC", "general FEA files");
      return FALSE;
      break;
   }

   return TRUE;

}

#undef BAD_HDR_ITEM

static int
est_file_size(sig)
    Signal  *sig;
{
    int     file;
    long    loc, len;

    file = sig->file;

    if (file < 0 && sig->name != NULL)
	file = open(sig->name, O_RDONLY);

    if (file < 0)		/* file nonexistent */
	return 0;

    loc = lseek(file, 0L, SEEK_CUR);

    if (loc < 0)		/* pipe */
	return INT_MAX;

    len = lseek(file, 0L, SEEK_END) - sig->bytes_skip;
    lseek(file, loc, SEEK_SET);	/* restore original position
				 * in case it was already open */

    if (sig->dim > 1)
	len /= sig->dim;	/* number of records, assuming
				 * at leas one byte per element */

    return (len < INT_MAX) ? len : INT_MAX;
}


/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/*
 * Generate a Header structure containing all relevant information in the
 * Signal structure including any previous header.  Total header length will
 * always be modulo 4 bytes.
 */

Header         *
w_write_header(sig)
   Signal         *sig;