hd.c

speech signal process tools

		for (i = 0; i < size; i++) {
    		    if (!miio_get_short(&len, 1, edr_flag, machine_code, fd))
			BADHEAD (lev, "bad specific part-len of fea name");
		    fea -> names[i] = calloc ((unsigned)(len+1), sizeof (char));
		    if (!miio_get_char(fea->names[i], len, edr_flag, 
					machine_code, fd))
			BADHEAD (lev, "bad specific part -fea names");
		    fea -> names[i][len] = '\0';
		    if (fea->ranks[i] != 0) {
		    	fea -> dimens[i] = 
			(long *)calloc((unsigned) fea->ranks[i], sizeof (long));
			if (!miio_get_long(fea->dimens[i], (int)fea->ranks[i], 
				edr_flag, machine_code, fd))
			BADHEAD (lev, "bad specific part -fea ranks");
		    }
		    if (fea -> types[i] == CODED) {
    			if (!miio_get_short(&len, 1, edr_flag,
						machine_code, fd))
			    BADHEAD (lev, "bad specific part-len of fea enums");
			fea -> enums[i] = (char **) calloc ((unsigned)len+1,
				sizeof (char *));
			fea->enums[i][0] = NULL;
			for (j = 0; j < len; j++) {
			    short   len2;

    			    if (!miio_get_short(&len2, 1, edr_flag,
						machine_code, fd))
				BADHEAD (lev,
					"bad specific part-len of fea enum");
			    fea -> enums[i][j] = calloc ((unsigned)(len2+1), 
					sizeof (char));
			    if (!miio_get_char(fea->enums[i][j], (int)len2,
				edr_flag, machine_code, fd))
				BADHEAD (lev, "bad specific part -fea enums");
			    fea -> enums[i][j][len2] = '\0';
			}
		    }
		    if (!old_version(p->common.hdvers,PRE_DERIVED)) {
    			if (!miio_get_short(&len, 1, edr_flag,
						machine_code, fd))
			    BADHEAD (lev, "bad specific part-len of src flds");
			fea -> srcfields[i] = (char **) 
				calloc ((unsigned)len+1, sizeof (char *));
			fea->srcfields[i][0] = NULL;
			for (j = 0; j < len; j++) {
			    short   len2;

    			    if (!miio_get_short(&len2, 1, edr_flag,
						machine_code, fd))
				BADHEAD (lev,
					"bad specific part-len of src fld");
			    fea -> srcfields[i][j] = 
				calloc ((unsigned)(len2+1), sizeof (char));
			    if (!miio_get_char(fea->srcfields[i][j], (int)len2,
				edr_flag, machine_code, fd))
				BADHEAD (lev, 
					"bad specific part -fea srcfields");
			    fea -> srcfields[i][j][len2] = '\0';
			}
		    }
		}
		break;
	    }

	default: 
	    BADHEAD (lev, "unknown header type");
	    break;
    }

/* process variable part of the header */
    while (1) {
	if (!miio_get_short(&code, 1, edr_flag, machine_code, fd))
	    BADHEAD (lev, "read error: code");
	if (code < 0 || code > PT_MAX)
	    BADHEAD (lev, "illegal parameter code");
	if (!miio_get_short(&len, 1, edr_flag, machine_code, fd))
	    BADHEAD (lev, "bad parameter format");
/* at end of header we have code==PT_ENDPAR, len==0 */
	if (code == PT_ENDPAR)
	    break;
/* make sure parameter will fit */
	if (code != PT_HEADER && len > MAX_PARAM_LEN)
	    BADHEAD (lev, "optional parameter too long");

/* Do the read here for string parameters */
	if (code == PT_SOURCE || code == PT_TYPTXT
		|| code == PT_REFER || code == PT_COMMENT
		|| code == PT_GENHD || code == PT_CWD) {
	    if (!miio_get_char((char *)buf, (int)(len*SIZINT), 
		 edr_flag, machine_code, fd))
		BADHEAD (lev, "read error: opt");
	    buf[len] = 0;	/* ensure null termination */
	}
/* when adding file types, be sure to check this for valid options */
	switch (code) {
	    case PT_SOURCE: 
		p -> variable.source[ns++] = savestring ((char *) buf);
		break;
	    case PT_TYPTXT: 
		p -> variable.typtxt = savestring ((char *) buf);
		break;
	    case PT_COMMENT: 
		p -> variable.comment = savestring ((char *) buf);
		break;
	    case PT_CWD:
		p -> variable.current_path = savestring ((char *) buf);
		break;
	    case PT_REFER: 
		p -> variable.refer = savestring ((char *) buf);
		break;
	    case PT_PRE: 	/* pre_emp */
		switch (p -> common.type) {

#ifdef ESI
		    case FT_ANA: 
			if ((p->hd.ana->pre_emp = read_zfunc(lev, fd)) == NULL)
			    return NULL;
			break;
#endif ESI
		    case FT_SPEC: 
			if ((p->hd.spec->pre_emp = read_zfunc(lev, fd)) == NULL)
			    return NULL;
			break;
		    default: 
			BADHEAD (lev, "wrong zfunc");
			break;
		}
		break;
	    case PT_PREFILTER: 	/* prefilter */
		switch (p -> common.type) {

#ifdef ESI
		    case FT_PIT: 
			if ((p->hd.pit->prefilter = read_zfunc(lev, fd)) ==NULL)
			    return NULL;
			break;
#endif ESI

		    case FT_SD: 
			if ((p->hd.sd->prefilter = read_zfunc(lev, fd))==NULL)
			    return NULL;
			break;
		    default: 
			BADHEAD (lev, "wrong zfunc");
			break;
		}
		break;
	    case PT_LPF: 
		switch (p -> common.type) {

#ifdef ESI
		    case FT_PIT: 
			if ((p -> hd.pit -> lpf = read_zfunc (lev, fd)) == NULL)
			    return NULL;
			break;
#endif ESI

		    default: 
			BADHEAD (lev, "wrong zfunc");
			break;
		}
		break;
	    case PT_DEEMP: 	/* de_emp */
		switch (p -> common.type) {
		    case FT_SD: 
			if ((p -> hd.sd->de_emp = read_zfunc(lev, fd)) == NULL)
			    return NULL;
			break;
		    default: 
			BADHEAD (lev, "wrong zfunc");
			break;
		}
		break;
	    case PT_GENHD: 
		(void) read_genhd (lev, fd, p, (char *) buf);
		break;
	    case PT_HEADER: 
		if ((p->variable.srchead[nh]=recursive_rh(fd, lev+1)) == NULL)
		    return NULL;
		nh++;
		break;
	    case PT_REFHD:
		if ((p->variable.refhd = recursive_rh(fd, lev+1)) == NULL)
		    return NULL;
		break;
	    default: 
		BADHEAD (lev, "bad optional parameter type");
		break;
	}
    }
    p -> variable.nnames = ns;
    p -> variable.nheads = nh;
    return p;
}

/*
	Error messages for read_header and its subroutines are stuffed
	into head_errtxt by badhead.
*/
static  void
badhead (level, msg)
int     level;
char   *msg;
{
    (void) sprintf (head_errtxt,
	    "read_header: %s%s\n", msg, level ? " in included header" : "");
    if(EspsDebug)
    	Fprintf (stderr,
	    "read_header: %s%s\n", msg, level ? " in included header" : "");
}

/*
	f_copy copies a floating vector.
*/
static void
f_copy (dst, src, n)
float  *dst, *src;
int     n;
{
    while (n-- > 0)
	*dst++ = *src++;
}

/*
	divceil does integer division rounding upward
*/
#define divceil(j,k) ((j)+(k)-1) / (k)

/*
	fix_header repairs the following fields:
	fixpartsiz, hsize, check 
        and the type fields
	It calls itself recursively for included headers.
*/
static
fix_header (p)
struct header  *p;
{
    int     i, size, sumop = FIX_HEADER_SIZE;
    p -> common.fixpartsiz = FIX_HEADER_SIZE;
fprintf(stderr,"point b1\n");
    for (i = 0; i < MAX_SOURCES; i++) {
	if (p -> variable.srchead[i]) {
fprintf(stderr,"point b2\n");
	    fix_header (p -> variable.srchead[i]);
	    sumop += p -> variable.srchead[i] -> common.hsize;
	}
fprintf(stderr,"point b3\n");
	if (p -> variable.source[i]) {
	    sumop += divceil (strlen (p -> variable.source[i]) + 1, SIZINT);
	}
    }
fprintf(stderr,"point b4\n");
    if (p -> variable.refhd) {
	fix_header (p -> variable.refhd);
	sumop += p -> variable.refhd -> common.hsize;
    }
fprintf(stderr,"point b5\n");
    if (p -> variable.typtxt)
	sumop += divceil (strlen (p -> variable.typtxt) + 1, SIZINT);
    if (p -> variable.comment)
	sumop += divceil (strlen (p -> variable.comment) + 1, SIZINT);
    if (p -> variable.refer)
	sumop += divceil (strlen (p -> variable.refer) + 1, SIZINT);
fprintf(stderr,"point b6\n");
    for (i = 0; i < GENTABSIZ; i++) {
	struct gen_hd  *np;
	np = p -> variable.gentab[i];
	while (np != NULL) {
	    sumop += divceil (strlen (np -> name) + 1, SIZINT);
	    sumop += SIZINT + SIZSHO + np -> size * typesiz (np -> type);
	    np = np -> next;
	}
    }
    switch (p -> common.type) {

#ifdef ESI
	case FT_ANA: 
	    sumop += divceil (ANA_SIZE, sizeof (int));
	    sumop += SIZZF (p -> hd.ana -> pre_emp);
	    break;

	case FT_PIT: 
	    sumop += divceil (PIT_SIZE, sizeof (int));
	    sumop += SIZZF (p->hd.pit->prefilter) + SIZZF (p -> hd.pit -> lpf);
	    break;

	case FT_ROS: 
	    sumop += divceil (ROS_SIZE, sizeof (int));
	    if (p -> hd.ros -> type_bits != NULL)
		sumop += SIZSHO * p -> hd.ros -> maxtype;
	    if (p -> hd.ros -> rc_ubits != NULL)
		sumop += SIZSHO*p->hd.ros->order_unvcd;
	    if (p -> hd.ros -> rc_vbits != NULL)
		sumop += SIZSHO*p->hd.ros->order_vcd;
	    if (p -> hd.ros -> pulse_bits != NULL)
		sumop += SIZSHO * p -> hd.ros -> maxpulses;
	    if (p -> hd.ros -> pow_bits != NULL)
		sumop += SIZSHO * p -> hd.ros -> maxpow;
	    break;
#endif ESI

	case FT_SD: 
	    sumop += divceil (SD_SIZE, sizeof (int));
	    sumop += SIZZF(p -> hd.sd -> prefilter) + SIZZF(p->hd.sd->de_emp);
	    break;

	case FT_SPEC: 
	    sumop += divceil (SPEC_SIZE, sizeof (int));
	    sumop += SIZZF (p -> hd.spec -> pre_emp);
	    break;

	case FT_FILT: 
	    sumop += divceil (FILT_SIZE, sizeof (int));
	    if (p -> hd.filt -> bandedges != NULL)
		sumop += SIZFLT * p -> hd.filt -> nbands * 2;
	    if (p -> hd.filt -> points != NULL)
		sumop += SIZFLT * p -> hd.filt -> npoints;
	    if (p -> hd.filt -> gains != NULL && 
		p -> hd.filt -> func_spec == BAND)
		sumop += SIZFLT * p -> hd.filt -> nbands;
	    if (p -> hd.filt -> gains != NULL &&
	 	p -> hd.filt -> func_spec == POINT)
		sumop += SIZFLT * p -> hd.filt -> npoints;
	    if (p -> hd.filt -> wts != NULL && 
		p -> hd.filt -> func_spec == BAND)
		sumop += SIZFLT * p -> hd.filt -> nbands;
	    if (p -> hd.filt -> wts != NULL && 
		p -> hd.filt -> func_spec == POINT)
		sumop += SIZFLT * p -> hd.filt -> npoints;
	    break;

	case FT_SCBK: 
	    sumop += divceil (SCBK_SIZE, sizeof (int));
	    break;

	case FT_FEA: 
fprintf(stderr,"point b7\n");
	    size = p -> hd.fea -> field_count;
	    sumop += divceil (FEA_SIZE, sizeof (int));
	    sumop += size * ((2*SIZLO) + (3*SIZSHO));
	    for (i = 0; i < size; i++) {
fprintf(stderr,"point b8\n");
fprintf(stderr,"p: %x\n",p);
fprintf(stderr,"p->hd.fea: %x\n",p->hd.fea);
fprintf(stderr,"p->hd.fea->names: %x\n",p->hd.fea->names);
fprintf(stderr,"names: %x\n",p->hd.fea->names[i]);
fprintf(stderr,"name: %s\n",p->hd.fea->names[i]);
fprintf(stderr,"ranks: %x\n",p->hd.fea->ranks[i]);
		sumop += strlen (p -> hd.fea -> names[i]);
		sumop += SIZLO * p -> hd.fea -> ranks[i];
fprintf(stderr,"point b9\n");
		if (p -> hd.fea -> types[i] == CODED) {
		    char  **s = p -> hd.fea -> enums[i];
		    while (s && *s) {
			sumop += strlen (*s) + SIZSHO;
			s++;
		    }
		}
		{
		    char  **s = p -> hd.fea -> srcfields[i];
fprintf(stderr,"point b10\n");
		    if (s != NULL) while (*s) {
			sumop += strlen (*s) + SIZSHO;
			s++;
		    }
		}
	    }
fprintf(stderr,"point b11\n");
	    break;

    }

/* if any optional parameters, we need a zero at the end */
    if (sumop > p -> common.fixpartsiz)
	sumop++;
    p -> common.hsize = sumop;
    p -> common.check = HD_CHECK_VAL;
}


/* Assume the 4 bytes starting at address "ptr" are the
 * EDR (most-significant-byte-first) representation of
 * a long.  Return the value of the long.
 */
static long
edr_bytes_to_long(ptr)
    char    *ptr;
{
    unsigned long   item;
    unsigned long   mask = 0xff;

    item = ((ptr[3] & mask)
	    | (ptr[2] & mask) << 8
	    | (ptr[1] & mask) << 16
	    | (ptr[0] & mask) << 24);

    return (((item & 0x80000000) == 0) ? item
	    : -1L - (long) (item ^ 0xffffffff));
}


/* Assume the 4 bytes starting at address "ptr" are the
 * "byte-reversed EDR" (least-significant-byte-first)
 * representation of a long.  Return the value of the long.
 */
static long
lsbf_bytes_to_long(ptr)
    char    *ptr;
{
    unsigned long   item;
    unsigned long   mask = 0xff;

    item = ((ptr[0] & mask)
	    | (ptr[1] & mask) << 8
	    | (ptr[2] & mask) << 16
	    | (ptr[3] & mask) << 24);

    return (((item & 0x80000000) == 0) ? item
	    : -1L - (long) (item ^ 0xffffffff));
}