headers.c

speech signal process tools

/*
 * This material contains unpublished, proprietary software of 
 * Entropic Research Laboratory, Inc. Any reproduction, distribution, 
 * or publication of this work must be authorized in writing by Entropic 
 * Research Laboratory, Inc., and must bear the notice: 
 *
 *    "Copyright (c) 1987-1990  Entropic Speech, Inc. 
 *    "Copyright (c) 1990-1996  Entropic Research Laboratory, Inc. 
 *                   All rights reserved"
 *
 * The copyright notice above does not evidence any actual or intended 
 * publication of this source code.     
 *
 * Written by:  Joseph T. Buck
 * Checked by:
 * Revised by:  Alan Parker
 *
 * Entry points:							     
 *    read_header(stream):  reads a header from stream and returns
 *        a pointer to it.					
 *    write_header(h, stream):  writes the header *h to stream.
 *    new_zfunc(ns,ds,num,den):  creates a new zfunc structure.
 *    new_header(type):  creates a new, zero header.		
 *    copy_header(h):  returns a pointer to a copy of h.
 *    add_source_file(oh, name, ih):  adds a source file and a source
 *        header to the output header.				
 *    add_comment(h, text):  appends a string to the comment field
 *
 */

static char *sccs_id = "@(#)headers.c	1.108	5/2/98	ESI/ERL";

#include <stdio.h>
#include <pwd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/file.h>
#ifdef DEC_ALPHA
#undef MIN
#undef MAX
#endif
#ifndef APOLLO_68K
#include <unistd.h>
#endif
#include <sys/stat.h>
#include <esps/esps.h>
#include <esps/filt.h>
#include <esps/unix.h>
#include <esps/fea.h>
#include <esps/feasd.h>
#include <esps/esignal_fea.h>
#include <esps/pc_wav.h>

/* Minimum number of bytes to read to recognize an ESPS file.
 * The ESPS magic number is a 4-byte long following four others
 * (if there is a preamble).
 */
#define ESPS_PREFIX_SIZE    (ESPS_MAGIC_OFFSET + 4)
#define ESPS_MAGIC_OFFSET   16

#define ESPS_BYTE  8
#define ESPS_SHORT  4

#undef BYTE
#undef SHORT

extern int errno;
extern int debug_level; 

#define MAX_PARAM_LEN 6000
/*
  This is a temp hack to work around a bug whereby a comment could be
  longer than the maximum size of a variable header item.   In the next
  version of esps change MAX_PARAM_LEN above to 8192, and removed the redefine
  of MAX_STRING
*/

#undef MAX_STRING	
#define MAX_STRING 6000*4


#define SIZINT (sizeof (int))
#define SIZFLT (sizeof (float))
#define SIZSHO (sizeof (short))
#define SIZLO  (sizeof (long))
#define SIZCHAR (sizeof (char))
#define SIZZF(z) (z ? (2*SIZSHO + (z->nsiz+z->dsiz)*SIZFLT)/SIZINT : 0)
#define BADHEAD(lev,text) { badhead (lev, text); return NULL; }

char    head_errtxt[100];
static int  buf[MAX_PARAM_LEN];
#define buf2 &buf[MAX_PARAM_LEN/2]/* 2nd half of buf */
long long_dummy;
char   *savestring ();
static void badhead (); 
static void recursive_wh (), put_shorts ();
static short  *get_shorts (), *copy_shorts ();
static float  *copy_floats (), *get_floats ();
static void write_genhd ();
char   *add_genhd ();
static void hd_error (), put_longs ();
static long   *copy_longs (), *get_longs ();
static void set_ana_type(), set_pit_type(), set_spec_type(), set_ros_type();
void set_filt_type(), set_scbk_type();
void add_comment();
#ifndef DEC_ALPHA
static long swap_longs();
#else
static int swap_longs();
#endif
void add_genzfunc();
int read_preamble();
static void rec_free_hdr();	/* used by free_header */
static void free_zfunc();	/* used by free_header */
static void free_strlist();	/* used by free_header */
static void f_copy(), putnulls(), write_par();
static int old_version();

static long edr_bytes_to_long();    /* used by recursive_rh */
static long lsbf_bytes_to_long();   /* used by recursive_rh */

double atof();

#ifdef DEMO
#define NOKEY 1
#endif

#ifndef NO_LIC
void check_header();
#endif


#define PRE_DERIVED "1.34"	/* last version of header.h without 
				   derived fields for feature files */
#define PRE_NEWSIZ  "1.44"	/* last version with ndouble, nfloat,
				   nlong, nshort, nchar, and fixpartsiz
				   as shorts */
#define PRE_FIELD_ORDER "1.57"	/* last version without ability to read or
				   write feature files in field order */
#define PRE_COMPLEX "1.70"	/* last version without complex fea fields */
#define PRE_ALIGNMENT "1.73"	/* last version without alignment pad */


#include <esps/mach_codes.h>

static int	edr_flag=0;		/* global EDR flag for reading */
static int	machine_code;		/* global machine_code flag */
int		EspsDebug = 0;		/* debug code enabled in this module */
#ifdef DEMO
static int	hash();			/* simple hash function */
#endif


/* copy zfunc, copies a zfunc from one header to another
*/

struct zfunc   *
copy_zfunc (src)
struct zfunc   *src;
{
    if (src == NULL)
	return (NULL);
    return (new_zfunc (src -> nsiz, src -> dsiz, src -> zeros, src -> poles));
}

/*
	new_zfunc creates a new zfunc structure from dynamic memory.
*/

struct zfunc   *
new_zfunc (ns, ds, num, den)
int     ns, ds;
float   num[], den[];
{
    struct zfunc   *z = (struct zfunc  *) malloc ((unsigned) sizeof *z);
    spsassert(z,"new_zfunc: malloc failed");
    if (ns > 0) {
	z -> zeros = (float *) malloc ((unsigned) (ns * SIZFLT));
        spsassert(z->zeros,"new_zfunc: malloc failed");
	f_copy (z -> zeros, num, ns);
    }
    else
	z -> zeros = NULL;
    if (ds > 0) {
	z -> poles = (float *) malloc ((unsigned) (ds * SIZFLT));
        spsassert(z->poles,"new_zfunc: malloc failed");
	f_copy (z -> poles, den, ds);
    }
    else
	z -> poles = NULL;
    z -> nsiz = ns;
    z -> dsiz = ds;
    return z;
}

static struct zfunc *
read_zfunc (lev, fd) int    lev;
FILE * fd; {
    short   ns, ds;
    if (!miio_get_short (&ns, 1, edr_flag, machine_code, fd) ||
	    !miio_get_short (&ds,  1, edr_flag, machine_code, fd))
	BADHEAD (lev, "zfunc read error");
    if (ns != 0)
	if (!miio_get_float ((float *)buf,  ns, edr_flag, machine_code, fd))
	    BADHEAD (lev, "zfunc read error");
    if (ds != 0)
	if (!miio_get_float ((float *)buf2,  ds, edr_flag, machine_code, fd))
	    BADHEAD (lev, "zfunc read error");
    return new_zfunc (ns, ds, (float *) buf, (float *) buf2);
}

static  void
write_zfunc (code, z, fd)
short   code;
struct zfunc   *z;
FILE * fd;
{
    short   len = SIZZF (z);
    if (!miio_put_short(&code, 1, edr_flag, fd) ||
	    !miio_put_short(&len, 1, edr_flag, fd) ||
	    !miio_put_short(&z -> nsiz, 1, edr_flag, fd) ||
	    !miio_put_short(&z -> dsiz, 1, edr_flag, fd))
	hd_error ("write_zfunc");
    if (z -> nsiz != 0)
	if (!miio_put_float(z -> zeros,  z -> nsiz, edr_flag, fd))
	    hd_error ("write_zfunc");

    if (z -> dsiz != 0)
	if (!miio_put_float(z -> poles, z -> dsiz, edr_flag, fd))
	    hd_error ("write_zfunc");
}

static int
typesiz (type)
int     type;
{
    switch (type) {
	case DOUBLE: 
	    return sizeof (double);
	case FLOAT: 
	    return sizeof (float);
	case LONG: 
	    return sizeof (long);
	case ESPS_SHORT: 
	    return sizeof (short);
	case CODED: 
	    return sizeof (short);
	case CHAR: 
	case ESPS_BYTE: 
	case EFILE:
	case AFILE:
	    return sizeof (char);
	case DOUBLE_CPLX:
            return sizeof(double_cplx);
    	case FLOAT_CPLX:
            return sizeof(float_cplx);
    	case LONG_CPLX:
            return sizeof(long_cplx);
    	case SHORT_CPLX:
            return sizeof(short_cplx);
    	case BYTE_CPLX:
            return sizeof(byte_cplx);
    }
    spsassert(NO, "typesiz: unrecognized type code");

    return 0;	/* not reached, just to keep lint happy */
}

static  void
write_genhd (code, np, fp)
short   code;
struct gen_hd  *np;
FILE * fp;
{
    short len;
/*
 * do not write out generic for sphere_hd_ptr, esignal_hd_ptr,
 * or pc_wav_hd_ptr
 */
    if (!strcmp(np->name, "sphere_hd_ptr")
	|| !strcmp(np->name, "esignal_hd_ptr")
	|| !strcmp(np->name, "pc_wav_hd_ptr"))
	return;
    write_par (code, np -> name, fp);
    if (!miio_put_int (&np -> size, 1, edr_flag, fp) ||
	    !miio_put_short(&np -> type, 1, edr_flag, fp))
	hd_error ("write_genhd");
    if (np->type == CODED) {
	char **p = np->codes;
	while (*p != NULL) {
		len = strlen(*p)+1;
		if(!miio_put_short(&len, 1, edr_flag, fp) ||
		   !miio_put_char(*p, len, edr_flag, fp)) 
			hd_error ("write_genhd");
		p++;
	}
	len = 0;
	if(!miio_put_short(&len, 1, edr_flag, fp))
		hd_error ("write_genhd");
    } 
    switch (np->type) {
	case DOUBLE:
	if (!miio_put_double((double *)np->d_ptr, (int)np->size, 
	     edr_flag, fp))
		hd_error ("write_genhd");
	break;
	case FLOAT:
	if (!miio_put_float((float *)np->d_ptr, (int)np->size, 
	     edr_flag, fp))
		hd_error ("write_genhd");
	break;
	case LONG:
	if (!miio_put_long((long *)np->d_ptr, (int)np->size, 
	     edr_flag, fp))
		hd_error ("write_genhd");
	break;
	case ESPS_SHORT:
	case CODED:
	if (!miio_put_short((short *)np->d_ptr, (int)np->size, 
	     edr_flag, fp))
		hd_error ("write_genhd");
	break;
	case CHAR:
	case ESPS_BYTE:
	case EFILE:
	case AFILE:
	if (!miio_put_char((char *)np->d_ptr, (int)np->size, 
	     edr_flag, fp))
		hd_error ("write_genhd");
	break;
     }
	
}

static
read_genhd (lev, fd, hd, name)
int     lev;
FILE * fd;
struct header  *hd;
char   *name;
{
    unsigned int    size;
    short   type, len;
    char   *ptr;
    char **codes;
    int data_rep = hd->common.edr;
    int mach_code = hd->common.machine_code;
    if (!miio_get_int (&size,  1, data_rep, mach_code, fd) ||
	    !miio_get_short (&type, 1, data_rep, mach_code, fd))
	BADHEAD (lev, "read_genhd read error");

    if (type != CODED) {
    	ptr = add_genhd (name, type, (int) size, (char *)NULL, 
		(char **)NULL, hd);
    }
    else {
	int i=0;
	codes = (char **)calloc(1,sizeof(char *));
	spsassert(codes != NULL,"read_genhd: calloc failed!");
        if (!miio_get_short (&len, 1, data_rep, mach_code, fd)) 
	    BADHEAD (lev, "read_genhd read error");
	while (len != 0) {
	    ptr = malloc(SIZCHAR*len);
	    spsassert(ptr != NULL,"read_genhd: malloc failed!");
	    if (!miio_get_char (ptr, len, data_rep, mach_code, fd))
	        BADHEAD (lev, "read_genhd read error");
	    codes[i++] = ptr;
	    codes = (char **)realloc((char *)codes, sizeof(char *)*(i+1));
	    spsassert(codes != NULL,"read_genhd: realloc failed!");
	    codes[i] = NULL;
            if (!miio_get_short (&len, 1, data_rep, mach_code, fd))
	        BADHEAD (lev, "read_genhd read error");
	}
    	ptr = add_genhd (name, type, (int) size, (char *)NULL, 
		codes, hd);
    }
    switch (type) {
	case DOUBLE:
	if (!miio_get_double((double *)ptr, (int)size, data_rep, mach_code, fd))
        	BADHEAD (lev, "read_genhd read error");
	break;
	case FLOAT:
	if (!miio_get_float((float *)ptr, (int)size, data_rep, mach_code, fd))
        	BADHEAD (lev, "read_genhd read error");
	break;
	case LONG:
	if (!miio_get_long((long *)ptr, (int)size, data_rep, mach_code, fd))
        	BADHEAD (lev, "read_genhd read error");
	break;
	case ESPS_SHORT:
	case CODED:
	if (!miio_get_short((short *)ptr, (int)size, data_rep, mach_code, fd))
        	BADHEAD (lev, "read_genhd read error");
	break;
	case CHAR:
	case ESPS_BYTE:
	case EFILE:
	case AFILE:
	if (!miio_get_char((char *)ptr, (int)size, data_rep, mach_code, fd))
        	BADHEAD (lev, "read_genhd read error");
	break;
     }
    return 0;
}



/*
	read_header reads in a file header. recursive_rh really does the
	work.
*/


/* #define NDREC1  */

/* define NDREC1 to get beta case of ndrec not being
   set to -1 for pipes.   Remove this to get esps 3.0 code 
*/

static long data_offset;
static long align_pad_size;