fe.c

CMU大名鼎鼎的SPHINX－3大词汇量连续语音识别系统

            }
        
            close(fp_in);
            
        }
        else{
                fprintf(stderr,"fe_start_utt() failed\n");
                exit(-1);
        }
        
    }
    else{
                fprintf(stderr,"Unknown mode - single or batch?\n");
                exit(-1);
    }
       
    ckd_free(infile);


    *splenp = splen; 
    *nframesp = nframes;   
    
    return(spdata);
}


void fe_validate_parameters(param_t *P) 
{
    
    if ((P->is_batch) && (P->is_single)) {
        E_FATAL("You cannot define an input file and a control file\n");
    }
    
    if (P->wavfile == NULL && P->wavdir == NULL){
        E_FATAL("No input file or file directory given\n");
    }
    
    if (P->cepfile == NULL && P->cepdir == NULL){
        E_FATAL("No cepstra file or file directory given\n");
    }
    
    if (P->ctlfile==NULL && P->cepfile==NULL && P->wavfile==NULL){
        E_FATAL("No control file given\n");
    }
    
    if (P->nchans>1){
        E_INFO("Files have %d channels of data\n", P->nchans);
        E_INFO("Will extract features for channel %d\n", P->whichchan);
    }
    
    if (P->whichchan > P->nchans) {
        E_FATAL("You cannot select channel %d out of %d\n", P->whichchan, P->nchans);
    }
    
    if ((P->UPPER_FILT_FREQ * 2) > P->SAMPLING_RATE) {
        E_WARN("Upper frequency higher than Nyquist frequency");
    }
    
    if (P->doublebw==ON) {
        E_INFO("Will use double bandwidth filters\n");
    }
}


param_t *fe_parse_options() 
{
    param_t *P;
    int32 format;
    char *endian;
    
    if ((P=(param_t *)malloc(sizeof(param_t)))==NULL){
        E_FATAL("memory alloc failed in fe_parse_options()\n...exiting\n");
    }
    
    fe_init_params(P);
    
    P->wavfile = cmd_ln_str("-i");
    if (P->wavfile != NULL) {
        P->is_single = ON;
    }
    
    P->cepfile = cmd_ln_str("-o");
    
    P->ctlfile = cmd_ln_str("-c");
    if (P->ctlfile != NULL) {
        P->is_batch = ON;
    }
    
    P->wavdir = cmd_ln_str("-di");
    P->cepdir = cmd_ln_str("-do");
    P->wavext = cmd_ln_str("-ei");
    P->cepext = cmd_ln_str("-eo");
    format = cmd_ln_int32("-raw");
    if (format) {
        P->input_format = RAW;
    }
    format = cmd_ln_int32("-nist");
    if (format) {
        P->input_format = NIST;
    } 
    format = cmd_ln_int32("-mswav");
    if (format) {
        P->input_format = MSWAV;
    }
    
    P->nchans = cmd_ln_int32("-nchans");
    P->whichchan = cmd_ln_int32("-whichchan");
    P->PRE_EMPHASIS_ALPHA = cmd_ln_float32("-alpha");
    P->SAMPLING_RATE = cmd_ln_float32("-srate");
    P->WINDOW_LENGTH = cmd_ln_float32("-wlen");
    P->FRAME_RATE = cmd_ln_int32("-frate");
    if (!strcmp(cmd_ln_str("-feat"), "sphinx")) 
    {
        P->FB_TYPE = MEL_SCALE;
        P->output_endian = BIG;
    } 
    else 
    {
        E_ERROR("MEL_SCALE IS CURRENTLY THE ONLY IMPLEMENTATION\n\n");
        E_FATAL("Make sure you specify '-feat sphinx'\n");
    }	
    P->NUM_FILTERS = cmd_ln_int32("-nfilt");
    P->NUM_CEPSTRA = cmd_ln_int32("-ncep");
    P->LOWER_FILT_FREQ = cmd_ln_float32("-lowerf");
    P->UPPER_FILT_FREQ = cmd_ln_float32("-upperf");
    P->FFT_SIZE = cmd_ln_int32("-nfft");
    if (cmd_ln_int32("-doublebw")) {
        P->doublebw = ON; 
    } else {
        P->doublebw = OFF;
    }
    P->blocksize = cmd_ln_int32("-blocksize");
    P->verbose = cmd_ln_int32("-verbose");
    endian = cmd_ln_str("-mach_endian");
    if (!strcmp("big", endian)) {
        P->machine_endian = BIG;
    } else {
        if (!strcmp("little", endian)) {
            P->machine_endian = LITTLE;
        } else {
            E_FATAL("Machine must be big or little Endian\n");
        }	
    }
    endian = cmd_ln_str("-input_endian");
    if (!strcmp("big", endian)) {
        P->input_endian = BIG;
    } else {
        if (!strcmp("little", endian)) {
            P->input_endian = LITTLE;
        } else {
            E_FATAL("Input must be big or little Endian\n");
        }	
    }
    P->dither = cmd_ln_int32("-dither");
    P->logspec = cmd_ln_int32("-logspec");
    
    if(P->dither){
      fe_init_dither(*(int32 *)cmd_ln_access("-seed"));
    }

    fe_validate_parameters(P);
    
    return (P);
    
}


void fe_init_params(param_t *P)
{
    P->FB_TYPE = DEFAULT_FB_TYPE;
    P->is_batch = OFF;
    P->is_single = OFF;
    P->wavfile = NULL;
    P->cepfile = NULL;
    P->ctlfile = NULL;
    P->wavdir = NULL;
    P->cepdir = NULL;
    P->wavext = NULL;
    P->cepext = NULL;
    
    
}


int32 fe_build_filenames(param_t *P, char *fileroot, char **infilename, char **outfilename)
{
    char cbuf[MAXCHARS];
    char chanlabel[MAXCHARS];
    
    if (P->nchans>1)
        sprintf(chanlabel, ".ch%d", P->whichchan);
    
    if (P->is_batch){
        sprintf(cbuf,"%s","");
        strcat(cbuf,P->wavdir);
        strcat(cbuf,"/");
        strcat(cbuf,fileroot);
        strcat(cbuf,".");
        strcat(cbuf,P->wavext);
	if (infilename != NULL) {
	  *infilename = fe_copystr(*infilename,cbuf);
	}
        
        sprintf(cbuf,"%s","");
        strcat(cbuf,P->cepdir);
        strcat(cbuf,"/");
        strcat(cbuf,fileroot);
        if (P->nchans>1)
            strcat(cbuf, chanlabel);
        strcat(cbuf,".");
        strcat(cbuf,P->cepext);
	if (outfilename != NULL) {
	  *outfilename = fe_copystr(*outfilename,cbuf);	
	}
    }
    else if (P->is_single){
        sprintf(cbuf,"%s","");
        strcat(cbuf,P->wavfile);
	if (infilename != NULL) {
	  *infilename = fe_copystr(*infilename,cbuf);
	}
        
        sprintf(cbuf,"%s","");
        strcat(cbuf,P->cepfile);
	if (outfilename != NULL) {
	  *outfilename = fe_copystr(*outfilename,cbuf);
	}
    }
    else{
        E_FATAL("Unspecified Batch or Single Mode\n");
    }
    
    return 0;
}


char *fe_copystr(char *dest_str, char *src_str)
{
    int i,src_len, len;
    char *s;
    
    src_len = strlen(src_str);
    len = src_len;
    s = (char *)malloc(len+1);
    for (i=0;i<src_len;i++)
	*(s+i) = *(src_str+i);
    *(s+src_len) = NULL_CHAR;
    
    return(s);
}

int32 fe_count_frames(fe_t *FE, int32 nsamps, int32 count_partial_frames)
{
    int32 frame_start,frame_count = 0;
    
    for (frame_start=0;frame_start+FE->FRAME_SIZE<=nsamps;
    frame_start+=FE->FRAME_SHIFT)
        frame_count++;
   
    if (count_partial_frames){
	if ((frame_count-1)*FE->FRAME_SHIFT+FE->FRAME_SIZE < nsamps)
	    frame_count++;
    }
    
    return(frame_count);
}


/* Temporary hack. This will duplicate some code, but allow wave2feat and main_ep.c coexists in the same codebase. */	
int32 ep_fe_openfiles(param_t *P, fe_t *FE, char *infile, int32 *fp_in, int32 *nsamps, 
                   int32 *nframes, int32 *nblocks)
{
    struct stat filestats;
    int fp=0, len=0, numframes, numblocks;
    FILE *fp2;
    char line[MAXCHARS];
    int got_it=0;

    /* Note: this is kind of a hack to read the byte format from the
       NIST header */
    if (P->input_format == NIST){
        if ((fp2 = fopen(infile,"rb")) == NULL){
            fprintf(stderr,"Cannot read %s\n",infile);
            return(FE_INPUT_FILE_READ_ERROR);
        }
        *line=0;
        got_it = 0;
        while(strcmp(line,"end_head") && !got_it){
            fscanf(fp2,"%s",line);
            if (!strcmp(line,"sample_byte_format")){
                fscanf(fp2,"%s",line);
                if (!strcmp(line,"-s2")){
                    fscanf(fp2,"%s",line);
                    if (!strcmp(line,"01")){
                        P->input_endian=LITTLE;
                        got_it=1;
                    }
                    else if(!strcmp(line,"10")){
                        P->input_endian=BIG;
                        got_it = 1;
                    }
                    else
                        fprintf(stderr,"Unknown/unsupported byte order\n");     
                }
                else 
                    fprintf(stderr,"Error determining byte format\n");
            }
        }
        if (!got_it){
            fprintf(stderr,"Can't find byte format in header, setting to machine's endian\n");
            P->input_endian = P->machine_endian;
        }           
        fclose(fp2);
    }
       else if (P->input_format == RAW){
      /*
        P->input_endian = P->machine_endian;
      */
    }
    else if (P->input_format == MSWAV){
        P->input_endian = LITTLE; // Default for MS WAV riff files
    }
    
    
    if ((fp = open(infile, O_RDONLY | O_BINARY, 0644))<0){
        fprintf(stderr,"Cannot open %s\n",infile);
        return (FE_INPUT_FILE_OPEN_ERROR);
    }
    else{
        if (fstat(fp,&filestats)!=0) printf("fstat failed\n");
        
        if (P->input_format == NIST){
            short *hdr_buf;

            len = (filestats.st_size-HEADER_BYTES)/sizeof(short);
            /* eat header */
            hdr_buf = (short *)calloc(HEADER_BYTES/sizeof(short),sizeof(short));
            if (read(fp,hdr_buf,HEADER_BYTES)!=HEADER_BYTES){
                fprintf(stderr,"Cannot read %s\n",infile);
                return (FE_INPUT_FILE_READ_ERROR);
            }
            free(hdr_buf);    
        }
        else if (P->input_format == RAW){
            len = filestats.st_size/sizeof(int16);
        }
        else if (P->input_format == MSWAV){
            /* Read the header */
            MSWAV_hdr *hdr_buf;
            if ((hdr_buf = (MSWAV_hdr*) calloc(1,sizeof(MSWAV_hdr))) == NULL){
                fprintf(stderr,"Cannot allocate for input file header\n");
                return (FE_INPUT_FILE_READ_ERROR);
            }
            if (read(fp,hdr_buf,sizeof(MSWAV_hdr)) != sizeof(MSWAV_hdr)){
                fprintf(stderr,"Cannot allocate for input file header\n");
                return (FE_INPUT_FILE_READ_ERROR);
            }
            /* Check header */
            if (strncmp(hdr_buf->rifftag,"RIFF",4)!=0 ||
                strncmp(hdr_buf->wavefmttag,"WAVEfmt",7)!=0) {
             fprintf(stderr,"Error in mswav file header\n");
                return (FE_INPUT_FILE_READ_ERROR);
            }
            if (strncmp(hdr_buf->datatag,"data",4)!=0) {
              /* In this case, there are other "chunks" before the
               * data chunk, which we can ignore. We have to find the
               * start of the data chunk, which begins with the string
               * "data".
               */
              int16 found=OFF;
              char readChar;
              char *dataString = "data";
              int16 charPointer = 0;
              printf("LENGTH: %d\n", strlen(dataString));
              while (found != ON) {
                if (read(fp,&readChar,sizeof(char)) != sizeof(char)){
                  fprintf(stderr,"Failed reading wav file.\n");
                  return (FE_INPUT_FILE_READ_ERROR);
                }
                if (readChar == dataString[charPointer]) {
                  charPointer++;
                }
                if (charPointer == (int16)strlen(dataString)) {
                  found = ON;
                  strcpy(hdr_buf->datatag, dataString);
                  if (read(fp,&(hdr_buf->datalength),sizeof(int32)) != sizeof(int32)){
                    fprintf(stderr,"Failed reading wav file.\n");
                    return (FE_INPUT_FILE_READ_ERROR);
                  }
                }
              }
            }
            if (P->input_endian!=P->machine_endian) { // If machine is Big Endian
                hdr_buf->datalength = SWAPL(&(hdr_buf->datalength));
                hdr_buf->data_format = SWAPW(&(hdr_buf->data_format));
                hdr_buf->numchannels = SWAPW(&(hdr_buf->numchannels));
                hdr_buf->BitsPerSample = SWAPW(&(hdr_buf->BitsPerSample));