xwaves_utils.c

speech signal process tools

   register int    i;
{
   return ((i >= 0) ? i : -i);
}

/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/*
 * Return the element number whose identification string matches str.  If a
 * channel label can not be found to match str, -1 is returned.
 */
get_labeled_chan(s, str)
   Signal         *s;
   char           *str;
{
   register List  *l, *l2;

   if (s && (l = s->idents)) {
      register int    i, dim;

      for (dim = 0; dim < s->dim; dim++) {	/* for each active
						 * dimension... */
	 if (!strcmp(l->str, str))
	    return (dim);
	 if (l->next)
	    l = l->next;
	 else
	    return (-1);	/* no hope of finding a match */
      }
   }
   return (-1);
}

/*********************************************************************/
Object         *
new_object(name, sig)
   Signal         *sig;
   char           *name;
{
   Object         *ob;
   char           *c;
   extern Methods  meth1;
   extern int      zoom_ganged, edit_ganged, scroll_ganged, dont_save_sgrams;

   if ((ob = (Object *) malloc(sizeof(Object))) &&
       (c = malloc(strlen(name) + 1))) {
      strcpy(c, name);
      ob->name = c;
      ob->methods = &meth1;
      ob->signals = sig;
      ob->marks = NULL;
      ob->zoom_ganged = zoom_ganged;
      ob->edit_ganged = edit_ganged;
      ob->scroll_ganged = scroll_ganged;
      ob->dont_save_sgrams = dont_save_sgrams;
      if (sig)
	 sig->obj = (caddr_t) ob;
      ob->next = NULL;
      return (ob);
   }
   printf("Can't allocate space for another object\n");
   return (NULL);
}

/************************************************************************/
/*
 * This assumes that the object's displays contain links to all signals in
 * the object.  The signals, views, etc. actually get freed up in
 * free_canvas_views() as part of the display cleanup initiated by
 * kill_signal_view().
 */
kill_object(o)
   Object         *o;
{
   Signal         *s, *s2;
   Object         *o2;
   View           *v;
   typedef struct frli {
      Frame           f;
      struct frli    *next;
   }               Flist;
   Flist          *fl = NULL, *fl2, *fl3;
   Frame           frame;
   int             wasthere;
   extern Panel_item newObj_item;
   extern char     objectname[];

   if (o) {
      s = o->signals;
      while (s) {
	 if ((s->file == SIG_NEW) &&
	     ((s->type & SPECIAL_SIGNALS) != SIG_SPECTROGRAM))
	    put_waves_signal(s);/* save newly created signals (except
				 * spectrograms) */
	 v = s->views;
	 while (v) {
	    if (v->canvas) {
	       frame = (Frame) xv_get(v->canvas, XV_OWNER);
	       wasthere = 0;
	       if (!(fl2 = fl)) {
		  fl = (Flist *) malloc(sizeof(Flist));
		  fl->f = frame;
		  fl->next = NULL;
	       } else {
		  while (fl2) {
		     if (fl2->f == frame) {
			wasthere = 1;
			break;
		     }
		     fl2 = fl2->next;
		  }
		  if (!wasthere) {
		     fl3 = (Flist *) malloc(sizeof(Flist));
		     fl3->f = frame;
		     fl3->next = fl;
		     fl = fl3;
		  }
	       }
	    }
	    v = v->next;
	 }
	 s = s->others;
      }
      if ((fl2 = fl)) {
	 while (fl2) {
	    xv_set(fl2->f, FRAME_NO_CONFIRM, TRUE, 0);
	    dt_xv_destroy_safe(17, fl2->f);	/* THIS OCCURS
						 * ASYNCHRONOUSLY!! */
	    fl3 = fl2->next;
	    free(fl2);
	    fl2 = fl3;
	 }
      }
      /*
       * The object will actually be freed in free_canvas_views() if it was
       * displayed in a canvas view.
       */
/*      if (!strcmp(objectname, o->name)) { disabled for eddy 3/5/96
	 panel_set_value(newObj_item, "");
      }
*/
      o2 = &program;
      while (o2->next) {
	 if (o2->next == o) {
	    o2->next = o->next;
	    break;
	 }
	 o2 = o2->next;
      }
   }
}

/************************************************************************/
dt_xv_destroy(where, o)
   int             where;
   void           *o;
{
   if (debug_level > 1)
      fprintf(stderr, "Destroying object(%d) %d\n", where, o);
   xv_destroy((Xv_opaque)o);
}

/************************************************************************/
dt_xv_destroy_safe(where, o)
   int             where;
   void           *o;
{
   if (debug_level > 1)
      fprintf(stderr, "Safe destroying object(%d) %d\n", where, o);
   xv_destroy_safe((Xv_opaque)o);
}

/************************************************************************/
put_waves_signal(s)
   Signal         *s;
{
   extern Pending_input new_files;
   extern int      dont_save_sgrams;

   if (s) {
      /* Usually it is not desirable to save the spectrogram signal... */
      if (dont_save_sgrams &&
	  ((s->type & SPECIAL_SIGNALS) == SIG_SPECTROGRAM))
	 return (TRUE);

      /* Keep a cumulative list of all new files created. */
      if (put_signal(s)) {
	 if (new_files.list)
	    ((Menu_list *) new_files.list)->active = FALSE;
	 if (add_to_menu_list(&new_files.list, s->name))
	    ((Menu_list *) new_files.list)->active = TRUE;
	 if (new_files.canvas)
	    menu_redoit(new_files.canvas, NULL, NULL);
	 return (TRUE);
      }
   }
   return (FALSE);
}

/*******************************************************************/
char           *
get_extension(stype)
   register int    stype;
{
   Tlist          *tl = extensions;
   int             type;

   if (!(type = (stype & SPECIAL_SIGNALS)))
      type = VECTOR_SIGNALS;
   while (tl) {
      if (tl->type == type)
	 return (tl->ext);
      tl = tl->next;
   }
   return (NULL);
}

/*********************************************************************/
make_edited_filename(s, realname)
   Signal         *s;
   char           *realname;
{
   char           *ext, *name, next[NAMELEN], *cp;
   extern char     outputname[];
   extern int      append_extensions;

   if ((name = get_output_file_names(outputname, next))) {
      if (append_extensions) {
	 /*
	  * ``outputname'' is given, so use it with appropriate extension
	  */
	 if (!(ext = (char *) get_extension(s->type))) {
	    if (debug_level)
	       fprintf(stderr, "Unknown file type (%x) in make_edited_filename()\n", s->type);
	    return (FALSE);
	 }
	 cp = name + strlen(name) - strlen(ext);
	 if (strcmp(cp, ext)) {	/* does it already have the correct
				 * extension? */
	    cp = name + strlen(name) - 2;	/* nope */
	    if (!strcmp(cp, ".."))
	       *cp = 0;
	    sprintf(realname, "%s%s", name, ext);
	 } else
	    strcpy(realname, name);
      } else
	 strcpy(realname, name);
   } else {
      insert_numeric_ext(s->name, ++(s->version), realname);
      setup_output_dir(realname);
   }
   return (TRUE);
}

/*********************************************************************/
char          **
get_new_files_list()
{
   Menu_list      *l;
   Pending_input  *get_new_files(), *p2, *p = get_new_files();
   int             n = 0;
   char          **rv;

   if (p && (l = (Menu_list *) p->list)) {

      while (l) {
	 n++;
	 l = l->next;
      }
      if ((rv = (char **) malloc(sizeof(char *) * (n + 1)))) {
	 char          **sort_a_list();

	 l = (Menu_list *) p->list;
	 n = 0;
	 while (l) {
	    rv[n++] = l->str;
	    l = l->next;
	 }
	 rv[n] = NULL;
	 return (sort_a_list(rv));
      } else
	 fprintf(stderr, "Allocation problems in get_new_files_list()\n");
   }
   return (NULL);
}

/*********************************************************************/
char          **
get_objects_list()
{
   int             n = 0;
   char          **rv;
   extern Object   program;
   Object         *o = program.next;

   if (o) {
      while (o) {
	 n++;
	 o = o->next;
      }
      if ((rv = (char **) malloc(sizeof(char *) * (n + 1)))) {
	 char          **sort_a_list();

	 o = program.next;
	 n = 0;
	 while (o) {
	    rv[n++] = o->name;
	    o = o->next;
	 }
	 rv[n] = NULL;
	 return (sort_a_list(rv));
      } else
	 fprintf(stderr, "Allocation problems in get_objects_list()\n");
   }
   return (NULL);
}

/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
time_to_index(s, time)
   register Signal *s;
   register double time;
{
   if (s->utils->time_to_index)
      return (s->utils->time_to_index(s, time));
   else
      return (vec_time_to_index(s, time));
}

/*********************************************************************/
check_file_name(s, cs)
   register Signal *s;
   char           *cs;
{
   char           *cp, *ct;

   if (!is_a_x_file(s->name, cs)) {
      if (!rename_signal(s, make_x_name(s->name, cs))) {
	 printf("Can't create new file name for edited parmeters\n");
	 return;
      }
      update_window_titles(s);
      return (FALSE);
   }
   return (TRUE);
}

/************************************************************************/
/*
 * This assumes that a canvas will only be used by one Object (and its
 * Signals).  All signals which refer solely to this view are deleted.
 */
free_canvas_views(canvas)
   Canvas          canvas;
{
   Object         *o;
   Signal         *s, *s2;
   View           *v, *v2;
   extern Panel_item newObj_item, newFile_item;
   extern char     objectname[];

   if ((v = (View *) xv_get(canvas, WIN_CLIENT_DATA)) &&
       (o = (Object *) v->sig->obj)) {	/* search object for ref. to canvas */
      if ((s = o->signals)) {
	 while (s) {
	    if (debug_level)
	       fprintf(stderr, "Does %s refer to canvas %x?\n", s->name, canvas);
	    v = s->views;
	    while (v) {
	       if (v->canvas == canvas) {
		  if (debug_level)
		     fprintf(stderr, "Yes, found signal %s displayed (its views:%x)\n",
			     v->sig->name, v->sig->views);
		  stop_da_view(v);
		  if (unlink_view(v, &(s->views))) {	/* kill views that use
							 * canvas */
		     v2 = v->next;
		     v->next = NULL;
		     free_view(v);
		  } else {
		     printf("Problems with unlink_view() in free_canvas_views()\n");
		     return (FALSE);
		  }
		  v = v2;
	       } else
		  v = v->next;
	    }
	    s = s->others;
	 }
      }
      /* rescan signal list looking for unreferenced signals */
      s = o->signals;
      while (s) {
	 if (debug_level)
	    fprintf(stderr, "Looking for ref to %s during rescan\n", s->name);
	 if (!s->views) {	/* check for references in other signal view
				 * lists */
	    int             was_referenced = FALSE;
	    if (debug_level)
	       fprintf(stderr, "%s has no directly-referenced views\n", s->name);
	    s2 = o->signals;
	    while (s2) {
	       v = s2->views;
	       while (v) {
		  if (v->sig == s) {
		     was_referenced = TRUE;
		     if (debug_level)
			fprintf(stderr, "Found reference to it from view %d\n", v);
		     break;
		  }
		  v = v->next;
	       }
	       if (was_referenced)
		  break;
	       s2 = s2->others;
	    }
	    if (!was_referenced) {	/* kill signals that have no views */
	       s2 = s->others;
	       
	       if (unlink_signal(s)) {
		  if ((s->file == SIG_NEW) &&	/* save any new or modified
						 * signals */
		      ((s->type & SPECIAL_SIGNALS) != SIG_SPECTROGRAM))	/* except spgm. */