xmethods.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) 1987-1990  AT&T, Inc.
 *    "Copyright (c) 1986-1990  Entropic Speech, Inc. 
 *    "Copyright (c) 1990-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:  David Talkin
 * Checked by:
 * Revised by:  Alan Parker, Rod Johnson, John Shore, David Talkin
 *
 *  xmethods.c
 *  implementation of methods accessible by external processes
 */

static char *sccs_id = "@(#)xmethods.c	1.39 28 Oct 1999 ERL/ATT";
#include <Objects.h>
#include <esps/esps.h>
#include <esps/fea.h>
#include <esps/unix.h>
#include <xview/scrollbar.h>

#ifndef hpux
#include <sys/param.h>
#else
#define MAXPATHLEN 1024
#endif

#define ATTACHING 0x4000
#define SLEEPING  0x2000

#define HI_SPECT_LIM  127-22
  /* This fudge factor of 22 is to translate the image_clip semantics
     for monochrome dither to a reasonable value for color/greyscale.
     Without this fudge factor, all image_clip entries in various
     environments worldwide would need to be changed!) */

extern char *checking_selectors(), *savestring();
extern double image_clip, image_range;
extern char *dispatch(), *receiver_prefixed(), *get_next_item();

#define CHECK_QUERY(a,b) { char *cret; if((cret = checking_selectors(a,b))) return(cret); }

static FILE *fopen_command_file();
extern Selector g1;
Signal *find_signal();
Selector **get_changed_items();
Object *find_object();

char *meth_add_espst(), *meth_add_espsf(), *meth_add_operator(),
     *meth_add_espsn(), *meth_start_attachment(), *meth_send(),
     *meth_add_keymap(), *meth_delete_keymap(), *meth_dump_keymaps();
char *meth_enable_server(),  *meth_disable_server(),
       *meth_dump_add_ops(), *meth_save_menus(),
       *meth_save_panels(), *meth_setenv(), *meth_stop_play();
void	    menu_change();
char *meth_get_attach_list();

extern void update_control_panel_names(), menu_set_blowup_op(),
  distribute_options_settings(), set_default_header(),
  set_old_sphere_format();

char *meth_print_setup();

char *meth_open_ctlwin(), *meth_close_ctlwin();

char *meth_auto_plotlims();
char *meth_print_graphic();
char *meth_print_ensemble();


extern char *build_filename();

extern int  debug_level; 
extern Frame daddy; /* the xwaves control panel */

extern char ok[], null[];	/* in message.c */


/* THE FOLLOWING GLOBALS MAY BE SET FROM <a profile file> */

extern char inputname[],	/* name of signal input file */
     outputname[] ,	/* name of signal output file */
     objectname[] ,	/* user-defined object name */
     commandname[] ,	/* control script */
     funcname[] ,	/* linkage to external process */
     def_left_op[],
     def_middle_op[],
     def_move_op[],
     def_sleft_op[],
     def_smiddle_op[];

extern int
    line_type;			/* for plotting waveforms */

/* some display creation globals */
extern double ref_size,		/* size for def. waveform disp.*/
              ref_step,		/* amount to step in file */
	      ref_start;	/* where reference window display begins */
extern int def_w_height,	/* dim. of waveform window */
           def_w_width;

/* window position parameters */
extern int  next_x,		/* upper left-hand corner of new window */
            next_y;

extern int w_verbose;

/* END OF GLOBALS SET FROM CONFIGURATION FILE */

extern Panel_item quit_item, newFile_item, newObj_item, newFunct_item;
extern Object program;
extern Frame daddy;

int command_paused = 0;		/* pause flag for command file */
typedef struct com_stk {
  char name[200];
  int line_num;
  struct com_stk *next;
} Com_stack;

Com_stack *command_stack = NULL;

int	new_width=0, new_height=0; /* arguments to make command */

#ifdef STARDENT_3000
extern char WAVES_MISC[];
#endif

/*********************************************************************/
char *
get_receiver(str)
     char *str;
{
  Object *ob;
  static  char name[200];

  ob = &program;
  if(str && strlen(str) && sscanf(str,"%s",name) == 1) {
    while(ob) {
      if(ob->name &&
	 (! strcmp(ob->name, name))) {
	   return((char*)ob);
      }
      ob = ob->next;
    }
  }
  return(NULL);
}

/*********************************************************************/
char *
get_receiver_name(ob)
     Object *ob;
{
  return(ob->name);
}

/*********************************************************************/
char *
get_methods(ob)
     Object *ob;
{
  extern Methods bmeth1;
  
  if(ob) return((char*)(ob->methods));
  else
    return((char*)&bmeth1);
}

/***********************************************************************/
char *
augment_external_command(s,v,mess)
     Signal *s;
     View *v;
     char *mess;
{
  if(mess && s && (v || (v = s->views)) && v->canvas) {
    double start, seccm;
    Frame frm = (Frame)xv_get(v->canvas, XV_OWNER);
    Rect  rec;
    char info[200];

    frame_get_rect(frm, &rec);
    
    seccm = *(v->x_scale);
    start = v->start_time;
    if(debug_level)
      fprintf(stderr,"augment_external_command: loc_x:%d loc_y:%d height:%d width:%d start:%f sec/cm:%f\n",
            rec.r_left + *(v->x_offset),rec.r_top,rec.r_height ,
            rec.r_width - *(v->x_offset),start,seccm);
    sprintf(info," loc_x %d loc_y %d height %d width %d start %f sec/cm %f",
            rec.r_left + *(v->x_offset),rec.r_top,rec.r_height,
	    rec.r_width - *(v->x_offset),start,seccm);
    strcat(mess,info);
    return(mess);
  }
  show_notice(1, "Bad args to augment_external_command().");
  return(NULL);
}

/***********************************************************************/
char *
meth_return(ob,str)
     Object *ob;
     char *str;
{
  if(ob && str && *str) {
    int id;
    sscanf(str,"%d",&id);
    do_return_callback(id,get_next_item(str));
    return(ok);
  }
  return(null);
}

/***********************************************************************/

char *
meth_delete_item(ob, str)
    Object	*ob;
    char	*str;
{
    static char	menu[50];
    static char	name[100];
    static Selector
		a1 = {"menu",	"%s",	    menu,   NULL},
		a0 = {"name",	"#strq",    name,   &a1};

    *menu = '\0';
    *name = '\0';
    CHECK_QUERY(str, &a0)
      get_args(str, &a0);

    if (*name)
    {
	menu_change(name, "", XV_NULL, menu);
	return ok;
    }
    else
    {
	return null;
    }
}

/***********************************************************************/

char *
meth_delete_all(ob, str)
    Object	*ob;
    char	*str;
{
    static char menu[50];
    static Selector
		a0 = {"menu",	"%s",	    menu,   NULL};

    *menu = '\0';
    CHECK_QUERY(str, &a0)
      get_args(str, &a0);
    menu_clear(menu);
    return ok;
}

static void *ipc_callback_data = NULL;
void *in_a_ipc_dispatch();

/***********************************************************************/
char *
meth_pause(o,str)
     Object *o;
     char *str;
{
  CHECK_QUERY(str,NULL)
  command_paused = TRUE;
  ipc_callback_data = in_a_ipc_dispatch();
  return(ok);
}

/***********************************************************************/
char *
meth_detach(o,str)
     Object *o;
     char *str;
{
  static char name[NAMELEN];
  static Selector s1 = {"function", "%s", name, NULL};

  strcpy(name,"all");
  CHECK_QUERY(str,&s1)
    get_args(str,&s1);
  terminate(name);
  return(ok);
}
    
/***********************************************************************/
char *
meth_attach(o,str)
     Object *o;
     char *str;
{
  static char fname[NAMELEN];
  static Selector a1 = {"function", "%s", fname, NULL};

  CHECK_QUERY(str,&a1)
    if(get_args(str,&a1))
    start_external_function(fname);

  return(ok);
}

  
/***********************************************************************/
View *
get_first_view(o)
     Object *o;
{
  Signal *s;
  View *v = NULL;
  
  if(o) {
    s = (Signal*)o->signals;
    while(s && (!(v = s->views))) s = s->others;
  }
  return(v);
}

/***********************************************************************/
char *
meth_align(o,str)
     Object *o;
     char *str;
{
  extern char inputname[];
  static char file[MAXPATHLEN];
  static Selector a1= {"file", "%s", file, NULL};
  char *cp;
  Signal *s;

  *file = 0;
  /* Try to get the name of a data view to use as alignment model */
  CHECK_QUERY(str, &a1)
    if(get_args(str,&a1) && *file) {
    (void) apply_waves_input_path(file,file);
    cp = file;
  } else
    if(o && (o->signals)) cp = o->signals->name;

  if(o && (s = find_signal(o,cp)) && s->views &&
     do_align_views(o, s->views))
    return(ok);

  return(null);
}

/***********************************************************************/
char *
meth_active_channels(o,str)
     Object *o;
     char *str;
{
  extern char active_ids[], active_numbers[];
  Signal *s;
  View *v, *find_view();
  static char name[MAXPATHLEN], op[20];
  static Selector a0 = {"op", "%s", op, NULL},
                  a1 = {"file", "%s", name, &a0},
                  a2 = {"numbers", "#strq", active_numbers, &a1},
                  a3 = {"identifiers", "#strq", active_ids, &a2};

  *name = *active_numbers = *active_ids = 0;
  CHECK_QUERY(str, &a3)
    get_args(str,&a3);
  if (*name) 
    (void) apply_waves_input_path(name,name);

  if(*name && (s = find_signal(o,name)) && (v = find_view(s))) {
    if(*op && (strcmp(op, "set"))) {
      if(!strcmp(op,"clear")) {
	clear_active_channels(v);
      } else
	if(!strcmp(op,"add")) {
	  add_active_channels(v);
	}
    }
    set_active_channels(v);
    redoit(v->canvas);
    *active_numbers = *active_ids = 0;
    return(ok);
  }
  *active_numbers = *active_ids = 0;
  return(null);
}

/***********************************************************************/
char *
meth_move_markers(o,str)
     Object *o;
     char *str;
{
  static double time;
  static int do_left;
  static Selector a2 = {"time", "%lf", (char*)&time, NULL },
                  a1 = {"do_left", "%d", (char*)&do_left, &a2};
  View *v;

  CHECK_QUERY(str, &a1)
  if(v = get_first_view(o)) {
    time = 0.0;
    do_left = 1;
    
    if(get_args(str, &a1)) {
      move_markers(v, time, do_left);
      return(ok);
    }
  }
  return(null);
}

/***********************************************************************/
char *
meth_move_cursors(o,str)
     Object *o;
     char *str;
{
  static double time, freq;
  static int chan;
  static Selector a2 = {"time", "%lf", (char*)&time, NULL },
                  a1b = {"yval", "%lf", (char*)&freq, &a2},
                  a1 = {"frequency", "%lf", (char*)&freq, &a1b};

  View *v;
  
  CHECK_QUERY(str, &a1)
  if((v = get_first_view(o))) {
    time = v->cursor_time;
    freq = v->cursor_yval;

    if(get_args(str, &a1)) {
      move_cursors(v,time,freq);
      return(ok);
    }
  }
  return(null);
}

/***********************************************************************/
char *
meth_remap_colors(o,str)
     Object *o;
     register char *str;
{
  static double threshold;
  static char name[MAXPATHLEN];
  static  Selector a3 = {"file", "%s", name, NULL},
                   a2b = { "image_clip", "%lf", (char*)&image_clip, &a3 },
                   a1b = { "image_range", "%lf", (char*)&image_range, &a2b },
                   a2 = { "threshold", "%lf", (char*)&threshold, &a1b },
                   a1 = { "range", "%lf", (char*)&image_range, &a2 };
  Signal *s;
  View *v;
  char *p;
  
  CHECK_QUERY(str,&a1)
  threshold = -234.5;
  *name = 0;
  for(s = (Signal*)o->signals; s; s = s->others) /* find a spectrogram */
    if(s->views && ((s->type & SPECIAL_SIGNALS) == SIG_SPECTROGRAM)) break;
    get_args(str,&a1);
  if (*name) (void) apply_waves_input_path(name,name);
  if(s && ! *name) strcpy(name, s->name);
  if(*name && (s = find_signal(o,name)) && (v = s->views) &&
     v->canvas) {
    if(threshold != -234.5)
      image_clip = HI_SPECT_LIM - (threshold + image_range);
    limit_z_range(MAX_CMAP_SIZE - (cmap_size-CMAP_RESERVED));
    cmap_spect(v->canvas);
    return(ok);
  }
  return(null);
}

/***********************************************************************/
limit_z_range(total_range)
     int total_range;
{
  if(image_clip < 0)
    image_clip = 0;
  if(image_range < 1)
    image_range = 1;
  if((image_clip + image_range) >= total_range)
    image_clip = total_range - image_range - 1;
}

/***********************************************************************/
char *
meth_spectrogram(o,str)
     Object *o;
     register char *str;
{
  static double start, end, threshold;
  static char name[NAMELEN], type[200], output[NAMELEN];
  extern int next_x, next_y;
  extern double image_clip, image_range;
  extern char inputname[];
  static  Selector   b2b = { "image_clip", "%lf", (char*)&image_clip, NULL },