xwaves_utils.c

speech signal process tools

		     put_waves_signal(s);
		  send_kill_file(o, s);
		  if (debug_level)
		     fprintf(stderr, "Sent kill file (%s %s)\n", o->name, s->name);
		  if (!strcmp((char*)panel_get_value(newFile_item), s->name))
		    panel_set_value(newFile_item, "");
		  free_signal(s);
	       } else {
		  printf("Problems with unlink_signal() in free_canvas_views()\n");
		  return (FALSE);
	       }
	       s = s2;
	    } else		/* it was referenced in another view */
	       s = s->others;
	 } else {		/* it has views */
	    if (debug_level)
	       fprintf(stderr, "It has a view list\n");
	    s = s->others;
	 }
      }

      if (!o->signals) {	/* if all signals were destroyed... */
	 Object         *o2 = &program;

	 if (debug_level)
	    fprintf(stderr, "Found that all signals in %s were destroyed\n", o->name);
	 while (o2->next) {	/* unlink from object list, if necessary */
	    if (o2->next == o) {
	       o2->next = o->next;
	       break;
	    }
	    o2 = o2->next;
	 }
/*	 if (!strcmp(objectname, o->name)) deleted 3/5/96 for eddy
	    panel_set_value(newObj_item, "");
*/
	 send_kill_object(o);
	 kill_all_marks(o);
	 if (o->name)
	    free(o->name);
	 free(o);
      }
      return (TRUE);
   }
   return (FALSE);
}

/*************************************************************************/
canvas_still_lives(canvas)
   Canvas          canvas;
{
   extern Object   program;
   Object         *o = &program;
   Signal         *s;
   View           *v;

   while (o) {
      s = o->signals;
      while (s) {
	 v = s->views;
	 while (v) {
	    if (v->canvas == canvas)
	       return (TRUE);
	    v = v->next;
	 }
	 s = s->others;
      }
      o = o->next;
   }
   return (FALSE);
}

/*********************************************************************/
static 
really_plot_it_now(canvas)
   Canvas          canvas;
{
   View           *v;
   Signal         *s;

   v = (View *) xv_get(canvas, WIN_CLIENT_DATA);
   s = v->sig;

   for (v = s->views; v; v = v->next)
      plot_view(v);

   if (s && (v = s->views) && v->canvas)
      send_redisplay(s);
}

static List    *dq = NULL;

#define ITIMER_NULL ((struct itimerval*)0)
/*************************************************************************/
static Notify_value 
process_repaint_q()
{
   List           *dq2;
   extern Frame    daddy;

   notify_set_itimer_func(12345, process_repaint_q, ITIMER_REAL, ITIMER_NULL,
			  ITIMER_NULL);
   while (dq) {
      if (dq->str && canvas_still_lives(dq->str))
	 really_plot_it_now(dq->str);
      dq2 = dq->next;
      free(dq);
      dq = dq2;
   }
   return (NOTIFY_DONE);
}

/*************************************************************************/
clobber_repaint_entry(canvas)
   char           *canvas;
{
   List           *dqp = dq;

   while (dqp) {
      if (dqp->str == canvas)
	 dqp->str = NULL;
      dqp = dqp->next;
   }
}

/*************************************************************************/
static List    *
new_repaint_ent(str)
   char           *str;
{
   List           *q;
   if (str && (q = (List *) malloc(sizeof(List)))) {
      q->str = str;
      q->next = NULL;
      return (q);
   }
   return (NULL);
}

/*************************************************************************/
static 
delay_repaint(str)
   char           *str;
{
   if (str) {
      List           *dqp = dq, *qp2;

      restart_d_clock(100000, 12345, process_repaint_q);

      while (dqp) {		/* repaint already requested? */
	 if (dqp->str == str)
	    return (TRUE);
	 dqp = dqp->next;
      }

      if ((dqp = new_repaint_ent(str))) {
	 if (!dq)
	    dq = dqp;
	 else {
	    qp2 = dq;
	    while (qp2->next)
	       qp2 = qp2->next;
	    qp2->next = dqp;
	 }
	 return (TRUE);
      } else
	 fprintf(stderr, "Allocation failure in delay_repaint()\n");
   }
   return (FALSE);
}

/***********************************************************************/
void 
repaint(canvas, pw, ra)
   Canvas          canvas;
   Pixwin         *pw;
   Rectlist       *ra;
{
   delay_repaint(canvas);
}

/*********************************************************************/
void 
redoit(canvas)
   Canvas          canvas;
{
   delay_repaint(canvas);
}

/*********************************************************************/
Object         *
find_object(name)
   char           *name;
{
   Object         *get_receiver();

   return (get_receiver(name));
}

/*********************************************************************/
link_new_object(ob)
   Object         *ob;
{
   if (ob) {
      ob->next = program.next;
      program.next = ob;
   }
}

/*********************************************************************/
link_new_signal(ob, sig)
   Object         *ob;
   Signal         *sig;
{
   if (ob && sig) {
      sig->obj = (caddr_t) ob;
      sig->others = ob->signals;
      ob->signals = sig;
   }
}

/*********************************************************************/
Signal         *
find_signal(ob, name)
   Object         *ob;
   char           *name;
{
   Signal         *s;
   char           *expand_name();

   if (ob && name && (s = ob->signals)) {
      while (s) {
	 if (!strcmp(expand_name(NULL, name), s->name))
	    return (s);
	 s = s->others;
      }
   }
   return (NULL);
}

/*********************************************************************/
Signal         *
get_playable_signal(v)
   View           *v;
{
   Spectrogram    *sp;
   Object         *o;
   Signal         *s0, *s, *get_any_signal();
   struct header  *ehd;

   if (v && (s0 = v->sig)) {
      if ((((s0->type & (VECTOR_SIGNALS | APERIODIC_SIGNALS | VAR_REC_SIGNALS))
	    == P_SHORTS) && playable_dimension(s0->dim)) ||
	  (s0->header
	   && s0->header->magic == ESPS_MAGIC
	   && (ehd = s0->header->esps_hdr)
	   && ehd->common.type == FT_FEA
	   && ehd->hd.fea->fea_type == FEA_SD)
	 )
	 return s0;
      if ((o = (Object *) s0->obj)) {
	 if (((s0->type & SPECIAL_SIGNALS) == SIG_SPECTROGRAM)
	     && (sp = (Spectrogram *) (s0->params))
	     && (s = (Signal *) find_signal(o, sp->signame))
	    )
	    return s;
	 if (s0->header
	     && s0->header->magic == ESPS_MAGIC
	     && (ehd = s0->header->esps_hdr)
	     && ehd->common.type == FT_FEA) {
	    if (ehd->variable.refer
		&& (s = find_signal(o, ehd->variable.refer)))
	       return s;
	    else if (ehd->variable.source[0]
                     && strcmp(ehd->variable.source[0],"<stdin>")
		     && (s = find_signal(o, ehd->variable.source[0])))
	       return s;
	    else if (ehd->variable.srchead[0] 
                     && ehd->variable.srchead[0]->variable.source[0]
                     && strcmp(ehd->variable.srchead[0]->variable.source[0],
			       "<stdin>")
		     && (s=find_signal(o, 
                         ehd->variable.srchead[0]->variable.source[0])))
	       return s;
	 }
	 if (s = find_signal(o, new_ext(s0->name, "sd")))
	    return s;
	 if (s = find_signal(o, new_ext(s0->name, "d")))
	    return s;
	 /* search through object for anything playable */
	 for (s = o->signals; s; s = s->others) {
	    if ((((s->type
		   & (VECTOR_SIGNALS | APERIODIC_SIGNALS | VAR_REC_SIGNALS))
		  == P_SHORTS)
		 && playable_dimension(s->dim)))
	       return s;
	 }
      }
      if (s0->header
	  && s0->header->magic == ESPS_MAGIC
	  && (ehd = s0->header->esps_hdr)
	  && ehd->common.type == FT_FEA) {
	 if (ehd->variable.refer
	     && (s = get_any_signal(ehd->variable.refer,
				    0.0, 20.0, (int (*) ()) NULL)))
	    return s;
	 else if (ehd->variable.source[0]
                  && strcmp(ehd->variable.source[0],"<stdin>")
		  && (s = get_any_signal(ehd->variable.source[0],
					 0.0, 20.0, (int (*) ()) NULL)))
	    return s;
	 else if (ehd->variable.srchead[0] 
                  && ehd->variable.srchead[0]->variable.source[0]
                  && strcmp(ehd->variable.srchead[0]->variable.source[0],
                            "<stdin>")
	          && (s=find_signal(o, 
                      ehd->variable.srchead[0]->variable.source[0])))
	    return s;
      }
      /* last resort - return signal being looked for external play */
      return s0;
   }
   return NULL;
}

/*************************************************************************/
update_filename_display(new)
   char           *new;
{
   char            sc[50];
   extern Panel_item outputFile_item;
   extern char     outputname[];

   if (*outputname == '@') {
      sscanf(outputname, "%s", sc);
      if (strlen(new))
	 sprintf(outputname, "%s   %s", sc, new);
      else
	 *outputname = 0;
   } else
      strcpy(outputname, new);
   xv_set(outputFile_item, PANEL_VALUE, outputname, 0);
   return;
}

/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
char           *
maybe_basename(name, v)
   char           *name;
   View           *v;
{
   extern          shorten_header;
   extern char    *basename();

   if (name && *name && v->shorten_header)
      return (basename(name));
   else
      return (name);
}

/*********************************************************************/
update_window_titles(s)
   Signal         *s;
{
   View           *v = s->views;

   while (v) {
      if (v->canvas && (v->extra_type != VIEW_OVERLAY)) {
	 char            head[200];
	 Frame           f = (Frame) xv_get(v->canvas, XV_OWNER);
	 sprintf(head, "%s (S.F.:%7.1f) {left:%s  mid:%s  right:menu}",
		 maybe_basename(s->name, v), s->freq, v->left_but_proc->name, v->mid_but_proc->name);
	 xv_set(f, XV_LABEL, head, 0);
      }
      v = v->next;
   }
}

/*********************************************************************/
void 
update_control_panel_names()
{
   extern Panel_item newFile_item, newObj_item, overlay_item, outputFile_item;
   extern char     outputname[], inputname[], objectname[], overlayname[];

   xv_set(outputFile_item, PANEL_VALUE, outputname, 0);
   xv_set(newFile_item, PANEL_VALUE, inputname, 0);
   xv_set(newObj_item, PANEL_VALUE, objectname, 0);
   xv_set(overlay_item, PANEL_VALUE, overlayname, 0);
}

/*************************************************************************/
/*
 * A quick and dirty check to see if the first thing in a file is likely a
 * direct command to the program (such as "xwaves make ...").
 */
is_a_command_file(name)
   char           *name;
{
   FILE           *fd;
   int             n;
   char            stuff[501], pname[201];
   extern Object   program;

   if (!strcmp(name, "stdin"))
      return (TRUE);

   if ((fd = fopen(name, "r"))) {
      *stuff = '\0';
      while ((fgets(stuff, 500, fd) != NULL) && (*stuff == '#'));
      fclose(fd);
      n = strlen(stuff);
      if (n) {
	 stuff[n] = ' ';
	 sscanf(stuff, "%s", pname);
	 return (!strcmp(pname, program.name));
      }
   }
   return (FALSE);
}