llib-lespsg.c

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

/* LINTLIBRARY */
/*
 * 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) 1986-1990  Entropic Speech, Inc. 
 *    "Copyright (c) 1990-1993  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:  
 * Checked by:
 * Revised by:
 *
 * Brief description:
 * This is the lint library for type checking against the ESPS library.
 */

/* @(#)llib-lespsg.c	1.48 6/28/93 ESI */

#include <stdio.h>
#include <esps/esps.h>
#include <esps/sd.h>
#include <esps/spec.h>
#include <esps/filt.h>
#include <esps/scbk.h>
#include <esps/fea.h>
#include <esps/anafea.h>
#include <esps/vq.h>
#include <esps/feastat.h>
#include <esps/feaspec.h>
#include <esps/feasd.h>
#include <esps/feadst.h>
#include <esps/feafilt.h>
#include <esps/ss.h>

void add_source_file(hd,name,src_hd) 
	struct header *hd,*src_hd; char *name; 
	{return;}
void add_comment(hd,text) 
	struct header *hd; char *text; 
	{return;}
int atoh(s) 
	char *s; 
	{ return 0;}
char *arr_func(func, num, src, src_type, dest, dest_type)
	int func; long num; char *src;
	int src_type; char *dest; int dest_type;
	{return (char *) NULL;}
char *arr_op(op, num, src1, src1_type, src2, src2_type, dest, dest_type)
	int op; long num; char *src1; int src1_type;
	char *src2; int src2_type; char *dest; int dest_type;
	{return (char *) NULL;}
struct header *copy_header(h) 
	struct header *h; 
	{ return (struct header *) NULL;}
void d_copy(out,in,n) 
	double *out,*in; 
	{return;}
void f_copy(out,in,n) 
	float *out,*in; 
	{ return;}
double **d_mat_alloc(nr,nc) 
	{ return (double **)NULL;}
float **f_mat_alloc(nr,nc) 
	unsigned nr, nc;
	{ return (float **)NULL;}
int d_mat_free(mat,nr) 
	double **mat; 
	{ return;}
int f_mat_free(mat,nr) 
	float **mat; 
	{ return;}
int emphasis(x,n,p,z,state) 
	double *x,*p,*z,*state; 
	{ return 0;}
faterr(sub,txt,n) 
	char *sub,*txt; 
	{ return;}
void frange_switch(txt,ps,pe) 
	char *txt; double *ps, *pe; 
	{ return;}
long fstatsiz(fd) 
	FILE *fd; 
	{return 0L;}
int get_ddata(fd,typ,x,n) 
	FILE *fd; double *x; 
	{ return;}
int get_fdata(fd,typ,x,n) 
	FILE *fd; float *x; 
	{ return;}
int getopt(ac,av,opts) 
	char **av, *opts; 
	{ return 0;}
char getsym_c(name) 
	char *name; 
	{ return 'y';}
double getsym_d(name) 
	char *name; 
	{return 0.0;}
int getsym_da(name,arr,l) 
	char *name; double *arr; 
	{return l;}
int getsym_i(name) 
	char *name; 
	{return 0;}
int getsym_ia(name,arr,l) 
	char *name; int *arr; 
	{return l;}
char *getsym_s(name) 
	char *name; 
	{return (char *) NULL;}
void init_table() 
	{ return;}
void lrange_switch(txt,ps,pe,us) 
	char *txt; long *ps,*pe; int us; 
	{ return;}
int make_symbol(name,val,typ,pr,s) 
	char *name,*s; YYSTYPE val; 
	{ return 0;}
struct header *new_header(type) 
	int type; 
	{ return (struct header *) NULL;};
struct zfunc *new_zfunc(ns,ds,n,d) 
	float *n,*d; 
	{ return (struct zfunc *) NULL;}
struct zfunc *copy_zfunc(src) 
	struct zfunc *src; 
	{ return (struct zfunc *) NULL;}
int print_arr(array,form,siz,fname) 
	char *fname,*array,*form; 
	{ return 0;}
int print_mat(mat,size) 
	double **mat; 
	{ return 0;}
int printarr(array,form,siz,fname) 
	char *fname,*array,*form; 
	{ return 0;}
int put_ddata(fd,type,x,n) 
	FILE *fd; double *x; 
	{ return;}
int put_fdata(fd,type,x,n) 
	FILE *fd; float *x; 
	{ return;}
void range_switch(txt,ps,pe,us) 
	char *txt; int *ps, *pe; int us; 
	{return;}
int rd_array(arr,elt_siz,maxsiz,file) 
	char *file,*arr; 
	{ return 0;}
int rd_plot(arr,maxsiz,file) 
	double *arr; char *file; 
	{return 0;}
struct header *read_header(fd) 
	FILE *fd; 
	{ return (struct header *) NULL;}
int read_params(a,b,c) 
	char *a; int b; char *c; 
	{ return 0;}
char *savestring(s) 
	char *s; 
	{ return s;}
int scan_arr(arr,form,maxsiz,file) 
	char *arr,*form,*file; 
	{ return 0;}
int scanarr(arr,form,siz,file) 
	char *arr,*form,*file; 
	{ return 0;}
void symerr_exit() 
	{ return;}
int shift3(a,b,c,n) 
	double *a,*b,*c; 
	int n;
	{ return;}
int size_rec(h) 
	struct header *h; 
	{ return 1;}
void skiprec(fd,nr,siz) 
	long nr;
	int siz;
	FILE *fd; 
	{ return;}
long statsiz(name) 
	char *name; 
	{ return 0L;}
int symsize(name)
	char *name;
	{ return 0;}
int symtype(s) char *s; 
	{ return 0;}
int typesiz(type)
	int type;
	{ return 0;}
void trange_switch(text, hd, startp, endp)
	char *text; struct header *hd; long *startp, *endp;
	{ return;}
int wr_array(arr,elt_siz,ar_siz,file) 
	char *file,*arr; 
	{ return 0;}
int wr_plot(arr,ar_siz,filnam) 
	double *arr; char *filnam; 
	{ return 0;}
int wrarray(arr,elt_siz,ar_siz,file) 
	char *file,*arr; 
	{ return 0;}
void write_header(h,fd) 
	struct header *h; FILE *fd; 
	{ return;}
int zerpolfil(x,n,p,z,size,state) 
	double *x,*p,*z,*state; 
	{ return 0;}
struct spec_data *allo_spec_rec(hd) 
	struct header *hd; 
	{return (struct spec_data *) NULL; }
int get_sd_type(hd) 
	struct header *hd; 
	{return 0;}
void set_sd_type(hd,type) 
	struct header *hd; short type; 
	{return;}
int get_sd_recsize(hd) 
	struct header *hd; 
	{return 0;}
int get_sd_recf(buf,ns,hd,file) 
	float *buf; int ns; struct header *hd; FILE *file; 
	{return 0;}
int get_sd_recd(buf,ns,hd,file) 
	double *buf; int ns; struct header *hd; FILE *file; 
	{return 0;}
int get_sd_recs(buf,ns,hd,file) 
	short *buf; int ns; struct header *hd; FILE *file; 
	{return 0;}
void put_sd_recf(buf,ns,hd,file) 
	float *buf; int ns; struct header *hd; FILE *file; 
	{return;}
void put_sd_recd(buf,ns,hd,file) 
	double *buf; int ns; struct header *hd; FILE *file; 
	{return;}
void put_sd_recs(buf,ns,hd,file) 
	short *buf; int ns; struct header *hd; FILE *file; 
	{return;}
int get_gen_recd(d,t,h,f) 
	double *d; long *t; struct header *h; FILE *f; 
	{return 0;}
int get_spec_rec(d,h,f) 
	struct spec_data *d; struct header *h; FILE *f; 
	{return 0;}
int idx_ok(i,a) 
	int i; char **a; 
	{return 0;}
int lin_search(a,t) 
	char *t, *a[]; 
	{return 0;}
int lin_search2(a,t) 
	char *t, *a[]; 
	{return 0;}
void print_spec_rec(d,h,f) 
	struct spec_data *d; struct header *h; FILE *f; 
	{return;}
void put_spec_rec(d,h,f) 
	struct spec_data *d; struct header *h; FILE *f; 
	{return;}
interp_filt (n, x, y, pzfunc, init_state, up, down, poutflag, preturn)
	int n, up, down, *poutflag, *preturn;
	float *x, *y, *init_state;
	struct zfunc *pzfunc;
	{return 0;}
block_filter(n,x,y,p,i) 
	int n; float *x,*y,*i; struct zfunc *p; 
	{return 0;}
struct filt_data *allo_filt_rec(h) 
	struct header *h; 
	{return (struct filt_data *)NULL;}
void set_filt_type(hd)
	struct header *hd;
	{return;}
get_filt_rec(r,h,f) 
	struct filt_data *r; struct header *h; FILE *f;
	{return 0;}
void put_filt_rec(r,h,f) 
	struct filt_data *r; struct header *h; FILE *f;
	{return;}
void print_filt_rec(r,h,f) 
	struct filt_data *r; struct header *h; FILE *f;
	{return;}
void set_scbk_type(hd) 
	struct header *hd; 
	{return;}
get_scbk_rec(r,h,f) 
	struct scbk_data *r; struct header *h; FILE *f;
	{return 0;}
void put_scbk_rec(r,h,f) 
	struct scbk_data *r; struct header *h; FILE *f;
	{return;}
void print_scbk_rec(r,h,f) 
	struct scbk_data *r; struct header *h; FILE *f;
	{return;}
struct scbk_data *allo_scbk_rec(h) 
	struct header *h; 
	{return (struct scbk_data *)NULL;}
int putsym_f(s,v) 
	char *s; float v; 
	{return 0;}
int putsym_i(s,v) 
	char *s; int v; 
	{return 0;}
int putsym_s(s,v) 
	char *s,*v; 
	{return 0;}
int rc_to_lar(rc,lar) 
	double rc; float *lar; 
	{return 0;}
float lar_to_rc(lar) 
	double lar; 
	{return 0;}
char **genhd_list(i,hd) 
	int *i; struct header *hd; 
	{return NULL;}
char **genhd_codes(name,hd) 
	char *name; struct header *hd; 
	{return NULL;}
int genhd_type(n,s,hd) 
	char *n; int *s; struct header *hd; 
	{return NULL;}
char *get_genhd(n,hd) 
	char *n; struct header *hd; 
	{return NULL;}
char **get_genhd_coded(n,hd)
	char *n; struct header *hd;
	{return NULL;}
char *add_genhd(n,t,s,p,q,hd) 
	char *n,*p; int t,s; char **q; struct header *hd; 
	{return NULL;}
double *add_genhd_d(n,p,s,h) 
	char *n; double *p; int s; struct header *h; 
	{return NULL;}
float *add_genhd_f(n,p,s,h) 
	char *n; float *p; int s; struct header *h; 
	{return NULL;}
long *add_genhd_l(n,p,s,h) 
	char *n; long *p; int s; struct header *h; 
	{return NULL;}
short *add_genhd_s(n,p,s,h) 
	char *n; short *p; int s; struct header *h; 
	{return NULL;}
short *add_genhd_e(n,p,s,q,h) 
	char *n; short *p; int s; char **q; struct header *h; 
	{return NULL;}
char *add_genhd_c(n,p,s,h) 
	char *n; char *p; int s; struct header *h; 
	{return NULL;}
double get_genhd_val(name, hd, def_val)
	char *name; struct header *hd; double def_val;
	{return 0.0;}
int add_fea_fld(n,s,r,d,t,c,h) 
	char *n,**c; long s,*d; short r,t; struct header *h; 
	{return 0;}
struct fea_data *allo_fea_rec(h) 
	struct header *h; 
	{return (struct fea_data *)NULL;}
char *get_fea_ptr(r,n,h) 
	struct fea_data *r; char *n; struct header *h; 
	{return (char *)NULL;}
void put_fea_rec(r,h,f) 
	struct fea_data *r; struct header *h; FILE *f; 
	{return;}
int get_fea_rec(r,h,f) 
	struct fea_data *r; struct header *h; FILE *f; 
	{return 0;}
void print_fea_rec(r,h,f) 
	struct fea_data *r; struct header *h; FILE *f; 
	{return;}
void print_fea_recf(r,h,f,l) 
	struct fea_data *r; struct header *h; FILE *f; char *l[];
	{return;}
long get_fea_siz(n,h,r,d) 
	char *n; struct header *h; short *r; long **d; 
	{return 0;}
void set_seg_lab(hd,f) 
	struct header *hd; char **f; 
	{return;}
short fea_encode(s,n,h) 
	char *s, *n; struct header *h; 
	{return 0;}
short fea_encode_ci(s,n,h) 
	char *s, *n; struct header *h; 
	{return 0;}
char *fea_decode(c,n,h) 
	short c; char *n; struct header *h; 
	{return (char *)NULL;}
void get_fft (x_real, x_imag, log_fft_size)
	float   x_real[], x_imag[];
	int     log_fft_size;
	{return;}
void get_rfft (real, imag, log_fft_size)
	float   real[], imag[];
	int     log_fft_size;
	{return;}
void get_fft_inv (x_real, x_imag, log_fft_size)
	float   x_real[], x_imag[];
	int     log_fft_size;
	{return;}
int init_anafea_hd(h,v,u,p,r,x,n,d) 
	struct header *h; long v,u,p,r,x; short n,d; 
	{return 0;}
struct anafea *allo_anafea_rec(h) 
	struct header *h; 
	{return NULL;}
void put_anafea_rec(r,h,f) 
	struct anafea *r; struct header *h; FILE *f; 
	{return;}
int get_anafea_rec(r,h,f) 
	struct anafea *r; struct header *h; FILE *f; 
	{return 0;}
short get_fea_type(n,h) 
	char *n; struct header *h; 
	{return 0;}
int refl_to_filter (rc, fc, n) 
	float *rc, *fc; int n; 
	{return 0;}
int refl_to_auto (rc, pfe, ac, n) 
	float *rc, pfe, *ac; int n; 
	{return 0;}
double is_dist_td (ac, ac_err, cw, cw_err, n) 
	float *ac, ac_err, *cw, cw_err; int n; 
	{return 0.0;}
double gnis_dist_td (ac, ac_err, cw, n) 
	float *ac, ac_err, *cw; int n; 
	{return 0.0;}
double gois_dist_td (ac, ac_err, cw, n) 
	float *ac, ac_err, *cw; int n; 
	{return 0.0;}
long get_rec_len(h) 
	struct header *h; 
	{return 0;}
long *grange_switch(s,i) 
	char *s; long *i; 
	{return 0;}
char *uniq_name(name,list) 
	char *name; char **list;
	{return NULL;}
int lsf_to_pc(lsf, pc, order, bandwidth)
	float pc[], bandwidth, lsf[];
	int  order;
	{return 0;}
int get_atal(r,order,c,rc,pgain) 
	double *r; float *c,*rc,*pgain; int order; 
	{return 0;}
int pc_to_lsf(afc, lsf, order, bwidth, frq_res)
	int order;
	float *afc, *lsf;
	float bwidth, frq_res;
	{return 0;}
int init_vqfea_hd(hd,r,c) 
	struct header *hd; long r,c;
	{return 0;}
struct vqcbk *allo_vqfea_rec(h) 
	struct header *h; 
	{return NULL;}
void put_vqfea_rec(cdbk,hd,strm) 
	struct vqcbk *cdbk; 
	struct header *hd; FILE *strm; 
	{return;}
int get_vqfea_rec(cdbk,hd,strm) 
	struct vqcbk *cdbk; struct header *hd; FILE *strm; 
	{return 0;}
int vqdesign(histrm, hdetail, data, len, dim, cbk, enc, init, split_crit, 
 get_chunk, vec_to_cdwd, distort, split, checkpoint, max_iter)
	FILE		*histrm;
	int		hdetail;
	float		**data;
	long		len;
	long		dim;
	struct vqcbk	*cbk;	
	long		*enc;
	int		init;	
	int		split_crit;
	long		(*get_chunk)();
	int		(*vec_to_cdwd)();
	double		(*distort)();
	int		(*split)();
	int		(*checkpoint)();
	int		max_iter;
	{return 0;}
long findmax_f(v,n) 
	float *v; long n; 
	{return 0;}
void vec_add_f(v1,v2,size) 
	float *v1,*v2; long size; 
	{return;}
long vqencode(fea, fea_dim, codebook, cbk_size, cbk_dim, 
	dist_val, distort, dist_err)
	float *fea; long fea_dim; float	**codebook; long cbk_size;
	long cbk_dim; double *dist_val; double	(*distort)(); int *dist_err;
	{return 0;}
int pz_to_co(nr,real,imag,pnco,co) 
	int nr; double *real,*imag; short *pnco; float *co; 
	{return 0;}
int init_feastat_hd (hd, statfield, statsize, class_type, covar, 
	invcovar, eigen)
	struct	header	*hd; char *statfield; long statsize;
	char	**class_type; short covar, invcovar, eigen; 
	{return 0;}
struct feastat * allo_feastat_rec (hd) 
	struct header *hd; 
	{return NULL;}
void put_feastat_rec (stat_rec, hd, file)
	struct feastat  *stat_rec; struct header   *hd; FILE *file;
	{return;}
int get_feastat_rec (stat_rec, hd, file)
	struct feastat  *stat_rec; struct header   *hd; FILE *file;
	{return 0;}
void add_genzfunc(name, f, hd)
	char *name; struct zfunc *f; struct header *hd;
	{return;}
struct zfunc *get_genzfunc(name,hd)
	char *name; struct header *hd;
	{return NULL;}
int copy_fea_fld(h1,h2,name)
	struct header *h1, *h2; char *name;
	{return 0;}
float gauss()
	{return 0;}
int getsym_fa(name,array,maxval)
	char *name;
	float array[];
	int maxval;
	{return 0;}
int pef_autorc(order,pef,r,c)
	int order;
	double pef[], r[], c[];
	{return 0;}
int auto_pefrc(order,r,pef,c)
	int order;
	double r[], pef[], c[];
	{return 0;}
int rc_autopef(order,c,r,pef)
	int order;
	double c[], r[], pef[];
	{return 0;}
float *atoarrayf(strm,nval,max)
	FILE *strm;
	long *nval;
	float *max;
	{return (float *)NULL;}
char * atoarray(strm, type, nvalues, max)
	FILE    *strm;
	int     type;
	long    *nvalues;
	double  *max;
	{return (char *)NULL;}
double matrix_inv(matin, inv_out, size)
	float *matin[], *inv_out[];
	int size;
	{return 0;}
int set_fea_deriv (name, srcfield, hd)
	char   *name;
	char  **srcfield;
	struct header  *hd;
	{return 0;}
char  ** get_fea_deriv (name, hd)
	char   *name;
	struct header  *hd;
	{return (char **)NULL;}
char * get_deriv_vec (fields, fea_rec, hd, type, length, vec)
	char		    **fields;
	struct fea_data	    *fea_rec;
	struct header	    *hd;
	int		    type;
	long		    *length;