tag_methods.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) 1993-1997  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:  David Talkin
 *
 * tag_methods.c
 *
 * A collection of methods for displaying and editing so-called
 *                    "tagged" ESPS files.
 *
 */

static char *sccs_id = "@(#)tag_methods.c	1.9	1/18/97	ATT/ERL";

#include <stdio.h>
#ifndef hpux
#include <sys/param.h>
#else
#define MAXPATHLEN 1024
#endif
#include <esps/esps.h>
#include <Objects.h>
#if !defined(HP400) && !defined(APOLLO_68K) && !defined(DS3100)
#include <malloc.h>
#endif
#include <esps/exview.h>
#include <Xp_pw.h>

extern int debug_level;
extern Xv_Font def_font;
extern int     def_font_height, def_font_width;

#define scoff(x) ((int)(yoffs + ((double)(x) * scale)))
#define ALMOST 0.95

/*********************************************************************/
tag_time_to_x(v,time)
     register View *v;
     register double time;
{
  register int i;
  register double freq, t;

  /* "integerize" time */
  i = time_to_index(v->sig,time);
  time = v->sig->x_dat[i];
  if (time < v->start_time) time = v->start_time; /* clamp */
  if (time > (t = ET(v)))   time = t;
  return((int)(.5 + (PIX_PER_CM *
     ((time - v->start_time) / (*v->x_scale)))) + (*v->x_offset));
}
	 
/*********************************************************************/
double 
tag_x_to_time(v,x)
     register View *v;
     register int x;
{
  double time, t;

  x -= *(v->x_offset);
  if(x < 0) x = 0;
  time = v->start_time + (double)x * *(v->x_scale) / PIX_PER_CM;
  if (time > (t = ET(v)))   time = t;
  return(v->sig->x_dat[time_to_index(v->sig,time)]);
}

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* Aperiodic vector and scalar signals are plotted using a connect-the-dots
   algorithm.  Arbitrary x-axis scaling, y_offsets and y-axis scaling are
   supported. */
tag_plot_waves(view)
     register View *view;
{
  register int y, y2, j, k, npix, x;
  View *vh = view;
  int index, ind, nsam, maxdim, its_an_overlay = FALSE;
  int val, dim;
  Pixwin *pw;
  Signal *sig;
  Canvas canvas;
  double end;
  register double scale, yoffs;
  struct rect	*rect;
  extern int	show_labels, doing_print_graphic, print_only_plot;
  List *l, *l2;

  if(view && (sig = view->sig) && sig->type) {

    if(view->extra && (view->extra_type == VIEW_OVERLAY)) {
      vh = (View*)view->extra;
      its_an_overlay = TRUE;
    }
    
    if(IS_GENERIC(view->sig->type)) {

      canvas = vh->canvas;
  
      pw = canvas_pixwin(canvas); /* get the pixwin to write to */

      rect = (struct rect*)xv_get(canvas, WIN_RECT);

      /* Determine the number of waveform samples to plot */
      if(vh->start_time < BUF_END_TIME(sig)) {
	end = ET(vh);
	/* deternine starting sample in the waveform */
	index = time_to_index(sig,vh->start_time);
	for(nsam=0,j=index; (nsam < sig->buff_size) &&
	    (sig->x_dat[j] <= end); j++) nsam++;
      } else {
	return(FALSE);
      }

      if(index+nsam >= sig->buff_size-1)
	nsam = sig->buff_size - 1 - index;

      /* clear window if data is NOT plotted as an overlay */
      if( !its_an_overlay && !doing_print_graphic)
	pw_write(pw,0,0,rect->r_width,rect->r_height,
		 PIX_COLOR(BACKGROUND_COLOR)|PIX_SRC,NULL,0,0);

#define PLOT_TYPE(the_type) { \
  register the_type *q, *r, *p, imax, imin; \
   \
  if (nsam > 0 && !s_data) \
    return FALSE; \
   \
  val = view->colors[dim]; \
  scale = - PIX_PER_CM/vh->y_scale[dim]; \
  yoffs = .5 + (double)vh->y_offset[dim]; /* precompute for speed */ \
  switch(view->line_types[dim]) { \
  case 1:		/* standard solid line type */ \
  default: \
      k = *(vh->x_offset) + 0.5 + \
	((PIX_PER_CM * (sig->x_dat[index] - vh->start_time) / *(vh->x_scale))); \
    for(ind = index+1, p = (the_type *) s_data + index, \
	r = p + 1,  q = p + nsam; p < q; ind++) { \
      x = *(vh->x_offset) + 0.5 + \
	((PIX_PER_CM * (sig->x_dat[ind] - vh->start_time) / *(vh->x_scale))); \
      pw_vector(pw, k, scoff(*p++), x, scoff(*r++), \
		PIX_COLOR(val)|PIX_SRC, val); \
      k = x; \
    } \
    break; \
  case 2:			/* histogram-style */ \
    k = *(vh->x_offset) + 0.5 + \
        ((PIX_PER_CM * (sig->x_dat[index] - vh->start_time) / *(vh->x_scale))); \
    for(ind = index+1, y2 = scoff(sig->smin[view->elements[dim]]), \
	p = (the_type *) s_data + index, \
	r = p + 1,  q = p + nsam; p < q; ind++) { \
      x = *(vh->x_offset) + 0.5 + \
	((PIX_PER_CM * (sig->x_dat[ind] - vh->start_time) / *(vh->x_scale))); \
      pw_vector(pw, k, (y = scoff(*p++)), x, scoff(*r++), \
		PIX_COLOR(val)|PIX_SRC, val); \
      pw_vector(pw, k, y, k, y2, PIX_COLOR(val)|PIX_SRC, val); \
      k = x; \
    } \
    break; \
  case 3:			/* DSP-style */ \
  case 4:			/* DSP-style with connect the dots */ \
    k = *(vh->x_offset) + 0.5 + \
        ((PIX_PER_CM * (sig->x_dat[index] - vh->start_time) / *(vh->x_scale))); \
    for(ind = index+1, y2 = scoff(0.0), \
	p = (the_type *) s_data + index, \
	r = p + 1,  q = p + nsam; p < q; ind++) { \
      x = *(vh->x_offset) + 0.5 + \
	((PIX_PER_CM * (sig->x_dat[ind] - vh->start_time) / *(vh->x_scale))); \
      y = scoff(*p++); \
      if(view->line_types[dim] == 4) \
	pw_vector(pw, k, y, x, scoff(*r++), \
		PIX_COLOR(val)|PIX_SRC, val); \
      pw_vector(pw, k, y, k, y2, PIX_COLOR(val)|PIX_SRC, val); \
      k = x; \
    } \
    break; \
  } \
}
  /* >>>  END of PLOT_TYPE() definition  <<< */

      if (nsam > 0)
      {
	  maxdim = MIN(view->dims, vh->dims);

	  if (maxdim > 0 && !sig->data)
	      return FALSE;

	  for (dim=0; dim < maxdim; dim++) /* for each dimension... */
	      switch(sig->type & VECTOR_SIGNALS)
	      {
	      case P_CHARS:
	      case P_UCHARS:
		{
		    char    *s_data = ((char **) sig->data)[vh->elements[dim]];

		    PLOT_TYPE(char);
		}
		break;
	      case P_SHORTS:
		{
		    short   *s_data = ((short **) sig->data)[vh->elements[dim]];

		    PLOT_TYPE(short);
		}
		break;
	      case P_INTS:
	      case P_UINTS:
		{
		    int     *s_data = ((int **) sig->data)[vh->elements[dim]];

		    PLOT_TYPE(int);
		}
		break;
	      case P_FLOATS:
		{
		    float   *s_data = ((float **) sig->data)[vh->elements[dim]];

		    PLOT_TYPE(float);
		}
		break;
	      case P_DOUBLES:
		{
		    double  *s_data = ((double **) sig->data)[vh->elements[dim]];

		    PLOT_TYPE(double);
		}
		break;
	      case P_MIXED:
		{
		    caddr_t s_data = ((caddr_t *) sig->data)[vh->elements[dim]];

		    switch (sig->types[vh->elements[dim]])
		    {
		    case P_CHARS:
		    case P_UCHARS:
			PLOT_TYPE(char);
			break;
		    case P_SHORTS:
			PLOT_TYPE(short);
			break;
		    case P_INTS:
		    case P_UINTS:
			PLOT_TYPE(int);
			break;
		    case P_FLOATS:
			PLOT_TYPE(float);
			break;
		    case P_DOUBLES:
			PLOT_TYPE(double);
			break;
		    default:
			sprintf(notice_msg,
				"Unknown component data type in plot_waves(%x)\n",
				sig->types[vh->elements[dim]]);
			show_notice(1,notice_msg);
			return(FALSE);
		    }
		}
		break;
	      default:
		goto arrgh;
	      } /* end switch (sig->type ...) */
      } /* end if (nsam ...) */

    } else {
    arrgh:
      sprintf(notice_msg,"Unknown data type in plot_waves(%x)\n", 
                         view->sig->type );
      show_notice(1,notice_msg);
      return(FALSE);
    }    

    if((!its_an_overlay) && (l = sig->idents)) {
      int curi, i;
/*      double sigmin; */
      
      for(dim=0; dim < view->dims; dim++) { /* for each dimension... */
	if(view->show_labels[dim]) {
	  curi = view->elements[dim];
	  for(i = 0, l2 = l; i < curi; i++)
	    if(l2->next)
	      l2 = l2->next;
/*	  sigmin = view->sig->smin[curi];

	  if (plot_min != 0)
	    sigmin = plot_min;

	  if (view->sig->smax[curi] - sigmin == 0.0)
	      sigmin -= 0.5; */	/* Cf. comment on similar adjustment
				 * in print_y.
				 */
	  scale = - PIX_PER_CM/view->y_scale[dim];
	  yoffs = .5 + (double)view->y_offset[dim];	  
	  if(!(doing_print_graphic && print_only_plot))
	      pw_text(pw, *(view->x_offset), scoff(view->plot_min[dim]),
		  PIX_SRC|PIX_COLOR(TEXT_COLOR), def_font, l2->str);
	}
      }
    }
    return(TRUE);
  }
  return(FALSE);
#undef PLOT_TYPE
}

/*********************************************************************/
View *
tag_setup_view(s, c)
     Signal *s;
     Canvas c;
{
View *v, *setup_generic_view();
if(s && c) {
  if((v = setup_generic_view(s,c))) {
    v->data_plot = tag_plot_waves;
    v->time_to_x = tag_time_to_x;
    v->x_to_time = tag_x_to_time;
    }
    return(v);
  }
  return(NULL);
}


/*******************************************************************/
tag_save_seg(s, start_time, duration, file)
     Signal *s;
     double start_time, duration;
     char *file;
{
  Signal *so;
  char comment[200];
  char **dpp, **dppi;
  int n, i, j, size;
  double etr, ets;
  char *ptr;
  /* Pixrect   *pr, *pro; */

  if(!((start_time >= s->start_time) &&
       ((etr = start_time+duration) <=
	(ets = (s->start_time + SIG_DURATION(s)))))) {
    if((start_time >= ets) || (etr <= s->start_time)) {
      sprintf(notice_msg, "Bogus times passed to tag_save_seg(%s %f %f)",
	     s->name, start_time, duration);
      show_notice(1,notice_msg);
      return(FALSE);
    }
    if(start_time < s->start_time) start_time = s->start_time;
    if(ets < etr) etr = ets;
    duration = etr - start_time;
    sprintf(notice_msg, 
             "Limits requested in tag_save_seg exceeded signal limits.\n");
    ptr = notice_msg + strlen(notice_msg);
    sprintf(ptr,"adjusted to: start_time=%lf  duration=%lf",
	   start_time,duration);
    show_notice(1,notice_msg);
  }

  if((so=new_signal(file, SIG_NEW, dup_header(s->header),
		    (caddr_t) NULL, 0, s->freq, s->dim))) {
    sprintf(comment,"tag_save_seg: start_time %f duration %f signal %s",
	    start_time, duration, s->name);
    so->start_time = start_time;

    so->end_time = etr;
    clone_methods(so,s);
    if (so->header
	&& so->header->magic == ESPS_MAGIC
	&& so->header->esps_hdr)