dtw_rec.c

speech signal process tools

/*
 * 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) 1991-1996 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:  Bill Byrne
 * Checked by:
 * Revised by:
 *
 * Brief description:
 * This program computes the dynamic time warping distances between
 * sequences.  The sequences are read from FEA files specified in
 * ASCII files.
 */

static char *sccs_id = "%W%	%G%	ERL";

#include <stdio.h>
#include <math.h>
#include <esps/esps.h> 
#include <esps/fea.h>
#include <esps/vq.h>
#include <esps/spsassert.h>
#include <esps/limits.h>

#define PROG "dtw_rec"
#define VERSION "%I%"
#define DATE "%G%"

#define REQUIRE(test, text) {if (!(test)) { \
  (void) fprintf(stderr, "%s: %s  Exiting.\n", PROG, text); \
  exit(1);}}

#define SYNTAX {\
fprintf(stderr, "%s: dynamic time warp distance between FEA files.\n", PROG); \
fprintf(stderr,"usage: %s [options] reference_list test_list results\n", PROG);\
fprintf(stderr, " -P parameter file (default: params)\n");\
fprintf(stderr, " -f sequence_field\n");\
fprintf(stderr, " -b best_so_far\n"); \
fprintf(stderr, " -l best_list_length (default: 1)\n"); \
fprintf(stderr, " -d delta (default: 0)\n"); \
fprintf(stderr, " -c distance_table_file\n"); \
fprintf(stderr, " -t distance_table_field\n"); \
fprintf(stderr, " -r distance_table_recno\n"); \
fprintf(stderr, " -x debug_level (default: 0) \n");\
exit(1);}

#define Fprintf (void)fprintf
#define Sprintf (void)sprintf

/* global declarations */
int 		debug_level=0;
unsigned long    flags;
char *	     ptr;

#if !defined(IBM_RS6000) && !defined(DEC_ALPHA)
    char             *calloc();
    int              fprintf();
    int              fscanf();
    void             exit();
#endif

main(argc, argv)
int argc;
char **argv;
{
    extern char      *optarg;
    extern int       optind;
    int              opt;

    char             *param_file = "params";            
    char             *vfieldname = "spec_param"; 
    char             *ifieldname = "spec_param_cwndx";
    char             *fieldname = NULL;
    int              fieldname_flag=0;
    int              debug_level_flag=0;
    int              delta_flag=0;
    long             delta=0;
    long             best_list_len=1;
    long             list_len;
    int              best_list_len_flag=0;
    double           *best_list=NULL;
    long             *best_id=NULL;
    int              best_so_far_flag=0;
    long             dim=0;
    double           dist;
    double           *dist_ptr;
    long             *mapping=NULL;
    int              i, j, k, ref_to_test_ptr;
    float            *fptr;
    long             *lptr;
    double           *dptr;

    FILE             *tbl_fp;
    char             *tbl_fname=NULL;
    char             *tbl_fieldname = "distance_table";
    int              tflag=0;
    int              rflag=0;
    int              cflag=0;                    /* if set, expect sequences of integers */
    long             tbl_recno = LONG_MAX;
    struct header    *tbl_hd;
    struct vqcbk     *tbl_rec;
    double           **distances=NULL;
    double           *fea_dist_ptr;
    int              cbk_dim=0;

    FILE             *res_fp;
    char             *res_fname;

    char             name[200];
    char             *tname;

    FILE             *ref_list_fp;
    char             *ref_list_fname;
    int              ref_list_len=0;
    char             **ref_fnames;
    float            ***ref_vseqs;
    long             **ref_iseqs;
    char             **ref_seq_id;
    long             *ref_seq_len;
    long             ref_ptr;

    FILE             *test_list_fp;
    char             *test_list_fname;
    int              test_list_len=0;
    char             **test_fnames;
    float            **test_vseq;
    long             *test_iseq;
    char             *test_seq_id;
    long             test_seq_len;
    long             test_ptr;

    double           dtw_l2();
    double           dtw_tl();
    double           l2_dist();
    double           atof();
    int              atoi();
    long             get_fea_siz();
    char             *savestring();
    char             *get_cmd_line();
    char             *strcpy();
    char             *get_fea_ptr();
    struct fea_data  *allo_fea_rec();
    int              getopt();
    double           **d_mat_alloc();
    float            **f_mat_alloc();
    FILE             *fopen();
    long             *fea_read_int_sequence();
    float            **fea_read_vec_sequence();


    while ( (opt = getopt(argc, argv,"P:f:bd:t:l:c:r:x:")) != EOF )
      switch(opt) {
      case 'P': 
	param_file = optarg;
	break;
      case 'b': 
	best_so_far_flag++;
	break;
      case 'd': 
        delta = atoi(optarg);
	spsassert(delta>=0,"delta must be positive.\n");
	delta_flag++;
	break;
      case 'l': 
        best_list_len = atoi(optarg);
	spsassert(best_list_len>0, "best_list_length must be positive.\n");
	best_list_len_flag++;
	break;
      case 'f': 
        fieldname = optarg;
	fieldname_flag++;
	break;
      case 'c': 
        tbl_fname = optarg;
        cflag++;
        break;
      case  'r':
        tbl_recno  = atoi(optarg);
        rflag++;
        break;
      case 't' :
	tbl_fieldname = optarg;
        tflag++;
        break;
      case 'x': debug_level=atoi(optarg);
	debug_level_flag++;
	break;
  }

    /* process parameters */
    (void) read_params(param_file, SC_NOCOMMON, (char *)NULL);
    if ( debug_level_flag == 0 && symtype("debug_level") != ST_UNDEF )
      debug_level = getsym_i("debug_level");
    if ( fieldname_flag == 0 && symtype("sequence_field") != ST_UNDEF ) {
      fieldname = getsym_s("sequence_field");
      fieldname_flag++;
    }
    if ( delta_flag == 0 && symtype("delta") != ST_UNDEF )
      delta = getsym_i("delta");
    if ( best_so_far_flag == 0 && symtype("best_so_far") != ST_UNDEF ) 
	if (getsym_i("best_so_far") == 1 )
	    best_so_far_flag++;
    if ( best_list_len_flag == 0 && symtype("best_list_length") != ST_UNDEF ) {
      best_list_len = getsym_i("best_list_length");
      best_list_len_flag++;
    }
    if ( tflag == 0 && symtype("distance_table_field") != ST_UNDEF )
      tbl_fieldname = getsym_s("distance_table_field");
    if ( rflag == 0 && symtype("distance_table_recno") != ST_UNDEF )
      tbl_recno = getsym_i("distance_table_recno");
    if ( cflag == 0 && symtype("distance_table_file") != ST_UNDEF ) {
	tbl_fname = getsym_s("distance_table_file");
	cflag++;
    }
    if ( !fieldname_flag ) {
	if (cflag)
	    fieldname = ifieldname;
	else
	    fieldname = vfieldname;
    }

    /* get distance table */
    if (cflag) {
	if (debug_level)
	    Fprintf(stderr, "%s: Getting distance table from file %s.\n",
		    PROG, tbl_fname);
	(void) eopen(PROG, tbl_fname, "r", FT_FEA, FEA_VQ, &tbl_hd, &tbl_fp);

	tbl_rec = allo_vqfea_rec(tbl_hd);

	if (tbl_recno == LONG_MAX && tbl_hd->common.ndrec != -1)
	    tbl_recno = tbl_hd->common.ndrec;

	if (tbl_recno != LONG_MAX)
	{
	    fea_skiprec(tbl_fp, tbl_recno - 1, tbl_hd);

	    REQUIRE(get_vqfea_rec(tbl_rec, tbl_hd, tbl_fp) != EOF,
		    "Premature end of file in FEA_VQ distortion file.");
	}
	else	/* Read records to find the last. */
	{
	    struct vqcbk	*next_rec, *tmp_rec;

	    next_rec = allo_vqfea_rec(tbl_hd);
	
	    REQUIRE(get_vqfea_rec(tbl_rec, tbl_hd, tbl_fp) != EOF,
		    "EOF when trying to read first distortion record.");

	    while (get_vqfea_rec(next_rec, tbl_hd, tbl_fp) != EOF)
	    {
		tmp_rec = tbl_rec;
		tbl_rec = next_rec;
		next_rec = tmp_rec;
	    }

	    free_fea_rec(tmp_rec->fea_rec);
	}

	fea_dist_ptr =
	    (double *) get_fea_ptr(tbl_rec->fea_rec, tbl_fieldname, tbl_hd);
	REQUIRE(fea_dist_ptr != NULL,
		"can't get field distance_table from distance file.");
	
	cbk_dim = *tbl_rec->current_size;

	if (debug_level>1)
	    Fprintf(stderr, "%s: codebook dimension %d.\n", PROG, cbk_dim);

	distances = d_mat_alloc( (unsigned) cbk_dim, (unsigned) cbk_dim);
	spsassert( distances != NULL, "can't allocate memory table.");

	for (i=0; i<cbk_dim; i++)
	    for (j=0; j<cbk_dim; j++)
		distances[i][j] = fea_dist_ptr[ i * cbk_dim + j];
	fclose(tbl_fp);
	free_fea_rec( tbl_rec->fea_rec );
    }

    /* open reference list file */
    if (optind == argc) {
	Fprintf(stderr, "No filename reference_list specified.\n");
	SYNTAX;
    }
    ref_list_fname = argv[optind++];
    spsassert( strcmp(ref_list_fname, "-")!=0, "standard input not allowed.");      
    ref_list_fp = fopen( ref_list_fname, "r");
    spsassert( ref_list_fp != NULL, "Can't open reference_list.");
    if (debug_level)
	Fprintf(stderr, "%s: Reading reference list from %s.\n", PROG, ref_list_fname);

    /* open test list file */
    if (optind == argc) {
	Fprintf(stderr, "No filename test_list specified.\n");
	SYNTAX;
    }
    test_list_fname = argv[optind++];
    spsassert( strcmp(test_list_fname, "-")!=0, "standard input not allowed.");      
    test_list_fp = fopen(test_list_fname, "r");
    spsassert( test_list_fp != NULL, "Can't open test_list.");
    if (debug_level)
	Fprintf(stderr, "%s: Reading test list from %s.\n", PROG, test_list_fname);