acf.c

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

    }
    if ( last == LONG_MAX || nan == 0 ) {
	last = ihd->common.ndrec;
	REQUIRE(last != -1,
		"Must specify endpoint when input is a pipe or has variable record length.");
	nan = last - start + 1;
    }
    REQUIRE(start >= 1, "can't start before beginning of input file");
    REQUIRE(last >= start, "empty range specified for input file");

    if (symtype("frame_len") == ST_UNDEF) 
	frame_len = 0;
    else 
      frame_len = (units==0) ?
	(long) getsym_d("frame_len") : (long) (getsym_d("frame_len")*src_sf);

    if (frame_len == 0) {
	frame_len = nan;
	if (debug_level>1) 
	  Fprintf(stderr, "%s: frame_len changed from 0 to %ld\n", PROG, frame_len);
    }

    if (symtype("step") != ST_UNDEF && getsym_d("step") != 0.0)
      step = (units==0) ? 
	(long) getsym_d("step") : (long)(getsym_d("step")*src_sf);
    else
      step = frame_len;

    n_frames =
      (nan == 0) ? 0
	: (nan <= frame_len) ? 1
	  : 2 + (nan - frame_len - 1) / step;
    
    if (n_frames > 0 && (n_frames - 1) * step + frame_len > nan)
	Fprintf(stderr,
	    "%s: WARNING - last frame will exceed specified range.\n",
	    PROG);

    window_type = (symtype("window_type") != ST_UNDEF) ? 
	getsym_s("window_type") : "RECT";

    pref_w_type =
	malloc((unsigned)(strlen(WT_PREFIX) + strlen(window_type) + 1));
    REQUIRE(pref_w_type, "can't allocate space for window type name");
    (void) strcpy(pref_w_type, WT_PREFIX);
    (void) strcat(pref_w_type, window_type);
    win = lin_search(window_types, pref_w_type);
    if (win <= 0) {
      Fprintf(stderr, "acf: window type not recognized, using RECT");
      win = WT_RECT;
    }

    /* get processing parameters from params file */
    sd_flag = GPFLAGSET("sd_flag") ? 1 : 0;
    if (sd_flag) 
	sd_fname = GPSTRING("sd_fname", "sd");
    
    p_flag = GPFLAGSET("pwr_flag") ? 1 : 0;
    if (p_flag)
	p_fname = GPSTRING("pwr_fname", "power");

    zc_flag = GPFLAGSET("zc_flag") ? 1 : 0;
    if (zc_flag)
	zc_fname = GPSTRING("zc_fname", "zero_crossing");

    ac_flag = GPFLAGSET("ac_flag") ? 1 : 0;
    if (ac_flag) {
      ac_yes = 1;
      ac_fname = GPSTRING("ac_fname", "auto_corr");
    }
    
    rc_flag = GPFLAGSET("rc_flag") ? 1 : 0;
    if (rc_flag) {
      ac_yes = rc_lpc_yes = 1;
      rc_fname = GPSTRING("rc_fname", "refcof");
    }

    lsf_flag = GPFLAGSET("lsf_flag") ? 1 : 0;
    if (lsf_flag) {
      ac_yes = rc_lpc_yes = 1;
      lsf_fname = GPSTRING("lsf_fname", "line_spec_freq");
    }

    lar_flag = GPFLAGSET("lar_flag") ? 1 : 0;
    if (lar_flag) {
      ac_yes = rc_lpc_yes = 1;
      lar_fname = GPSTRING("lar_fname", "log_area_ratio");
    }

    lpc_flag = GPFLAGSET("lpc_flag") ? 1 : 0;
    if (lpc_flag) {
      ac_yes = rc_lpc_yes = 1;
      lpc_fname = GPSTRING("lpc_fname", "lpc_coeffs");
    }
	
    fft_flag = GPFLAGSET("fft_flag") ? 1 : 0;

    lpccep_flag = GPFLAGSET("lpccep_flag") ? 1 : 0;
    if (lpccep_flag) {
      ac_yes = rc_lpc_yes = 1;
      lpccep_fname = GPSTRING("lpccep_fname", "lpc_cepstrum");
    }

    fftcep_flag = GPFLAGSET("fftcep_flag") ? 1 : 0;
    if (fftcep_flag) {
      fftcep_fname = GPSTRING("fftcep_fname", "fft_cepstrum");
    }

    /* get compute params */
    if (ac_yes) {
      if (symtype("ac_order") != ST_UNDEF)
	ac_order = getsym_i("ac_order");
      else {
	Fprintf(stderr,"%s: ac_order undefined in parameter file.\n", PROG);
	exit(1);
      }
      if (ac_order <= 0)
	Fprintf(stderr,"%s: WARNING! Value of 0 or less found for auto corr order.\n", PROG);
    }
    if (lpccep_flag) {
      if (symtype("lpccep_order") == ST_UNDEF)
	  lpccep_order = ac_order;
      else
	  lpccep_order = getsym_i("lpccep_order");
      spsassert(ac_order!=0 || lpccep_order!=0, "both ac_order and lpccep_order are 0.");
	  
      if (lpccep_order < ac_order) {
	Fprintf(stderr, "%s: setting lpc cepstrum order to auto corr order.\n", PROG);
	lpccep_order = ac_order;
      }

      if (ac_order==0) {
	Fprintf(stderr, "%s: ac_order is zero - setting it to lpccep_order (%d).\n", 
		PROG, lpccep_order);
	ac_order = lpccep_order;
      }

      if (symtype("lpccep_deriv")!=ST_UNDEF) {
	  lpccep_range = getsym_s("lpccep_deriv");
	  if ( strlen(lpccep_range) ) { 
	      lpccep_index = grange_switch( lpccep_range, &j);
	      if ( lpccep_index != NULL ) {
		  for (k=0; k<j; k++)
		      spsassert(lpccep_index[k] >= 0 && lpccep_index[k] < lpccep_order, 
				"invalid subrange of lpc_cepstrum elements specified by lpccep_deriv.");
		  lpccep_deriv_flag = 1;
		  lpccep_field_len = j;
	      } 
	  }
      }
      if ( !lpccep_deriv_flag ) {
	  lpccep_range = malloc(15);
	  lpccep_field_len = lpccep_order;
	  Sprintf( lpccep_range, "0:%d", lpccep_order-1);
      }

    }
    if (lsf_flag) 
      if (symtype("lsf_freq_res")!=ST_UNDEF)
	lsf_freq_res = (float) getsym_d("lsf_freq_res");
    if (fftcep_flag) {
      if (symtype("fftcep_order")!=ST_UNDEF)
	fftcep_order = getsym_i("fftcep_order");
      else {
	Fprintf(stderr, "%s: fft cepstrum order undefined.\n", PROG);
	exit(1);
      }
      spsassert( fftcep_order>0, "fftcep_order must be positive.");
      fftcep_tlen = 1 << fftcep_order;
      if (symtype("fftcep_deriv")!=ST_UNDEF) {
	  fftcep_range = getsym_s("fftcep_deriv");
	  if ( strlen(fftcep_range) ) {
	      fftcep_index = grange_switch( fftcep_range, &j);
	      if ( fftcep_index != NULL ) {
		  for (k=0; k<j; k++)
		      spsassert(fftcep_index[k] >= 0 && fftcep_index[k] < fftcep_tlen, 
				"invalid subrange of fft_cepstrum elements specified by fftcep_deriv.");
		  fftcep_deriv_flag = 1;
		  fftcep_field_len = j;
	      } 
	  }
      }
      if ( !fftcep_deriv_flag ) {
	  fftcep_range = malloc(15);
	  fftcep_field_len = fftcep_tlen;
	  Sprintf( fftcep_range, "0:%d", fftcep_tlen-1);
      }
    }


    if ( symtype("preemphasis") != ST_UNDEF )
      preemphasis = (float) getsym_d("preemphasis");
    REQUIRE( preemphasis >=0.0 && preemphasis <=1.0, "preemphasis outside [0.0,1.0]");
    if (fftcep_flag || lpccep_flag) 
	if (symtype("warp_param")!=ST_UNDEF)  
	    warp_param = (float) getsym_d("warp_param");
    REQUIRE(warp_param>-1.0 && warp_param<1.0, "warping parameter outside (-1,1).");
		
    if (fft_flag) {
      if (symtype("fft_order")!=ST_UNDEF) 
	fft_order = getsym_i("fft_order");
      else {
	Fprintf(stderr, "acf: parameter fft_order undefined.\n");
	exit(1);
      }
      fft_tlen = 1 << fft_order;
      hf = fft_tlen / 2;
      num_freqs = hf + 1;
      scale = 10 * log10(2.0/(fft_tlen*src_sf));
    }

    /* Create output-file header */
    ohd = new_header(FT_FEA);
    add_source_file(ohd, iname, ihd);
    ohd->common.tag = YES;
    (void) strcpy(ohd->common.prog, PROG);
    (void) strcpy(ohd->common.vers, Version);
    (void) strcpy(ohd->common.progdate, Date);
    ohd->variable.refer = iname;
    add_comment(ohd, get_cmd_line(argc, argv));

    *add_genhd_l("frmlen", (long *) NULL, 1, ohd) = frame_len;
    *add_genhd_l("nan", (long *) NULL, 1, ohd) = nan;
    *add_genhd_l("start", (long *) NULL, 1, ohd) = start;
    *add_genhd_l("step", (long *) NULL, 1, ohd) = step;
    *add_genhd_e("window_type", (short *) NULL, 1, window_types, ohd) = win;
    /* processing flags */
    *add_genhd_s("flag_sd", (short *) NULL, 1, ohd) = sd_flag;
    *add_genhd_s("flag_pwr", (short *) NULL, 1, ohd) = p_flag;
    *add_genhd_s("flag_zc", (short *) NULL, 1, ohd) = zc_flag;
    *add_genhd_s("flag_rc", (short *) NULL, 1, ohd) = rc_flag;
    *add_genhd_s("flag_autoc", (short *) NULL, 1, ohd) = ac_flag;
    *add_genhd_s("flag_lsf", (short *) NULL, 1, ohd) = lsf_flag;
    *add_genhd_s("flag_lar", (short *) NULL, 1, ohd) = lar_flag;
    *add_genhd_s("flag_lpc", (short *) NULL, 1, ohd) = lpc_flag;
    *add_genhd_s("flag_fft", (short *) NULL, 1, ohd) = fft_flag;
    *add_genhd_s("flag_lpccep", (short *) NULL, 1, ohd) = lpccep_flag;
    *add_genhd_s("flag_fftcep", (short *) NULL, 1, ohd) = fftcep_flag;
    *add_genhd_f("src_sf", (float *) NULL, 1, ohd) = (float) src_sf;
    if (ac_yes) 
      *add_genhd_s("ac_order", (short *) NULL, 1, ohd) = ac_order;
    if (lpccep_flag) {
      *add_genhd_s("lpccep_order", (short *) NULL, 1, ohd) = lpccep_order;
      (void) add_genhd_c("lpccep_deriv", lpccep_range, (int)0, ohd);
    }
    if (lsf_flag)
      *add_genhd_f("lsf_freq_res", (short *) NULL, 1, ohd) = lsf_freq_res;
    if (fftcep_flag) {
      *add_genhd_s("fftcep_order", (short *) NULL, 1, ohd) = fftcep_order;
      (void) add_genhd_c("fftcep_deriv", fftcep_range, (int)0, ohd);
    }
    *add_genhd_f("warping_param", (float *) NULL, 1, ohd) = warp_param;
    *add_genhd_f("preemphasis", (float *) NULL, 1, ohd) = preemphasis;
    if(debug_level>1)
	Fprintf(stderr, "%s: adding fields.\n", PROG);

    /* create output fields */
    if (sd_flag)
	REQUIRE( add_fea_fld(sd_fname, (long)frame_len, (short) 1, (long *) NULL,
			     FLOAT, (char **) NULL, ohd) != -1,
		"can't create sd_field_name field in output file header" );
    if (p_flag)
	REQUIRE( add_fea_fld(p_fname, (long )1, (short) 1, (long *) NULL,
			     FLOAT, (char **) NULL, ohd) != -1,
		"can't create power_field_name field in output file header" );
    if (zc_flag)
	REQUIRE( add_fea_fld(zc_fname, (long) 1, (short) 1, (long *) NULL,
			     FLOAT, (char **) NULL, ohd) != -1,
		"can't create zc_field_name field in output file header" );
    if (rc_flag)
	REQUIRE( add_fea_fld(rc_fname, (long)ac_order, (short) 1, (long *) NULL,
			     FLOAT, (char **) NULL, ohd) != -1,
		"can't create refcof field in output file header" );
    if (ac_flag) 
	REQUIRE( add_fea_fld(ac_fname, (long)(ac_order+1), (short) 1, (long *) NULL,
			     FLOAT, (char **) NULL, ohd) != -1,
		"can't create autocor field in output file header" );
    if (lsf_flag)
	REQUIRE( add_fea_fld(lsf_fname, (long)ac_order, (short) 1, (long *) NULL,
			     FLOAT, (char **) NULL, ohd) != -1,
		"can't create lsf field in output file header" );
    if (lar_flag)
	REQUIRE( add_fea_fld(lar_fname, (long)ac_order, (short) 1, (long *) NULL,
			     FLOAT, (char **) NULL, ohd) != -1,
		"can't create lar field in output file header" );
    if (lpc_flag)
	REQUIRE( add_fea_fld(lpc_fname, (long)ac_order, (short) 1, (long *) NULL,
			     FLOAT, (char **) NULL, ohd) != -1,
		"can't create lpc field in output file header" );
    if (lpccep_flag)
	REQUIRE( add_fea_fld(lpccep_fname, (long)lpccep_field_len, (short) 1, 
			     (long *) NULL, FLOAT, (char **) NULL, ohd) != -1,
		"can't create lpccep field in output file header" );
    if (fftcep_flag) {
	REQUIRE( add_fea_fld(fftcep_fname, (long)fftcep_field_len, (short) 1, 
			     (long *) NULL, FLOAT, (char **) NULL, ohd) != -1,
		"can't create fftcep field in output file header" );
    }

    update_waves_gen(ihd, ohd, (float) start, (float) step);

    if (debug_level) {
	Fprintf(stderr, "%s: Input file: %s \t Output file: %s\n", PROG,
	    iname, oname);
	Fprintf(stderr, "start: %ld   last: %ld    nan: %ld\n", start, last, nan);
	Fprintf(stderr, "frame_len: %ld    step: %ld   frames: %ld\n", 
		frame_len, step, n_frames);
	Fprintf(stderr, "preemphasis: %f\n", preemphasis);
	Fprintf(stderr, "window_type: %s\n", window_type);
	if (ac_yes) 
	  Fprintf(stderr, "autocorrelation order: %ld\n", ac_order);
	if (rc_lpc_yes)
	  Fprintf(stderr, "lpc and reflection coefs: order %ld\n", ac_order);
	if (lar_flag) 
	  Fprintf(stderr, "log area ratios order: %ld\n", ac_order);
	if (lsf_flag)
	  Fprintf(stderr, "line spectral frequencies order: %ld,   frequency resolution %f\n",
		  ac_order, lsf_freq_res);
	if (lpccep_flag)
	  Fprintf(stderr, "lpc cepstrum: order %ld  formed from elements %s: warping param: %f\n", 
		  lpccep_order, lpccep_range, warp_param);
	if (fftcep_flag)
	  Fprintf(stderr, "fft cepstrum: order %ld (%ld) formed from elements %s; warping param %f\n", 
		  fftcep_order, fftcep_tlen, fftcep_range, warp_param);
	if (fft_flag)
	  Fprintf(stderr, "fft: order %ld (%ld)\n", fft_order, fft_tlen);
    }

    if (fft_flag)
	REQUIRE( 0==init_feaspec_hd(ohd, NO, SPFMT_SYM_EDGE, SPTYP_DB, YES, (long) num_freqs, SPFRM_FIXED, 
				    (float *)NULL,(double) src_sf,(long) frame_len, FLOAT), 
		"can't initialize fea spec header.");

    if ( ohd->hd.fea->field_count == 0  ) {
	Fprintf(stderr, "%s: No output fields defined in parameter file - exiting\n", PROG);
	exit(1);
    }

    if (debug_level>1)
      Fprintf(stderr, "%s:writing output header to file\n", PROG);
    write_header(ohd, ofile);

    /* Allocate buffer and set up output record. */
    x = (float *) calloc((unsigned) frame_len, sizeof(float));
    sd_preemp_ptr = (float *) calloc((unsigned) frame_len, sizeof(float));
    REQUIRE((x != NULL) && (sd_preemp_ptr != NULL), 
	    "can't allocate memory for input frame");