llib-lespsg.c

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

	char		    *vec;
	{return (char *)NULL;}
int rc_reps(rc, output, output_type, size, bwidth, frq_res)
	float *rc, *output; 
	int output_type; 
	float bwidth, frq_res; 
	int size; 
	{return 0;}
int reps_rc(input, input_type, rc, size, bwidth)
	float *input, *rc;
	float bwidth;
	int input_type;
	int size;
	{return 0;}
void get_fftd (x_real, x_imag, log_fft_size)	
	double x_real[], x_imag[];
	int     log_fft_size;
	{return;}
void set_spec_type(hd)
	struct header *hd;
	{return;}
get_burg (x, lnt, r, order, c, rc, pgain, method)
	float   x[], c[], rc[], *pgain;
	double  r[];
	int     order, lnt;
	char    method;
	{return 0;}
int afc2cep(afc, cep, order)
	int order;
	float *afc, *cep;
	{return 0;}
int cep2afc(cep, afc, order)
	int order;
	float *cep, *afc;
	{return 0;}
int classify(feavec, nfea, nclas, means, invcovars, priors, posteriors)
	float   *feavec;
	int	    nfea, nclas;
	float   **means;
	float   ***invcovars;
	float   *priors;
	float   *posteriors;
	{ return 0; }
COMPLEX cadd(x, y)
	COMPLEX x,y;
	{return x;}
COMPLEX csub(x, y)
	COMPLEX x,y;
	{return x;}
COMPLEX conj(x)
	COMPLEX x;
	{return x;}
COMPLEX cmult(x, y)
	COMPLEX x, y;
	{return x;}
COMPLEX realmult(x, y)
	COMPLEX x;
	double y;
	{return x;}
double modul(x)
	COMPLEX x;
	{return 0;}
COMPLEX cdiv(x, y)
	COMPLEX x,y;
	{return x;}
COMPLEX cmultacc(x, y, r)
	COMPLEX x, y, r;
	{return x;}
int convolv (a, a_siz, b, b_siz, c, c_siz)
	double *a, *b, *c;
	int     a_siz, b_siz;
	int    *c_siz;
	{return 0;}
auto_convolv (a, a_siz, b, b_siz, c, c_siz)
	double *a, *b, *c;
	int     a_siz, b_siz;
	int    *c_siz;
	{return 0;}
void copy_fea_rec(irec, ihd, orec, ohd, fields, trans)
	struct fea_data *irec;
	struct header   *ihd;
	struct fea_data *orec;
	struct header   *ohd;
	char    **fields;
	short   **trans;
	{return;}
int covar (data, lnt, c, order, grc, pgain, window_flag)
	float   data[], c[], grc[], *pgain;
	int     lnt, order, window_flag;
	{return 0;}
double determ(mat, order)
	float **mat;
	int order;
	{return 0;}
char *eopen(prog_name, file_name, mode, type, subtype, header, stream)
	char    *prog_name, *file_name, *mode;
	int	    type, subtype;
	struct header   **header;
	FILE    **stream;
	{return (char *)NULL;}
int get_arspect (c, order, res_power, samp_freq, y)
	int     order, samp_freq;
	float   c[], res_power, y[];
	{return 0;}
int get_auto(x, lnt, r, order)
	float x[];
	double r[];
	int lnt,order;
	{return 0;}
char *get_cmd_line(argc,argv) 
	int argc; 
	char **argv; 
	{return (char *)NULL; }
int get_dct(in, out, N)
	float in[], out[];
	int N;
	{return 0;}
int dct(x, X, N)
	int N;
	float x[], X[];
	{return 0;}
int idct(X, x, N)
	short N;
	float x[], X[];
	{return 0;}
int hamm_enc(data, code)
	int data;
	short *code;
	{return 0;}
int hamm_dec(data, code)
	int code;
	short *data;
	{return 0;}
int lloyd (data, n, cbk, ncbk_desired, convergence, hstrm, final_dist, cbk_dist, pop)
	double *data;
	long n;		
	double *cbk;
	unsigned ncbk_desired;
	double convergence;
	FILE *hstrm;	
	double *final_dist;	
	double *cbk_dist;
	long *pop;
	{return 0;}
long rand_int(max_int)
	long max_int;
	{return 0;}
long rand_intnr(max_int, reset)
	long max_int;
	int reset;
	{return 0;}
void rc2cep(input, output, size)
	float *input, *output;
	int size;
	{return;}
void rc2lar(input, output, size)
	float *input, *output;
	int size;
	{return;}
void rc2afc(input, output, size)
	float *input, *output;
	int size;
	{return;}
void rc2lsf(input, output, size, bwidth, frq_res)
	float *input, *output;
	int size;
	float bwidth, frq_res;
	{return;}
void rc2auto(input, output, size)
	float *input, *output;
	int size;
	{return;}
long long_reverse(in)
	long in;
	{return 0;}
short short_reverse(in)
	short in;
	{return 0;}
int sizetype(type)
	char type;
	{return 0;}
void rctoc(rc,order,c,pgain)
	float rc[],c[],*pgain;
	int order;
	{return;}
char *marg_index(arr, rk, dim, typ, lvl)
	char *arr; int rk; long *dim; int typ, lvl;
	{return arr;}
char *arr_alloc(rk, dim, typ, lvl)
	int rk; long *dim; int typ, lvl;
	{return "";}
void arr_free(arr, rk, typ, lvl)
	char *arr; int rk, typ, lvl;
	{return;}
#if defined(M5500) || defined(M5600)
char *index(s,c)
	char *s, c;
	{return (char *)NULL;}
#endif
int get_sd_orecd(framebuf, framelen, nmove, first, hd, file)
	double *framebuf;
	int framelen, nmove, first;
	struct header *hd;
	FILE *file;
	{return 0;}
int get_sd_orecf(framebuf, framelen, nmove, first, hd, file)
	float *framebuf;
	int framelen, nmove, first;
	struct header *hd;
	FILE *file;
	{return 0;}
int get_sd_orecs(framebuf, framelen, nmove, first, hd, file)
	short *framebuf;
	int framelen, nmove, first;
	struct header *hd;
	FILE *file;
	{return 0;}
char *get_genhd_c(name,h)
	char *name;
	struct header *h;
	{return NULL;}
short *get_genhd_s(name,h)
	char *name;
	struct header *h;
	{return NULL;}
long *get_genhd_l(name,h)
	char *name;
	struct header *h;
	{return NULL;}
float *get_genhd_f(name,h)
	char *name;
	struct header *h;
	{return NULL;}
double *get_genhd_d(name,h)
	char *name;
	struct header *h;
	{return NULL;}
short *malloc_s(n)
	unsigned n;
	{return NULL;}
int *malloc_i(n)
	unsigned n;
	{return NULL;}
long *malloc_l(n)
	unsigned n;
	{return NULL;}
float *malloc_f(n)
	unsigned n;
	{return NULL;}
double *malloc_d(n)
	unsigned n;
	{return NULL;}
short *calloc_s(n)
	unsigned n;
	{return NULL;}
int *calloc_i(n)
	unsigned n;
	{return NULL;}
long *calloc_l(n)
	unsigned n;
	{return NULL;}
float *calloc_f(n)
	unsigned n;
	{return NULL;}
double *calloc_d(n)
	unsigned n;
	{return NULL;}
void CANTOPEN(prog, file)
	char *prog, *file;
	{return;}
void USAGE(text)
	char *text;
	{return;}
void NOTSPS(prog, bfile)
	char *prog, *bfile;
	{return;}
int BOOL(arg)
	int arg;
	{return 0;}
int window(n, x, y, type, p)
	long n;
	float *x, *y;
	int type;
	double *p;
	{return 0;}
int windowd(n, x, y, type, p)
	long n;
	double *x, *y;
	int type;
	double *p;
	{return 0;}
void copy_fea_fields(dest, src)
	struct header *dest, *src;
	{return;}

COMPLEX csqrt(x)
	COMPLEX x;
	{COMPLEX y; return(y);}

void addstr(str, arr)
	char *str;
	char ***arr;
	{return;}

long *fld_range_switch(text, name, array_len, hd)
	char *text;
	char **name;
	long *array_len;
	struct header*hd;
	{return (long *)NULL;}

long get_fea_element(name, hd)
	char *name;
	struct header *hd;
	{return 0;}

int stsolv(r, v, order, w)
    double  *r, *v;
    int	    order;
    double  *w;
    {return 0;}

int copy_genhd(dest, src, name)
    struct header *dest;
    struct header *src;
    char *name;
    {return 0;}

FILE *get_genhd_afile(name, hd)
    char *name;
    struct header *hd;
    {return (FILE *)NULL;}

struct header *get_genhd_efile(name, hd)
     char *name;
     struct header *hd;
     {return (struct header *)NULL;}

char *get_genhd_efile_name(name, hd)
     char *name;
     struct header *hd;
     {return NULL;}

char *get_genhd_afile_name(name, hd)
     char *name;
     struct header *hd;
     {return NULL;}

char *add_genhd_efile(item_name, file_name, hd)
     char *item_name, *file_name;
     struct header *hd;
     {return NULL;}

char *add_genhd_afile(item_name, file_name, hd)
     char *item_name, *file_name;
     struct header *hd;
     {return NULL;}

void update_waves_gen(ih, oh, start, step)
     struct header *ih, *oh;
     float start, step;
     {return;}

int lsq_solv2(a, b, m, n, p, x, eps)
    double  **a, **b;
    int	    m, n, p;
    double  **x, eps;
    {return 0;}


int lsq_solv(a, b, m, n, x, eps)
    double  **a, *b;
    int	    m, n;
    double  *x, eps;
    {return 0;}

int moore_pen(a, m, n, x, eps)
    double  **a;
    int	    m, n;
    double  **x, eps;
    {return 0;}

int init_feaspec_hd(hd, def_tot_power, freq_format, spec_type,
		contin, num_freqs, frame_meth, freqs, sf, frmlen, 
		re_spec_format)
    struct header   *hd;	
    int		    def_tot_power;
    int		    freq_format; 
    int		    spec_type;	
    int		    contin;
    long	    num_freqs;	
    int		    frame_meth;	
    float	    *freqs;
    double	    sf;	
    long	    frmlen;	
    int	    	    re_spec_format;
    {return 0;}

struct feaspec * allo_feaspec_rec(hd, re_spec_format)
    struct header   *hd;
    int	    	    re_spec_format;
    {return (struct feaspec *) NULL;}

long put_feaspec_rec(spec_rec, hd, file)
    struct feaspec  *spec_rec;
    struct header   *hd;
    FILE            *file;
    {return 0;}

long get_feaspec_rec(spec_rec, hd, file)
    struct feaspec  *spec_rec;
    struct header   *hd;
    FILE            *file;
    {return 0;}

void print_feaspec_rec(rec, hd, file)
    struct feaspec *rec;
    struct header *hd;
    FILE *file;
    {return;}

char **get_feaspec_xfields(hd)
	struct header *hd;
	{return (char **)NULL;}


char	*spfmt_names[1];
char	*sptyp_names[1];
char	*spfrm_names[1];

void inhibit_hdr_date()
	{return;}

int copy_genhd_uniq (dest, src, name)
	struct header  *dest, *src;
	char *name;
	{return 0;}


int miio_get_double(ptr, size, edr_flag, machine, fd)
	double *ptr;
	int size, edr_flag, machine;
	FILE *fd;
	{return 0;}

int miio_get_float(ptr, size, edr_flag, machine, fd)
	float *ptr;
	int size, edr_flag, machine;
	FILE *fd;
	{return 0;}

int miio_get_long(ptr, size, edr_flag, machine, fd)
	long *ptr;
	int size, edr_flag, machine;
	FILE *fd;
	{return 0;}

int miio_get_int(ptr, size, edr_flag, machine, fd)
	int *ptr;
	int size, edr_flag, machine;
	FILE *fd;
	{return 0;}

int miio_get_short(ptr, size, edr_flag, machine, fd)
	short *ptr;
	int size, edr_flag, machine;
	FILE *fd;
	{return 0;}

int miio_get_char(ptr, size, edr_flag, machine, fd)
	char *ptr;
	int size, edr_flag, machine;
	FILE *fd;
	{return 0;}

int miio_get_byte(ptr, size, edr_flag, machine, fd)
	char *ptr;
	int size, edr_flag;
	FILE *fd;
	{return 0;}

int miio_put_double(ptr, size, edr_flag, fd)
	double *ptr;
	int size, edr_flag;
	FILE *fd;
	{return 0;}

int miio_put_float(ptr, size, edr_flag, fd)
	float *ptr;
	int size, edr_flag;
	FILE *fd;
	{return 0;}

int miio_put_int(ptr, size, edr_flag, fd)
	int *ptr;
	int size, edr_flag;
	FILE *fd;
	{return 0;}

int miio_put_short(ptr, size, edr_flag, fd)
	short *ptr;
	int size, edr_flag;
	FILE *fd;
	{return 0;}

int miio_put_long(ptr, size, edr_flag, fd)
	long *ptr;
	int size, edr_flag;
	FILE *fd;
	{return 0;}

int miio_put_char(ptr, size, edr_flag, fd)
	char *ptr;
	int size, edr_flag;
	FILE *fd;
	{return 0;}

int miio_put_byte(ptr, size, edr_flag, fd)
	char *ptr;
	int size, edr_flag;
	FILE *fd;
	{return 0;}

void free_fea_rec(rec)
	struct fea_data *rec;
	{return;}

int miio_get_dcplx(ptr, n, flag, mach, fp)
	double_cplx *ptr;
	int n;
	int flag;
	int mach;
	FILE *fp;
	{return 0;}

int miio_get_fcplx(ptr, n, flag, mach, fp)
	float_cplx *ptr;
	int n;
	int flag;
	int mach;
	FILE *fp;
	{return 0;}

int miio_get_lcplx(ptr, n, flag, mach, fp)
	long_cplx *ptr;
	int n;
	int flag;
	int mach;
	FILE *fp;
	{return 0;}

int miio_get_scplx(ptr, n, flag, mach, fp)
	short_cplx *ptr;
	int n;
	int flag;
	int mach;
	FILE *fp;
	{return 0;}

int miio_get_bcplx(ptr, n, flag, mach, fp)
	byte_cplx *ptr;
	int n;
	int flag;
	int mach;
	FILE *fp;
	{return 0;}

int miio_put_dcplx(ptr, n, flag, fp)
	double_cplx *ptr;
	int n;
	int flag;
	FILE *fp;
	{return 0;}