miio.c

来自「speech signal process tools」· C语言 代码 · 共 1,388 行 · 第 1/3 页

	spsassert(fp,  "miio_put_int: fp is NULL");
	spsassert(n >= 0, "miio_put_int: n not > 0");
	spsassert(flag == 0 || flag == 1, "miio_put_int: bad flag");

	if (n == 0) return(0);
	return (fwrite((char *)ptr, sizeof(*ptr), n, fp));
}

int
miio_put_long(ptr, n, flag, fp)
long *ptr;
int n;
int flag;
FILE *fp;

{
	spsassert(ptr, "miio_put_long: ptr is NULL");	
	spsassert(fp,  "miio_put_long: fp is NULL");
	spsassert(n >= 0, "miio_put_long: n not > 0");
	spsassert(flag == 0 || flag == 1, "miio_put_long: bad flag");

	if (n == 0) return(0);
	return (fwrite((char *)ptr, sizeof(*ptr), n, fp));
}

int
miio_put_short(ptr, n, flag, fp)
short *ptr;
int n;
int flag;
FILE *fp;

{
	spsassert(ptr, "miio_put_short: ptr is NULL");	
	spsassert(fp,  "miio_put_short: fp is NULL");
	spsassert(n >= 0, "miio_put_short: n not > 0");
	spsassert(flag == 0 || flag == 1, "miio_put_short: bad flag");

	if (n == 0) return(0);
	return (fwrite((char *)ptr, sizeof(*ptr), n, fp));
}

int
miio_put_char(ptr, n, flag, fp)
char *ptr;
int n;
int flag;
FILE *fp;

{

	spsassert(ptr, "miio_put_char: ptr is NULL");	
	spsassert(fp,  "miio_put_char: fp is NULL");
	spsassert(n >= 0, "miio_put_char: n not > 0");
	spsassert(flag == 0 || flag == 1, "miio_put_char: bad flag");

	if (n == 0) return(0);
	return (fwrite((char *)ptr, sizeof(*ptr), n, fp));
}

int
miio_put_byte(ptr, n, flag, fp)
char *ptr;
int n;
int flag;
FILE *fp;

{

	spsassert(ptr, "miio_put_byte: ptr is NULL");	
	spsassert(fp,  "miio_put_byte: fp is NULL");
	spsassert(n >= 0, "miio_put_byte: n not > 0");
	spsassert(flag == 0 || flag == 1, "miio_put_byte: bad flag");

	if (n == 0) return(0);
	return (fwrite((char *)ptr, sizeof(*ptr), n, fp));
}

#endif  /* end of machines that do EDR by default */


/* this section is for Sun386i, DS3100, and DEC_ALPHA machines
*/
#if defined(SUN386i) || defined(DS3100) || defined(DEC_ALPHA) || defined(LINUX)

int
miio_get_double(ptr, n, flag, mach, fp)
double *ptr;
int n;
int flag;
int mach;
FILE *fp;

{
	int item_count = 0;		/* count of items read */

	spsassert(ptr, "miio_get_double: ptr is NULL");	
	spsassert(fp,  "miio_get_double: fp is NULL");
	spsassert(n >= 0, "miio_get_double: n not > 0");
	spsassert(flag == NO || flag == YES, "miio_get_double: bad flag");

	if (n == 0) return(0);
	if (flag == NO && (mach == SUN386i_CODE || mach == DS3100_CODE || mach == DEC_ALPHA_CODE || mach == LINUX_CODE))
	/* no need to translate */
		return (fread((char *)ptr, sizeof(*ptr), n, fp));
	else if (flag == YES || edr_default(mach)) { 		
/* translate from EDR */
	 while (n--) {
		if (fread(&u1.byte[7], 1, 1, fp) != 1) 
		  break;
		if (fread(&u1.byte[6], 1, 1, fp) != 1)
		  miio_input_error("double");
		if (fread(&u1.byte[5], 1, 1, fp) != 1)
		  miio_input_error("double");
		if (fread(&u1.byte[4], 1, 1, fp) != 1)
		  miio_input_error("double");
		if (fread(&u1.byte[3], 1, 1, fp) != 1)
		  miio_input_error("double");
		if (fread(&u1.byte[2], 1, 1, fp) != 1)
		  miio_input_error("double");
		if (fread(&u1.byte[1], 1, 1, fp) != 1)
		  miio_input_error("double");
		if (fread(&u1.byte[0], 1, 1, fp) != 1)
		  miio_input_error("double");
		*ptr++ = u1.d_val;
		item_count++;
	  }
	 return item_count;
	}
	else {
	    Fprintf(stderr,
	     "ESPS (double) file input routine: this file was written on a %s ",
	     machine_codes[mach]);
	    Fprintf(stderr, "and cannot be read on this machine.\n");
	    exit(1);
	}
}


int
miio_get_float(ptr, n, flag, mach, fp)
float *ptr;
int n;
int flag;
int mach;
FILE *fp;

{
	int item_count=0;	/* count of items read */

	spsassert(ptr, "miio_get_float: ptr is NULL");	
	spsassert(fp,  "miio_get_float: fp is NULL");
	spsassert(n >= 0, "miio_get_float: n not > 0");
	spsassert(flag == 0 || flag == 1, "miio_get_float: bad flag");

	if (n == 0) return(0);
	if (flag == NO && (mach == SUN386i_CODE || mach == DS3100_CODE || mach == DEC_ALPHA_CODE || mach == LINUX_CODE))
	/* no need to translate */
		return (fread((char *)ptr, sizeof(*ptr), n, fp));
	else if (flag == YES || edr_default(mach)) { 		
	   while (n--) {
		if (fread(&u2.byte[3], 1, 1, fp) != 1)
		  break;
		if (fread(&u2.byte[2], 1, 1, fp) != 1)
		  miio_input_error("float");
		if (fread(&u2.byte[1], 1, 1, fp) != 1)
		  miio_input_error("float");
		if (fread(&u2.byte[0], 1, 1, fp) != 1)
		  miio_input_error("float");
		*ptr++ = u2.f_val;
		item_count++;
	   }
	  return item_count;
	}
	else {
	    Fprintf(stderr,
	     "ESPS (float) file input routine: this file was written on a %s ",
	     machine_codes[mach]);
	    Fprintf(stderr, "and cannot be read on this machine.\n");
	    exit(1);
	}
}
#ifdef DEC_ALPHA
int
miio_get_long(ptr, n, flag, mach, fp)
long *ptr;
int n;
int flag;
int mach;
FILE *fp;

{
	int item_count=0;	/* count of items read */

	spsassert(ptr, "miio_get_long: ptr is NULL");	
	spsassert(fp,  "miio_get_long: fp is NULL");
	spsassert(n >= 0, "miio_get_long: n not > 0");
	spsassert(flag == 0 || flag == 1, "miio_get_long: bad flag");

	if (n == 0) return(0);
	if (flag == NO && (mach == DEC_ALPHA_CODE))
	/* no need to translate */
		return (fread((char *)ptr, sizeof(*ptr), n, fp));
	else if (flag == YES || edr_default(mach)) { 		
	  while (n--) {
		if (fread(&u2.byte[3], 1, 1, fp) != 1)
		  break;
		if (fread(&u2.byte[2], 1, 1, fp) != 1)
		  miio_input_error("long");
		if (fread(&u2.byte[1], 1, 1, fp) != 1)
		  miio_input_error("long");
		if (fread(&u2.byte[0], 1, 1, fp) != 1)
		  miio_input_error("long");
		*ptr++ = u2.l_val;
		item_count++;
	  }
	  return item_count;
	}
	else if (flag == NO && ((mach == DS3100_CODE) || (mach == LINUX_CODE))){
	  int i_reg;
	  while (n--) {
		if (fread(&i_reg, 1, 4, fp) != 4)
		  break;
		*ptr++ = i_reg;
		item_count++;
	  }
	  return item_count;
	}
	else {
	    Fprintf(stderr,
	     "ESPS (long) file input routine: this file was written on a %s ",
	     machine_codes[mach]);
	    Fprintf(stderr, "and cannot be read on this machine.\n");
	    exit(1);
	}
}

#else
int
miio_get_long(ptr, n, flag, mach, fp)
long *ptr;
int n;
int flag;
int mach;
FILE *fp;

{
	int item_count=0;	/* count of items read */

	spsassert(ptr, "miio_get_long: ptr is NULL");	
	spsassert(fp,  "miio_get_long: fp is NULL");
	spsassert(n >= 0, "miio_get_long: n not > 0");
	spsassert(flag == 0 || flag == 1, "miio_get_long: bad flag");

	if (n == 0) return(0);
	if (flag == NO && (mach == SUN386i_CODE || mach == DS3100_CODE || mach == LINUX_CODE))
	/* no need to translate */
		return (fread((char *)ptr, sizeof(*ptr), n, fp));
/* 
 translate a file from DEC ALPHA native format
*/
        else if (flag == NO && (mach == DEC_ALPHA_CODE)) {
	  while (n--) {
                char dummy[4];
		if (fread(&u2.byte[0], 1, 1, fp) != 1)
		  break;
		if (fread(&u2.byte[1], 1, 1, fp) != 1)
		  miio_input_error("long");
		if (fread(&u2.byte[2], 1, 1, fp) != 1)
		  miio_input_error("long");
		if (fread(&u2.byte[3], 1, 1, fp) != 1)
		  miio_input_error("long");
		*ptr++ = u2.l_val;
/* just discard the extra four bytes */
		if (fread(dummy, 1, 4, fp) != 4)
		  miio_input_error("long");
		item_count++;
	  }
          return item_count;
        }
	else if (flag == YES || edr_default(mach)) { 		
	  while (n--) {
		if (fread(&u2.byte[3], 1, 1, fp) != 1)
		  break;
		if (fread(&u2.byte[2], 1, 1, fp) != 1)
		  miio_input_error("long");
		if (fread(&u2.byte[1], 1, 1, fp) != 1)
		  miio_input_error("long");
		if (fread(&u2.byte[0], 1, 1, fp) != 1)
		  miio_input_error("long");
		*ptr++ = u2.l_val;
		item_count++;
	  }
	  return item_count;
	}
	else {
	    Fprintf(stderr,
	     "ESPS (long) file input routine: this file was written on a %s ",
	     machine_codes[mach]);
	    Fprintf(stderr, "and cannot be read on this machine.\n");
	    exit(1);
	}
}
#endif DEC_ALPHA

int
miio_get_short(ptr, n, flag, mach, fp)
short *ptr;
int n;
int flag;
int mach;
FILE *fp;

{
	int item_count=0;	/* count of items read */

	spsassert(ptr, "miio_get_short: ptr is NULL");	
	spsassert(fp,  "miio_get_short: fp is NULL");
	spsassert(n >= 0, "miio_get_short: n not > 0");
	spsassert(flag == 0 || flag == 1, "miio_get_short: bad flag");

	if (n == 0) return(0);
	if (flag == NO && (mach == SUN386i_CODE || mach == DS3100_CODE || mach == DEC_ALPHA_CODE || mach == LINUX_CODE))
	/* no need to translate */
		return (fread((char *)ptr, sizeof(*ptr), n, fp));
	else if (flag == YES || edr_default(mach)) { 		
	  while (n--) {
		if (fread(&u3.byte[1], 1, 1, fp) != 1)
		  break;
		if (fread(&u3.byte[0], 1, 1, fp) != 1)
		  miio_input_error("short");
		*ptr++ = u3.s_val;
		item_count++;
	  }
	  return item_count;
	}
	else {
	    Fprintf(stderr,
	     "ESPS (short) file input routine: this file was written on a %s ",
	     machine_codes[mach]);
	    Fprintf(stderr, "and cannot be read on this machine.\n");
	    exit(1);
	}
}

int
miio_get_int(ptr, n, flag, mach, fp)
int *ptr;
int n;
int flag;
int mach;
FILE *fp;

{
	int item_count=0;

	spsassert(ptr, "miio_get_int: ptr is NULL");	
	spsassert(fp,  "miio_get_int: fp is NULL");
	spsassert(n >= 0, "miio_get_int: n not > 0");
	spsassert(flag == 0 || flag == 1, "miio_get_int: bad flag");

	if (n == 0) return(0);
	if (flag == NO && (mach == SUN386i_CODE || mach == DS3100_CODE || mach == DEC_ALPHA_CODE || mach == LINUX_CODE))
	/* no need to translate */
		return (fread((char *)ptr, sizeof(*ptr), n, fp));
	else if (flag == YES || edr_default(mach)) { 		
	   while (n--) {
		if (fread(&u2.byte[3], 1, 1, fp) != 1)
		  break;
		if (fread(&u2.byte[2], 1, 1, fp) != 1)
		  miio_input_error("int");
		if (fread(&u2.byte[1], 1, 1, fp) != 1)
		  miio_input_error("int");
		if (fread(&u2.byte[0], 1, 1, fp) != 1)
		  miio_input_error("int");
		*ptr++ = u2.l_val;
		item_count++;
	   }
	  return item_count;
	}
	else {
	    Fprintf(stderr,
	     "ESPS (int) file input routine: this file was written on a %s ",
	     machine_codes[mach]);
	    Fprintf(stderr, "and cannot be read on this machine.\n");
	    exit(1);
	}
}

int
miio_get_char(ptr, n, flag, mach, fp)
char *ptr;
int n;
int flag;
int mach;
FILE *fp;

{

	spsassert(ptr, "miio_get_char: ptr is NULL");	
	spsassert(fp,  "miio_get_char: fp is NULL");
	spsassert(n >= 0, "miio_get_char: n not > 0");
	spsassert(flag == 0 || flag == 1, "miio_get_char: bad flag");

	if (n == 0) return(0);
	return (fread((char *)ptr, sizeof(*ptr), n, fp));
}

int
miio_get_byte(ptr, n, flag, mach, fp)
char *ptr;
int n;
int flag;
int mach;
FILE *fp;

{

	spsassert(ptr, "miio_get_byte: ptr is NULL");	
	spsassert(fp,  "miio_get_byte: fp is NULL");
	spsassert(n >= 0, "miio_get_byte: n not > 0");
	spsassert(flag == 0 || flag == 1, "miio_get_byte: bad flag");

	if (n == 0) return(0);
	return (fread((char *)ptr, sizeof(*ptr), n, fp));
}

int
miio_put_double(ptr, n, flag, fp)
double *ptr;
int n;
int flag;
FILE *fp;

{
	int i=n;

	spsassert(ptr, "miio_put_double: ptr is NULL");	
	spsassert(fp,  "miio_put_double: fp is NULL");
	spsassert(n >= 0, "miio_put_double: n not > 0");
	spsassert(flag == 0 || flag == 1, "miio_put_double: bad flag");

	if (n == 0) return(0);
	if (flag == NO)	/* no need to translate */
		return (fwrite((char *)ptr, sizeof(*ptr), n, fp));
	else { 		/* translate from EDR */
	 while (n--) {
		u1.d_val = *ptr++;
		if (fwrite(&u1.byte[7], 1, 1, fp) != 1)
		  return 0;
		if (fwrite(&u1.byte[6], 1, 1, fp) != 1)
		  return 0;
		if (fwrite(&u1.byte[5], 1, 1, fp) != 1)
		  return 0;
		if (fwrite(&u1.byte[4], 1, 1, fp) != 1)
		  return 0;
		if (fwrite(&u1.byte[3], 1, 1, fp) != 1)
		  return 0;
		if (fwrite(&u1.byte[2], 1, 1, fp) != 1)
		  return 0;
		if (fwrite(&u1.byte[1], 1, 1, fp) != 1)
		  return 0;
		if (fwrite(&u1.byte[0], 1, 1, fp) != 1)