comparison model/gen.c @ 0:5242703e91d3 tip

Initial checkin for AIM92 aimR8.2 (last updated May 1997).

+/*
+    Copyright (c) Applied Psychology Unit, Medical Research Council. 1988, 1989
+    ===========================================================================
+
+    Permission to use, copy, modify, and distribute this software without fee 
+    is hereby granted for research purposes, provided that this copyright 
+    notice appears in all copies and in all supporting documentation, and that 
+    the software is not redistributed for any fee (except for a nominal shipping 
+    charge). Anyone wanting to incorporate all or part of this software in a
+    commercial product must obtain a license from the Medical Research Council.
+
+    The MRC makes no representations about the suitability of this 
+    software for any purpose.  It is provided "as is" without express or implied 
+    warranty.
+ 
+*/
+
+/*
+	gen.c
+	=====
+
+    APU, ASP model demonstration program.
+
+
+    Copyright (c), 1989  The Medical Research Council, Applied Psychology Unit.
+
+
+    Authors : John Holdsworth (1989), Mike Allerhand (1990)
+
+
+    Edited  : M.Akeroyd 22-1-1993
+              Removed the conditional of `if (centering) Clear (w)' 
+	      (in plot_frame), so that Clear may be called for 
+	      PostScriptWindows that AREN'T centered, so allowing
+	      showpages to be generated.
+              See also edit to ps.c
+
+	    : M Akeroyd 3-8-1993
+              Added new options:
+		erbscale_efb (InputOption) mono_ctn (SilentOption)
+		colour_ctn (SilentOption) planemask_ctn (SilentOption)
+  	      Allowed "bitmap=stdout".
+
+	    : MAA 3rd August 1993
+              Extra options 
+	        framenumber (SilentOption), review (SilentOption)
+             
+            : MAA 22nd July 1994. 
+              Extra postscript options ALl silent
+                xstart_ps xend_ps ystart_ps yend_ps 
+                xtitle_ps ytitle_ps
+              Extra X options
+                fg_col bg_col
+
+            : MAA Summer 1984. Lots of postscript options. All silent
+  	       portraitstr, landscapestr;
+	       fontnamestr, fontsizestr;
+	       xmajorticksstr, xminorticksstr, ymajorticksstr, yminorticksstr;
+	       axistop, axisbottom, axisleft, axisright;
+            
+            : AJD Spring 1995.  
+              Added a new argument 'nwid' to the function SourceDraw, so that genspl
+              can have the necessary information. 
+
+            : AJD May, 1995.
+              Made options overlap, headroom, perspective, bytemax and type silent.
+*/
+
+
+#ifndef  lint
+static char *sccs_id = "@(#)gen.c	1.66 John Holdsworth, Mike Allerhand, Roy Patterson, Paul Manson (MRC-APU) 6/6/91" ;
+#endif
+
+
+/****************************************************************************
+* This module contains:
+*   Display option parameter strings.
+*   Model option parameter strings.
+*   File-format strings.
+*     X windows interface, (included from windows.h).
+*     Options handler routines, (included from options.h).
+*   Option defaults, (application specific).
+*   Strings for generic option types, (OnOption etc).
+*   Display options table, (displayopts[]).
+*     Model option tables, (included from table.c).
+*     Model entry-point functions, (included from model.c).
+*     Display drawing routines, (included from draw.h and fill.h).
+*   Options table construction, (constructOptions(), and mapOptions()).
+*   Main.
+****************************************************************************/
+
+#include <string.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <math.h>
+
+#if defined(THINK_C) || defined(NeXT)
+#include <stdlib.h>
+#endif
+
+/********************* Display option parameter strings *********************
+* The strings defined here are pointers referenced by the "value" field in
+* the display options table, displayopts. They are assigned to space which
+* initially contains defaults in the "defaultValue" field of the display
+* options table.
+****************************************************************************/
+
+static char *bmaxstr,   *topstr,    *botstr,    *overstr   ;
+static char *headstr,   *downcstr,  *heightstr, *helpstr   ;
+static char *invertstr, *lengthstr, *linstr,    *outstr    ;
+static char *reusestr,  *startstr,  *envstr,    *typestr   ;
+#ifdef X11
+static char *dispstr,   *erasestr,  *hiddenstr, *bitmapstr ;
+static char *kludgestr, *magstr,    *penstr,    *psfilestr ;
+static char *psstr,     *animstr,   *titlestr,  *viewstr   ;
+static char *widthstr,  *xstr,      *ystr                  ; 
+/* All these MAA. */
+char        *monostr,   *colourstr, *planemaskstr, *rotateaxesstr;
+char        *fgcolourstr, *bgcolourstr;                           
+char        *xstartstr, *ystartstr, *xendstr,   *yendstr;         
+char        *xnewtitlestr, *ynewtitlestr;        
+char        *portraitstr, *landscapestr;
+char        *fontnamestr, *fontsizestr, *titlesizestr;
+char        *xticksstr, *yticksstr, *outsidestr;
+char        *axistopstr, *axisbottomstr, *axisleftstr, *axisrightstr;
+char        *xmajorticksstr, *xminorticksstr, *ymajorticksstr, *yminorticksstr;
+char        *axislinewidthstr, *figurelinewidthstr;
+char        *boxstr;
+#endif  /* X11 */
+
+char *framenumberstr,  *reviewstr;            /* MAA: 3-8-1993 */
+
+static char *test1str,  *test2str,  *test3str,  *test4str  ;
+
+char headerstr[64] ;
+
+char *filestr ;
+
+/* application display parameters */
+
+#ifdef X11
+static char  *tiltstr = "0."       ;
+static char  *diststr = "0.5"      ;
+static char  *roomstr = "0%"       ;
+#endif  /* X11 */
+
+/*************** Included from glib (graphics library) directory ***********/
+
+#include "options.h"
+#include "defaults.h"
+
+#ifdef X11
+#include "windows.h"
+#endif  /* X11 */
+
+/******************* Strings for generic option values **********************
+* Generic option values, (ON_OPTION etc), are defined in options.h.
+* Convenience routines used to test or convert option values are:
+*  OptionStringsEqual( str1, str2 )     -(defined in options.c).
+*  isON( str )                          -(defined in options.h).
+*  isOFF( str )                         -(defined in options.c).
+*  isNULL( str )                        -(defined in options.c).
+*  OptionInt( str )                     -(defined in model.c).
+*  OptionDouble( str )                  -(defined in model.c).
+*  Samples( str )                       -(defined in model.c).
+*  Cycles( str, cfreq )                 -(defined in model.c).
+*  Scalar( str )                        -(defined in model.c).
+*  Freq( str )                          -(defined in model.c).
+*
+****************************************************************************/
+
+
+static char helpstring[200] = "no help initially" ;
+static char      OnOption[] =           ON_OPTION ;     /* "on"       */
+static char     OffOption[] =          OFF_OPTION ;     /* "off"      */
+static char    NullOption[] =         NULL_OPTION ;     /* "none"     */
+static char     CenterStr[] =            "center" ;
+static char     LengthStr[] =         "remainder" ;
+static char       LandStr[] =         "landscape" ;
+
+static int isEXCITE( str )
+char *str ;
+{
+    return ( strncmp( str, "excitation", strlen( str ) ) == 0 ) ;
+}
+
+static int isWATERFALL( str )
+char *str ;
+{
+    return ( strncmp( str, "waterfall", strlen( str ) ) == 0 ) ;
+}
+
+static int isGREYSCALE( str )
+char *str ;
+{
+    return ( strncmp( str, "greyscale", strlen( str ) ) == 0 ||
+	     strncmp( str, "grayscale", strlen( str ) ) == 0 ) ;
+}
+
+
+
+/************************* Options table ***********************************
+* The complete options table is built by constructOptions() according to the
+* application. It is composed of the display options, (displayopts[], below),
+* and the model option tables (from table.c) which are appropriate for the
+* application. The sequence of processing stages, (and hence model option
+* tables), for an application is determined by FindStage() in model.c.
+*
+* The complete options table is an array of Option structs.
+* The Option struct is defined in options.h as:
+*
+* typedef struct {
+*   char   *name           ;   The name of the option.
+*   char   *defaultValue   ;   Default value.
+*   char  **value          ;   Address of current value.
+*   char   *comment        ;   Something to print when the user types "-help".
+*   short   classification ;   Type of option it is.
+* } Option;
+*
+* The classification of options uses names defined in options.h:
+*   InputOption
+*   OutputOption
+*   InOutOption
+*   SilentOption
+*
+* Routines which access the option table:
+* Note: Some routines are called to supply arguments to other routines.
+*       Routines which access the option table in some way are denoted (*).
+*       Most of these routines are defined in options.c.
+*
+*                                 main()
+*                                   |
+*     +-----------------+-----------+----+-------+-----------------+
+*     |                 |                |       |                 |
+*     |                 |                | ModeledSource()         |
+*     |                 |                |       |                 |
+*     |                 |                | checkForFile()          |
+* helpopts()            |                |       |                 |
+*     |                 |                +---+---+                 |
+*     |                 |                    |                     |
+*     |              getopts()           readopts()           writeopts()
+*     |                 |                    |                     |
+*     |            getnopts(*)          readnopts()            writenopts(*)
+*     |   [arg countOptions(*)]   [arg countOptions(*)]  [arg countOptions(*)]
+*     |                 |                    |                     |
+*     |         +-------+------+             |            countBytesToWrite(*)
+*     |         |       |      |             |
+*     |         |       |      +------+------+
+*     |         |       |             |
+*     |         |       |      processOptionFile()
+*     |         |       |             |
+*     |         |       +------+------+
+*     |         |              |
+*     |         |        LookUpAndStore(*)
+*     |         |              |
+*     |         |          +---+---+----------+
+*     |         |          |       |          |
+*     |         +-----+----+    LookUp(*) Ambiguity(*)
+*     |         |     |
+*     +----+----+  updateOptionsFile(*)
+*          |
+*   defaultHelpHandler(*)
+*
+*
+* getopts()
+* Operates on the options table given to it as an argument.
+*  a) Each "value" field is initialized to its "defaultValue" field.
+*  b) The "value" fields are re-initialized by any corresponding values found
+*     in the options ("rc") file, (overriding the "defaultValue").
+*  c) The "value" fields are re-initialized again by any corresponding values
+*     found in command-line arguments.
+*  d) Special arguments are dealt with:
+*     "help"      calls the onLineHelpHandler() routine, (see below).
+*     "update"    calls the updateOptionsFile() routine.
+*  e) Return the remainder of the command-line (argc and argv) for use in
+*     main().
+*
+* helpopts()
+* Is called to print the help menu if no input file has been found by
+* getopts(), (in the "rc" file), and none remains on the command-line.
+* An alias for the onLineHelpHandler() function, which is in turn an
+* alias for the defaultHelpHandler() routine, (see options.c).
+*
+* readopts()
+* Read any options header which may be at the start of the input file.
+* Interpret the header like an options ("rc") file, and re-initialize any
+* corresponding "value" fields in the given options table, (as in getopts()).
+* Skip to the start of the input data, allowing for any offset (ie startstr).
+*
+* writeopts()
+* Write the given options table as an options header at the start of an o/p
+* file, if the "header" option is "on".
+*
+****************************************************************************/
+
+static  Option *options;
+
+/******************** Display options table ********************************
+* Options table for application display parameters.
+****************************************************************************/
+
+static  Option displayopts[] = {
+
+  /* Miscellaneous Silent Parameters (hidden from users) */
+
+
+ { "Version",      headerstr, &versionstr,      "Version number and date", OutputOption},
+
+ { "test1",              "0", &test1str,        "Dummy option for test and development", SilentOption},
+ { "test2",              "0", &test2str,        "Dummy option for test and development", SilentOption},
+ { "test3",              "0", &test3str,        "Dummy option for test and development", SilentOption},
+ { "test4",              "0", &test4str,        "Dummy option for test and development", SilentOption},
+
+ { "linear_sgm",   OffOption, &linstr,          "Linear frequency axis for spectrograms",SilentOption},
+ { "useprevious",  OffOption, &reusestr,        "Use previously stored output",          SilentOption},
+
+/* MAA: 21-8-1993 
+ * These next two options are here, because otherwise "gensgm -use ..." (at least) core dumps.
+ */
+ { "framenumber",  OffOption, &framenumberstr,  "Index of current frame (to stderr)\n",     SilentOption},
+ { "review",       OffOption, &reviewstr,       "Wait for keyboard <return> between frames",SilentOption},
+
+#ifdef X11
+ { "pstofile",     OffOption, &psfilestr,       "Send PostScript output to .ps file",    SilentOption},
+ { "invert",       OffOption, &invertstr,       "Invert axis of sai image",              SilentOption},
+ { "fast",         OffOption, &kludgestr,       "Speed up image generation",             SilentOption},
+#endif  /* X11 */
+
+  /* ( The order of the "help" option members is strange due to the way   */
+  /*   it was originally used.  See options.c: defaultHelpHandler() and   */
+  /*   updateOptionsFile() ).                                             */
+
+  /* Input Parameters */
+
+ { "envelope",     OffOption, &envstr,          "Type of model to use required",         SilentOption},
+ { "help",        "not used", &helpstr,         helpstring,                              SilentOption},
+
+#ifdef X11
+
+  /* Screen Output Parameters */
+
+ { "title",       "filename", &titlestr,  "Title of picture, or input filename",       InputOption},
+#ifdef THINK_C 
+ { "x0_win",            "10", &xstr,      "Left edge of window (pixels)",              InOutOption},
+ { "y0_win",            "50", &ystr,      "Lower edge of window (pixels)",             InOutOption},
+#else
+ { "x0_win",       CenterStr, &xstr,      "Left edge of window (pixels)",              InOutOption},
+ { "y0_win",       CenterStr, &ystr,      "Lower edge of window (pixels)",             InOutOption},
+#endif
+#ifdef PC
+ { "width_win",        "400", &widthstr,  "Window width (pixels)",                     InOutOption},
+ { "height_win",       "300", &heightstr, "Window height (pixels)\n",                  InOutOption},
+#else /* UNIX */
+ { "width_win",        "540", &widthstr,  "Window width (pixels)",                     InOutOption},
+ { "height_win",       "400", &heightstr, "Window height (pixels)\n",                  InOutOption},
+#endif
+ { "display",       OnOption, &dispstr,   "Select display of output image",            InOutOption},
+ { "view",           LandStr, &viewstr,   "Select display format",                     InOutOption},
+ { "top",             "1024", &topstr,    "Maximum of plotted range",                  InputOption},
+ { "bottom",         "-1024", &botstr,    "Minimum of plotted range",                  InputOption},
+ { "overlap",          "50%", &overstr,   "Overlap between channels",                  SilentOption}, /* AJD 16-5-95 */
+ { "headroom",          "0%", &roomstr,   "Headroom at top of picture",                SilentOption}, /* AJD 16-5-95 */
+ { "magnification",      "1", &magstr,    "Magnification of image in display",         InputOption},
+ { "pensize",            "1", &penstr,    "Size of plotted lines and dots",            InputOption},
+ { "hiddenline",    OnOption, &hiddenstr, "Hidden line removal\n",                       InputOption},
+ { "perspective",        "0", &tiltstr,   "Perspective view of display (degrees)\n",   SilentOption}, /* AJD 16-5-95 */
+#endif  /* X11 */
+
+ { "downchannel",  OffOption, &downcstr,  "Average adjacent frequency channels\n",     InOutOption},
+
+#ifdef X11
+
+  /* Auditory image cartoon parameters */
+
+ {   "erase_ctn",   OnOption, &erasestr,  "Erase display between cartoon frames",      InOutOption},
+ { "animate_ctn",  OffOption, &animstr,   "Animate cartoon",                           InOutOption},
+ {  "bitmap_ctn",  OffOption, &bitmapstr, "Produce cartoon output (.ctn)\n",           InputOption},
+ {    "mono_ctn",   OnOption, &monostr,   "Force monochrome (single plane) cartoons.", SilentOption},
+ {  "colour_ctn",  OffOption, &colourstr, "Force colour (multi-plane) cartoons.",      SilentOption},
+ {"planemask_ctn", "1", &planemaskstr,    "Planemask for creating cartoons.\n",        SilentOption},
+ {"fg_col",          "black", &fgcolourstr, "Foreground Colour.\n",                    SilentOption},
+ {"bg_col",          "white", &bgcolourstr, "Background Colour.\n",                    SilentOption},
+
+
+ /* Postscript options */
+
+ { "postscript",   OffOption, &psstr,     "Produce postscript output",                 InputOption},
+ { "rotateaxes",   OffOption, &rotateaxesstr,     "Rotate the axes labels in .ps output",  SilentOption},
+ { "xstart_ps",           "", &xstartstr, "Postscript x-axis: start point.",           SilentOption},
+ { "xend_ps",             "", &xendstr,   "Postscript x-axis: end point.",             SilentOption},
+ { "ystart_ps",           "", &ystartstr, "Postscript y-axis: start point.",           SilentOption},
+ { "yend_ps",             "", &yendstr,   "Postscript y-axis: end point.",             SilentOption},
+ { "xtitle_ps",           "", &xnewtitlestr, "Postscript x-axis: title.",              SilentOption},
+ { "ytitle_ps",           "", &ynewtitlestr, "Postscript x-axis: title.",              SilentOption},
+ { "portrait_ps",         "", &portraitstr, "Use 'portrait' page format",              SilentOption},
+ { "landscape_ps",        "", &landscapestr, "Use 'landscape' page format (overrides 'portriat)", SilentOption},
+ { "fontname_ps", "Helvetica", &fontnamestr, "Define font",              SilentOption},
+ { "fontsize_ps",       "12", &fontsizestr, "Define fontsize (points)",                     SilentOption},
+ { "fonttitlesize_ps",   "0", &titlesizestr, "Define fontsize for title (points)",                     SilentOption},
+ { "axislinewidth_ps",   "1", &axislinewidthstr, "Linewidth for axes & tickmarks (points)",                     SilentOption},
+ { "figurelinewidth_ps", "1", &figurelinewidthstr, "Linewidth for figures (points)",                     SilentOption},
+ { "xticks_ps",          "6", &xticksstr,   "Define size of x-axis (big) ticks (points)",   SilentOption},
+ { "yticks_ps",          "6", &yticksstr,   "Define size of y-axis (big) ticks' (points)",   SilentOption},
+ { "outsideticks_ps",OnOption, &outsidestr,   "Print tick-marks 'outside' figure",   SilentOption},
+ { "axistop_ps",    OnOption, &axistopstr,  "Print tick-marks on top side",   SilentOption},
+ { "axisbottom_ps", OnOption, &axisbottomstr, "Print tick-marks on bottom side",   SilentOption},
+ { "axisleft_ps",   OnOption, &axisleftstr, "Print tick-marks on left side",   SilentOption},
+ { "axisright_ps",  OnOption, &axisrightstr, "Print tick-marks on right side",   SilentOption},
+ { "xmajorticks_ps",  "1",   &xmajorticksstr, "Relative *spacing* of ticks",   SilentOption},
+ { "xminorticks_ps",  "1",   &xminorticksstr, "Relative *spacing* of ticks",   SilentOption},
+ { "ymajorticks_ps",  "1",   &ymajorticksstr, "Relative *spacing* of ticks",   SilentOption},
+ { "yminorticks_ps",  "1",   &yminorticksstr, "Relative *spacing* of ticks",   SilentOption},
+ { "box_ps",     OnOption,       &boxstr,                  "Plot a box",   SilentOption},
+#endif  /* X11 */
+
+  /* File Output Parameters */
+ { "output",       OffOption, &outstr,    "Produce output file",                       InputOption},
+ { "header",        OnOption, &headstr,   "Add a header to the output file\n",           InOutOption},
+ { "bytemax",          "255", &bmaxstr,   "Maximum value in byte output",              SilentOption}, /* AJD 16-5-95 */
+ { "type",           "short", &typestr,   "Output data type\n",                        SilentOption}, /* AJD 16-5-95 */
+
+ { "input_wave",  NullOption, &filestr,   "Default input file name",                   InputOption},
+ { "start_wave",       "0ms", &startstr,  "Start point in wave (ms)",                  InputOption},
+ { "length_wave",  LengthStr, &lengthstr, "Length of wave to process (ms)",            InputOption},
+
+ ( char * ) 0 } ;
+
+
+/*********************** Included from stitch directory ********************/
+
+/* interfaces to stitch system */
+
+#include "stitch.h"
+#include "source.h"
+#include "spiral.h"
+#include  "image.h"
+#include  "model.h"
+#include  "units.h"
+#include   "calc.h"
+#include    "ops.h"
+#include     "io.h"
+
+
+#ifdef X11
+#include   "draw.h"
+#include   "fill.h"
+#endif  /* X11 */
+
+/**************************************************************************/
+
+char *AlterSuffix() ;               /* alter suffix of file name. */
+#ifdef X11
+void save_frame(), plot_frame() ;   /* draw callbacks. */
+void fast_frame() ;
+#endif  /* X11 */
+
+extern char *genstate() ;
+static char *gen_state ;
+
+Source DownChannel() ;              /* reduce channels by averaging. */
+#ifdef X11
+Source PackShorts()  ;              /* pack output into one byte. */
+#endif  /* X11 */
+Source checkForFile() ;             /* create source from file if present. */
+
+#define POSTSCRIPT_FILE_SUFFIX ".ps"
+#define CARTOON_FILE_SUFFIX ".ctn"
+
+#ifdef X11
+static WindowObject display = 0 ;
+#endif  /* X11 */
+
+/***************************************************************************/
+
+/* Return length of the file in bytes */
+static long fileLength( fp )
+FILE *fp ;
+{
+    long posn = ftell( fp ) ;
+    long length = 0 ;
+
+    if( fseek( fp, 0l, 2 ) == 0 ) {
+
+	length = ftell( fp ) ;
+
+	(void) fseek( fp, posn, 0 ) ;
+    }
+
+    return ( length ) ;
+}
+
+/* per frame image handling */
+
+static FILE *inputFilePointer = ( FILE * ) 0 ;
+
+#ifdef X11
+
+static FILE *imageFilePointer = ( FILE * ) 0 ;
+static int   images = 0 ;
+static void (*frame_drawer)() ;
+
+/***** axis information *****/
+/*
+  "Axis" is defined in windows.h:143
+  The postscript program for drawing axis stuff is in axis.h
+*/
+
+static int Top()
+{
+    return ( atof( topstr ) / atof( magstr ) + 0.5 ) ;
+}
+
+static int Bot()
+{
+    if( atof( botstr ) < 0 )
+	return ( atof( botstr ) / atof( magstr ) - 0.5 ) ;
+    else
+	return ( atof( botstr ) / atof( magstr ) + 0.5 ) ;
+}
+
+static struct {
+  double min, max ;
+  char *label ;
+} xaxis, yaxis ;
+
+
+
+TimeAxis( min, max, label )
+double *min, *max ;
+char **label ;
+{
+    *min = Samples( startstr, Samplerate() ) / Samplerate()                                         ;
+    *max = Samples( startstr, Samplerate() ) / Samplerate() + Frames() * Framestep() / Samplerate() ;
+
+    if( *max > 1. )
+	*label = "Time [s]" ;
+    else {
+	*label = "Time [ms]" ;
+
+	*min *= 1000. ;
+	*max *= 1000. ;
+    }
+}
+
+MagnitudeAxis( min, max, label )
+double *min, *max ;
+char **label ;
+{
+    *min = Bot() ;
+    *max = Top() / ( 1. - atof( headstr ) / 100. ) ;
+
+    *label = "Magnitude" ;
+}
+
+
+static void DrawAxes( win )
+WindowObject win ;
+{
+    /* frame window with axes */
+
+    Axes( win, titlestr, xaxis.min, xaxis.max, xaxis.label,
+			 yaxis.min, yaxis.max, yaxis.label ) ;
+    return ;
+}
+
+#endif  /* X11 */
+
+/******************************* main **************************************
+* The following tables are used extensively:
+* stage table   Arrays of _stage structs, ("envelope", "fine", etc.), defined
+*               in routine FindStage() in model.c.
+* option table  Array of Option structs built at run-time by
+*               constructOptions() from displayopts, (in gen.c), and tables of
+*               model options included from table.c.
+*
+* Compiler switches for model versions are:
+*     FLOAT     For floating point version, (default uses integer arithmetic).
+*               Defined in calc.h.
+*
+* The model version number is the sccs <release-number>.<level-number> of
+* the file version.c. Refer to that file for incrementing the version number.
+* The version number is stored in versionstr in routine getversion().
+****************************************************************************/
+
+int    argc_save ;
+char **argv_save ;
+
+main( argc, argv )
+int argc ;
+char *argv[] ;
+#ifdef THINK_C
+{
+	static char *realargv[] = { "prog", "", 0 };
+	static char *progs = { "\pgenwav;-;\
+genfbm;genfbr;genfbc;genfbt;genfbd;gensai;genspl;gensas;-;\
+genbmm;gennap;gensai;-;gensgm;gencgm;gensas;-;genasa;genepn;gensep;-;Quit/Q" } ;
+	
+	extern char *MacMenu(), *MacFile() ;
+	
+	MacInit() ;
+
+	realargv[0] = MacMenu(progs) ;
+	realargv[1] = MacFile() ;
+
+	return ( real_main( sizeof( realargv ) / sizeof (*realargv) - 1, realargv ) ) ;
+}
+
+real_main( argc, argv )
+int argc ;
+char *argv[] ;
+#endif
+{
+    int    i ;
+    FILE *ofp = 0 ;
+    Source source ;
+    char *which, *psfilename ;
+    char title[256] ;
+    char *programName ;
+    int x, y, pixels, image, time ;
+    long headerSize, fileFramebytes ;
+    double *frequency_scale ;
+#ifdef X11
+    WindowObject psw = 0 ;
+    char *imageFileName ;
+#endif  /* X11 */
+
+/**************************************************************************
+* Determine which version of the model is required.
+* Set "which" to the last three chars of the program name, (allowing for
+* a ".exe" extension in the case of a PC version).
+**************************************************************************/
+
+
+    programName = argv[0] ;
+
+    which = programName + strlen( programName ) - strlen( "xxx" ) ;
+
+#ifdef PC
+    lowerArgs( argv, argc ) ;
+
+    which -= strlen( ".exe" ) ;
+#endif
+
+
+/***************************************************************************
+* Process arguments, (the model options):
+* Set option defaults (from option table in model.c).
+* Then override these by any options in the options file,
+* (the resource control file, eg .gensairc).
+* Finally, override these by any options given as command-line arguments.
+*
+* offsetOptions() finds the first option, (a ptr to one line of the "res"
+* array), required by the program. This gives a place mark in the options
+* table. (Note that the bottom of the options table, a null, corresponds with
+* the top of the help menu).
+* This first option appropriate to the program is found by looking it up in
+* the stage table (in model.c), and then cross-referencing the option name
+* with the names in the options table.
+*
+* Here is an example of an option, showing the members of the Options struct:
+*   name:         defaultValue: value:       comment:         classification:
+* {"length_wave", LengthStr,    &lengthstr, "Length of wave", InputOption},
+*
+* getopts() operates on the options between the given place mark and the
+* bottom of the table.
+* This is the only call to routine getopts(), which is defined in options.c.
+* First, each "value" is set to its corresponding "defaultvalue".
+* Then the options file (the "rc" file) is opened, and any options found there
+* are assigned to the corresponding "value", (overriding the "defaultvalue").
+* Then the command-line arguments are examined, and any options found there
+* are assigned to the corresponding "value", (overriding again).
+* Special arguments are dealt with:
+*   "help"      calls the onLineHelpHandler() routine, (see below).
+*   "update"    calls the updateOptionsFile() routine.
+*
+* Finally, leave the remainder of the command line (argc and argv).
+* Anything left on the command line is interpreted as follows:
+*   "filestr"   is the input data filename,
+*   "startstr"  is the start point in the data,
+*   "lengthstr" is the amount of data to process,
+*   "whichstr"  is the last 3 chars of the program name (the program version).
+*
+* Note that if no input file has been found by getopts(), (in the "rc" file),
+* and none remains on the command line, then helpopts() is called.
+* This is an alias for the onLineHelpHandler() function, which is in turn an
+* alias for the defaultHelpHandler() routine, (see options.c).
+*
+*
+***************************************************************************/
+
+    getversion( programName ) ;
+
+    /* The helpstring, defined in model.c, is stored as the comment field  */
+    /* of the help option (see table.c). It is accessed in options.c in    */
+    /* defaultHelpHandler(), using options[help].comment.                  */
+
+    (void) sprintf( helpstring, " [file_name]\n       Generates %s", modelHelp( which ) ) ;
+
+    options = constructOptions( which, displayopts ) ;
+
+
+    /* Hack to save argc and argv so they don't get mangled by getopts    */
+    /* This is so the command line args can override a reused file header */
+
+    argc_save = argc ;
+    argv_save = (char **)malloc( ( argc + 1 ) * sizeof( char *) ) ;
+    for ( i = 0 ; i < argc ; i++ ) {
+	argv_save[i] = (char *)malloc( ( strlen( argv[i] ) + 1 ) * sizeof( char ) ) ;
+	strcpy( argv_save[i], argv[i] ) ;
+    }
+
+    getopts( options, &argc, &argv ) ;
+
+    if( argc == 0 && isNULL( filestr ) ) {
+	(void) helpopts( options, programName ) ;
+	stitch_exit( -1 ) ;
+    }
+
+    if( argc > 0 && strcmp( *argv, "+" ) != 0 && argc-- > 0 )
+	filestr   = *argv++ ;
+
+    if( argc > 0 && strcmp( *argv, "+" ) != 0 && argc-- > 0 )
+	startstr  = *argv++ ;
+
+    if( argc > 0 && strcmp( *argv, "+" ) != 0 && argc-- > 0 )
+	lengthstr = *argv++ ;
+
+    if( isNULL( whichstr ) )
+	whichstr = which ;
+
+
+/***************************************************************************
+* horrrrrrrrible hack for now to try out -envelope option
+***************************************************************************/
+
+    if( isON( envstr ) )
+	if( whichstr[1] == 'b' )
+	    whichstr[1] =  'e' ;
+	else {
+	    /* map sai to sie and sas to sse */
+
+	    whichstr[1] = whichstr[2] ;
+	    whichstr[2] = 'e' ;
+	}
+
+
+/***************************************************************************
+* hack test arguments
+***************************************************************************/
+#if 00
+    test1 = atof( test1str ) ;
+    test2 = atof( test2str ) ;
+    test3 = atof( test3str ) ;
+    test4 = atof( test4str ) ;
+#endif
+
+/***************************************************************************
+* Open input data file, (use stdin if filename "-" is given).
+***************************************************************************/
+
+    if( strcmp( filestr, "-" ) == 0 )
+	inputFilePointer = stdin ;
+    else
+	inputFilePointer = fopen( filestr, readBinary ) ;
+
+/***************************************************************************
+* Position input data file pointer correctly:
+* Read any options header at the start of the input file. Set any options.
+* Skip to the start of the input data, allowing for any offset (ie startstr).
+* Set "framesstr" to the number of frames in the input data file, (here this
+* means the number of shorts remaining in the input file).
+* Create a source for the input data file.
+* Re-set "framesstr" to allow for a given "lengthstr", (ie not the whole file).
+***************************************************************************/
+
+    if( inputFilePointer != (FILE *) 0 ) {
+
+	readopts( options, inputFilePointer ) ;
+
+	headerSize = ftell( inputFilePointer ) ;
+
+	setFrames( fileLength( inputFilePointer ) / sizeof ( short ) - (long) Samples( startstr, Samplerate() ) ) ;
+
+	(void) fseek( inputFilePointer, (long)( headerSize + (long) Samples( startstr, Samplerate() ) * sizeof ( short ) ), 0 ) ;
+
+	source = FileSource( inputFilePointer ) ;
+    }
+
+    /* If a specific processing amount is specifed (other than "remainder") */
+    /* and this amount is less than the remainder of the input file, then   */
+    /* override the amount of data to process, (in framesstr).              */
+
+    if ( strncmp( lengthstr, LengthStr, strlen(lengthstr) ) != 0 &&
+			    Samples( lengthstr, Samplerate() ) < Frames() )
+	setFrames( (long) ( Samples( lengthstr, Samplerate() ) ) / Framestep() ) ;
+
+
+/***************************************************************************
+* Create source with data derived from processing file through model.
+* This may involve several stages of callback, and will initialize a chain of
+* objects which will ultimately execute the program, (see SinkSource() below).
+* If reusestr in "on", the "useprevious" option will use a previously
+* generated file, (see checkForFile() routine below).
+* If no input data file is found, report error: "could not open file".
+*
+* The routine ModeledSource() first uses Findstage() to find the appropriate
+* place in the stage table called for by the program, (see model.c).
+* Then it finds the end of the stage table, and works back up the table to
+* the stage called for by the program. Each stage in the table is a process
+* on the way to the program as a whole. The order of the stage table sets the
+* order of processing.
+* Immediately below are the only two calls to routine ModeledSource().
+***************************************************************************/
+
+    if( isON( reusestr ) )
+	source = ModeledSource( source, checkForFile ) ;
+    else
+	if( inputFilePointer != (FILE *) 0 )
+	    source = ModeledSource( source, (Source ( * )()) 0 ) ;
+
+    if( inputFilePointer == (FILE *) 0 )
+	stitch_error( "Could not open file \"%s\" for input\n", filestr ) ;
+
+/***************************************************************************
+* If the "downchannel" option is on, reduce channels by averaging.
+* (See DownChannel() routine below).
+* Then updateFramebytes sets  "framebytesstr" to the total number of bytes
+* in each frame, (ie the new width * height).
+***************************************************************************/
+
+
+    for( time=0 ; time<OptionInt( downcstr ) ; time++ ) {
+	source = DownChannel( source, Frameheight() ) ;
+	setFrameheight( Frameheight() / 2 ) ;
+    }
+    updateFramebytes() ;
+
+#if 0  /* for debugging */
+fprintf( stderr, "%d %d %d %d %ld\n",
+	Framewidth(),
+	Frameheight(),
+	Framebytes(),
+	Framestep(),
+	Frames() ) ;
+#endif
+
+/***************************************************************************
+* From here on is concerned with setting up for output, then starting the
+* processing, and finally cleaning up.
+***************************************************************************/
+
+#ifdef X11
+/* First sort out window placement. */
+
+    if( strcmp( xstr, CenterStr ) == 0 )
+	x = -1 ;
+    else
+	x = atoi( xstr ) ;
+
+    if( strcmp( ystr, CenterStr ) == 0 )
+	y = -1 ;
+    else
+	y = atoi( ystr ) ;
+
+    if( isGREYSCALE( viewstr ) )
+	pixels = 0 ;
+    else {
+	pixels = atoi( penstr ) ;
+
+	if( isON( hiddenstr ) && Frameheight() > 1 )
+
+	    pixels = -abs( pixels ) ;
+
+	/* Convert arguments for line-drawing. See draw.ch */
+	drawTilt     = atof( tiltstr ) ;
+	drawDistance = atof( diststr ) ;
+	drawHeadroom = atof( roomstr ) ;
+	drawOverlap  = atof( overstr ) / 100. ;
+#ifdef mips
+	if( pixels == 0 )
+	    pixels = 1 ;
+#endif
+    }
+#endif  /* X11 */
+
+    /* work out title of output */
+
+    (void) strcpy(  title, filestr ) ;
+    (void) strcat(  title, "." ) ;
+    (void) strncat( title, whichstr, strlen( "xxx" )+1 ) ;
+
+#ifdef X11
+
+    if( strcmp(titlestr,"filename") == 0)   /* was: if(isNULL(titlestr)) */
+	titlestr = title ;
+
+    /* calculate axis information */
+
+    if( isEXCITE( viewstr ) ) {
+	  ChannelAxis( &xaxis.min, &xaxis.max, &xaxis.label ) ;
+	MagnitudeAxis( &yaxis.min, &yaxis.max, &yaxis.label ) ;
+    }
+    else if( isWATERFALL( viewstr ) ) {
+	  ChannelAxis( &xaxis.min, &xaxis.max, &xaxis.label ) ;
+	     TimeAxis( &yaxis.min, &yaxis.max, &yaxis.label ) ;
+    }    /* landscape ones */
+    else if( Framewidth() > 1 ) {
+	    DelayAxis( &xaxis.min, &xaxis.max, &xaxis.label ) ;
+	  ChannelAxis( &yaxis.min, &yaxis.max, &yaxis.label ) ;
+    }
+    else {
+	     TimeAxis( &xaxis.min, &xaxis.max, &xaxis.label ) ;
+
+	if( Frameheight() > 1 )
+	  ChannelAxis( &yaxis.min, &yaxis.max, &yaxis.label ) ;
+	else
+	MagnitudeAxis( &yaxis.min, &yaxis.max, &yaxis.label ) ;
+
+    }
+
+
+    /* select outputs... */
+
+
+    /* select sai drawing method */
+
+    /* Hack so spiral parameters are independent of stage and option order */
+    /* (Spiral parameters appear late in options list, so are not known    */
+    /*  when an earlier stage is specified. So don't process unless sai).  */
+
+    if( strncmp(whichstr,"spl",strlen("spl")) == 0 ) {
+
+	frame_drawer = draw_spiral;
+
+	dotthresh_spl = Top() ;
+	dotsize_spl   = OptionInt(  penstr ) ;
+    }
+    else
+	frame_drawer = draw_frame;
+
+    /* screen output first         */
+    /* (set by option: display=on) */
+
+    if( isON( dispstr ) ) {
+
+	display = newDisplayWindow( titlestr, x, y, atoi( widthstr ), atoi( heightstr ), pixels ) ;
+
+	if( !isGREYSCALE( viewstr ) /* && OptionInt( penstr ) != 0 */ ) {
+
+		if( Top() == Bot() )
+		    stitch_error( "error: display top and bottom parameters the same value\n" );
+
+		if( isEXCITE( viewstr ) )
+		    source = SourceDraw( source, Bot(), Top(), display, Frameheight(), 1, Nwidth(), Frames(), save_frame, frame_drawer ) ;
+		else if( isWATERFALL( viewstr ) ) 
+		    source = SourceDraw( source, Bot(), Top(), display, Frameheight(),  Frames(), Nwidth(), 1, save_frame, frame_drawer ) ;
+		else if( !isON( kludgestr ) ) 
+		    source = SourceDraw( source, Bot(), Top(), display, Framewidth(), Frameheight(), Nwidth(), Frames(), save_frame, frame_drawer ) ; 
+		else {        /* speed-up for sai */
+		    source  = SourceDraw( source,    Bot(), Top(), display, Framewidth(), Frameheight(), Nwidth(), Frames(), save_frame, fast_frame  ) ;
+		    gen_state = genstate( display,   Bot(), Top(),          Framewidth(), Frameheight(), Nwidth(), Frames(), pixels ) ;
+		    frame_drawer=fast_frame ;
+		}
+	}
+	else {
+	    if( isON( erasestr ) )
+		Clear(   display ) ;
+
+	    DrawAxes( display ) ;
+
+	    if( isON( linstr ) )
+		frequency_scale = frequencies ;
+	    else
+		frequency_scale = (double *) 0 ;
+
+	    if( Framewidth() > 1 )
+		source = FillDown(   display, source, Top(), Bot(), Framewidth(), Frameheight() ) ;
+	    else
+		source = fillAcross( display, source, Top(), Bot(), Frameheight(),(int)Frames(), frequency_scale ) ;
+	}
+    }
+
+    /* postscript output next         */
+    /* (set by option: postscript=on) */
+
+    if( isON( psstr ) ) {
+
+	if( isON( psfilestr ) )
+	    psfilename = AlterSuffix( filestr, POSTSCRIPT_FILE_SUFFIX ) ;
+	else
+	    psfilename = (char *) 0 ;
+
+/* the extra argument to newPSWindow. MAA> 27-1-1993. */
+	psw = newPSWindow( psfilename, x, y, atoi(widthstr), atoi(heightstr), atoi( penstr ), isON( hiddenstr ) );
+
+	if( !isGREYSCALE( viewstr ) && OptionInt( penstr ) != 0 ) {
+
+		if( isEXCITE( viewstr ) )
+		    source = SourceDraw( source, Bot(), Top(), psw,     Frameheight(),            1, Nwidth(), Frames(), plot_frame, frame_drawer ) ;
+		else if( isWATERFALL( viewstr ) )
+		    source = SourceDraw( source, Bot(), Top(), psw,     Frameheight(),     Frames(),  Nwidth(),      1, plot_frame, frame_drawer ) ;
+		else
+		    source = SourceDraw( source, Bot(), Top(), psw,     Framewidth(), Frameheight(), Nwidth(), Frames(), plot_frame, frame_drawer ) ;
+	}
+	else { /* greyscale displays */
+
+	    if( isON( erasestr ) )
+		Clear(   psw ) ;
+
+	    DrawAxes( psw ) ;
+
+	    if( isON( linstr ) )
+		frequency_scale = frequencies ;
+	    else
+		frequency_scale = (double *) 0 ;
+
+	    if( Framewidth() > 1 )
+		source = FillDown(   psw, source, Top(), Bot(), Framewidth(), Frameheight() ) ;
+	    else
+		source = fillAcross( psw, source, Top(), Bot(), Frameheight(),(int)Frames(), frequency_scale ) ;
+	}
+    }
+
+
+    if( strcmp( typestr, "char" ) == 0 ) {
+	source = PackShorts( source ) ;
+	fileFramebytes = Framebytes() / sizeof ( short ) * sizeof ( char ) ;
+    }
+    else
+
+#endif  /* X11 */
+
+	fileFramebytes = Framebytes() ;
+
+    /* output to file */
+
+    if( !isOFF( outstr ) ) {
+
+	(void) unlink( title ) ;
+
+	if( OptionStringsEqual( outstr, OnOption ) )
+	    ofp = fopen( title,  writeBinary ) ;
+	else {
+	    if( strcmp( outstr, "stdout" ) == 0 )
+		ofp = stdout;
+	    else
+		ofp = fopen( outstr, writeBinary ) ;
+	}
+
+	if( ofp == (FILE *) 0 )
+	    stitch_error( "Unable to open file %s for output\n", title ) ;
+	else {
+	    if( isON( headstr ) )
+		writeopts( options, ofp ) ;
+
+	    source = FileTap( source, ofp ) ;
+	}
+    }
+
+#ifdef X11
+
+    /* output of screen "image" files in display format */
+    if( !isOFF( bitmapstr ) ) {
+      imageFileName = AlterSuffix(filestr, CARTOON_FILE_SUFFIX ) ;
+
+      if( (strcmp( bitmapstr, "stdout" ) == 0 )){
+           imageFilePointer = stdout;
+	   writeopts( options, imageFilePointer ) ;}
+      else 
+	if ( ( imageFilePointer = fopen(imageFileName, writeBinary ) ) == (FILE *) 0)
+	  stitch_error( "Unable to open file %s for image output\n", imageFileName ) ;
+	else
+	  writeopts( options, imageFilePointer ) ;}
+
+    if (( ofp == stdout ) && ( imageFilePointer == stdout ))
+        stitch_error( "Both 'output' and 'bitmap' set to stdout.\n", title);
+
+#endif  /* X11 */
+
+
+/***************************************************************************
+* Execute the program by pulling data from the source.
+* This is the only call to routine SinkSource(), which is defined in
+* stitch/source.c as sinkSource().
+* (SinkSource is an alias, defined in stitch/source.h, to cast the arguments).
+* Routine sinkSource() executes:  "(void) Pull( source, fileFramebytes ) ;"
+* for "Frames()" times in succession.
+* A chain of source objects, linked by callback-function pointers, was setup
+* earlier, (see call to ModeledSource() above).
+***************************************************************************/
+
+
+    SinkSource( source, fileFramebytes,   Frames() ) ;
+
+
+/***************************************************************************
+* Clean up and close
+****************************************************************************/
+
+    CloseSource( source ) ;
+
+    if( ofp != (FILE *) 0 )
+	(void) fclose( ofp ) ;
+
+#ifdef X11
+
+    if( psw != (WindowObject) 0 )
+	Close( psw ) ;
+
+    if( display != (WindowObject) 0 ) {
+
+	/* animate sai's if selected */
+
+	do
+	{
+	    for( image=1 ; image <= images ; image++ )
+		for( time = OptionInt( animstr ) ; time>0 ; time-- )
+		    Recall( display, image ) ;
+
+	    if( Pause( display ) == 'q' )
+		break;
+
+	} while( isON( animstr ) ) ;
+
+	Close( display ) ;
+    }
+
+#endif  /* X11 */
+
+    stitch_exit( 0 ) ;
+}
+
+/*************************** End main *************************************/
+
+/***************************************************************************
+* checkForFile()
+* Create source from file if present, to be used if reusestr in "on".
+* This is the "useprevious" option to use previously generated files.
+***************************************************************************/
+
+Source checkForFile( which )
+char *which ;
+{
+    static Source noSource = { (struct _source *) 0 } ;
+    long headerSize, fileFramebytes ;
+    char file_name[200] ;
+    FILE *tmp ;
+
+    (void) strcpy( file_name, filestr ) ;
+    (void) strcat( file_name, "."  ) ;
+    (void) strcat( file_name, which ) ;
+
+    if( ( tmp = fopen( file_name, readBinary ) ) != ( FILE * ) 0 ) {
+
+	inputFilePointer = tmp ;
+
+	(void) fprintf( stderr, "Using existing file \"%s\"\n", file_name ) ;
+
+	readopts( options, inputFilePointer ) ;
+
+	/* the saved command line overrides options from file header */
+
+	if( isON( reusestr ) )
+	    cmd_line_opts( options, &argc_save, &argv_save ) ;
+
+	headerSize = ftell( inputFilePointer ) ;
+
+	if( strcmp( typestr, "char" ) == 0 )
+	    fileFramebytes = Framebytes() / 2 ;
+	else
+	    fileFramebytes = Framebytes() ;
+
+	/*
+	If length=remainder then use the whole file.
+	Otherwise the length of the reused file is that given on the command
+	line, or the default length (if no length option is given).
+	*/
+
+	if ( strncmp( lengthstr, LengthStr, strlen(lengthstr) ) == 0 )
+	    setFrames( ( fileLength( inputFilePointer ) - headerSize ) / fileFramebytes - (long) Samples( startstr, Samplerate() ) / Framestep() ) ;
+	else
+	    setFrames( (long) ( Samples( lengthstr, Samplerate() ) ) / Framestep() ) ;
+
+
+	(void) fseek( inputFilePointer, headerSize + (long) Samples( startstr, Samplerate() ) / Framestep() * fileFramebytes, 0 ) ;
+
+#ifndef PC
+	if( strcmp( typestr, "char" ) == 0 )
+	    return( CharShortSource( FileSource( inputFilePointer ) ) ) ;
+	else
+#endif
+	    return(                  FileSource( inputFilePointer )   ) ;
+    }
+    else
+	return( noSource ) ;
+}
+
+/***************************************************************************
+* AlterSuffix().
+* Returns its argument fileName with a newSuffix appended in place of
+* any previous suffix it may have had. It should be noted that this
+* suffix must include any DOT it wishes to have appended to the name.
+***************************************************************************/
+
+/* File Name Suffix Conversion Parameters */
+
+#define BACKSLASH_CHAR  '\\'
+#define SLASH_CHARACTER '/'
+#define NULL_CHARACTER  '\000'
+#define DOT_CHARACTER '.'
+
+char *AlterSuffix(fileName, newSuffix)
+     char *fileName, *newSuffix;
+{
+  char *temp, *temp2, *lastPart;
+#if defined( PC )
+  int i;
+#endif
+
+  temp = stitch_malloc((unsigned) (strlen(fileName) + strlen(newSuffix) + 1), "AlterSuffix" );
+
+  temp = strcpy(temp, fileName);
+
+#if defined(PC)
+  /* Change all backslashes to forward slashes */
+  for (i = 0; temp[i] != NULL_CHARACTER; i++)
+    if (temp[i] == BACKSLASH_CHAR)
+      temp[i] = SLASH_CHARACTER;
+#endif
+  
+  if ((lastPart = strrchr(temp, SLASH_CHARACTER)) == NULL)
+    lastPart = temp;
+  else
+    lastPart++; /* Skip over the actual "/" */
+
+  /* lastPart points to the tail name of the path */
+
+  if ((temp2 = strchr(lastPart, DOT_CHARACTER)) == NULL)
+    temp = strcat(temp, newSuffix);
+  else
+    temp2 = strcpy(temp2, newSuffix);
+
+  return (temp);
+}
+
+#ifdef X11
+
+/***************************************************************************
+* Interceptions for various combinations of drawing.
+* An "interception function" is a function inserted into a chain a functions
+* linked by function pointers. The inserted function "intercepts" the
+* processing, to perform some transformation.
+****************************************************************************/
+
+/* intercept draw to store images for animation */
+
+void save_frame( state, frame, first )
+struct _draw_state *state ;
+short *frame ;
+int first ;
+{
+    if( first ) {
+	if( isON( erasestr ) )
+	    Clear( state->window ) ;
+
+	if( frame_drawer != (void (*)()) draw_spiral && state->framenumber == 1 )
+	    DrawAxes( state->window ) ;
+	}
+
+    frame_drawer( state, frame ) ;
+
+    if( isON( animstr ) && isOFF( kludgestr ) )
+	if( Store( state->window ) )
+	    ++images ;
+
+    if( isON( bitmapstr ) )
+	Write( state->window, imageFilePointer ) ;
+
+    return ;
+}
+
+/* hacky but effective faster frame drawing routine - for sai only! */
+
+void fast_frame( state, frame, first )
+struct _draw_state *state ;
+short *frame ;
+int first ;
+{
+    if( isON( animstr ) || images == 0 )
+	if( Store( state->window ) )
+	    ++images ;
+
+    /* generate image in current cleared image */
+
+    generate( gen_state, frame ) ;
+
+    /* then recal the window using the modified image */
+
+    Recall( state->window, images );
+
+    return ;
+}
+
+/* intercept plot to check if page should be output for printing */
+
+static int plot_wanted( state )
+struct _draw_state *state ;
+{
+#if !defined(PC)
+    if( display != ( WindowObject ) 0 && state->framewidth > 1 && state->frames > 1 ) {
+	(void) fprintf(stderr, "Hit \"y\" to include this image in the PostScript file: ");
+
+	switch ( Pause( display ) ) {
+
+	    case 'y' : case 'Y' :
+	    case 'p' : case 'P' :
+		return 1 ;
+
+	    default :
+		return 0 ;
+	}
+    }
+#endif
+    return 1 ;
+}
+
+void plot_frame( state, frame, first )
+struct _draw_state *state ;
+short *frame ;
+int first ;
+{
+    int centering = state->window->entries->x( state->window ) < 0 &&
+		    state->window->entries->y( state->window ) < 0 ;
+
+    if( isOFF( erasestr ) || state->framewidth == 1 || plot_wanted( state ) ) {
+
+	if( first && ( state->framenumber == 1 || isON( erasestr ) ) ) {
+/*  ***	    if( centering )   *** removed the conditional. M.Akeroyd. 22-1-1993.*/
+		Clear(   state->window ) ;
+
+	    if( frame_drawer != (void (*)()) draw_spiral )
+		DrawAxes( state->window ) ;
+	}
+
+	frame_drawer( state, frame ) ;
+    }
+
+    return ;
+}
+
+#endif  /* X11 */
+
+/***************************************************************************
+* downchannel: average across channels for output  (with special sai version)
+***************************************************************************/
+
+struct _down_channel_state {
+    struct _fillable_source parent ;
+    int channels ;
+    Source input ;
+} ;
+
+
+static Pointer down_channel_callback( state, bytes, buffer )
+struct _down_channel_state *state ;
+ByteCount *bytes ;
+short *buffer ;
+{
+    register int last = *bytes == 0 ;
+    register int chan, outchans = state->channels >> 1 ;
+    long frame, frames = ToPoints( short, *bytes ) / outchans ;
+    register short *iptr = PullItems( state->input, frames * state->channels, short ) ;
+    register short *bptr = buffer ;
+
+    for( frame=0 ; frame<frames ; frame++ ) {
+	for( chan=0 ; chan<outchans ; chan++ )
+	    *bptr++ = ( *iptr++ + *iptr++ ) / 2 ;
+
+	if( ( outchans << 1 ) != state->channels )
+	    iptr++ ;
+    }
+
+    if( !last )
+	return ( (Pointer) buffer ) ;
+    else
+	return ( DeleteFillableSource( state ) ) ;
+}
+
+static Pointer down_channel_callback_sai( state, bytes, buffer )
+struct _down_channel_state *state ;
+ByteCount *bytes ;
+short *buffer ;
+{
+    register int last = *bytes == 0 ;
+    register int chan, outchans = state->channels >> 1 ;
+    long frame, frames = ToPoints( short, *bytes ) / outchans ;
+    register short *iptr = PullItems( state->input, frames * state->channels, short ) ;
+    register short *bptr = buffer ;
+    register short *iptr2 ;
+
+    iptr2 = iptr + frames ;
+    for( chan=0 ; chan<outchans ; chan++ ) {
+	for( frame=0 ; frame<frames ; frame++ )
+	    *bptr++ = ( *iptr++ + *iptr2++ ) / 2 ;
+    }
+
+    if( !last )
+	return ( (Pointer) buffer ) ;
+    else
+	return ( DeleteFillableSource( state ) ) ;
+}
+
+
+Source DownChannel( source, channels )
+Source source ;
+{
+    DeclareNew( struct _down_channel_state *, state ) ;
+
+    state->channels = channels ;
+    state->input = source ;
+
+
+    /* Hack for special-case downchannel routine to handle format of sai and spl frames (mha: 22/6/93) */
+
+    if( strncmp(whichstr,"sai",strlen("sai")) == 0 ||
+	strncmp(whichstr,"spl",strlen("spl")) == 0    )
+
+	return ( SetFillableSource( state, down_channel_callback_sai, "down channeling sai frames" ) ) ;
+
+    return ( SetFillableSource( state, down_channel_callback, "down channeling" ) ) ;
+}
+
+
+#ifdef X11
+
+/***************************************************************************
+* Pack model output onto a single byte if required,
+* using greyscale Top() from display.
+***************************************************************************/
+
+typedef struct { struct _fillable_source parent ; Source input ; } *PackSource ;
+
+static Pointer pack_callback( state, bytes, buffer )
+PackSource state ;
+ByteCount *bytes ;
+Pointer buffer ;
+{
+    register int last = *bytes == 0 ;
+    register short  *iptr = PullShorts( state->input, *bytes ) ;
+    register Pointer optr = buffer ;
+    register Pointer eptr = buffer + *bytes ;
+    register int bytemax  = atoi( bmaxstr  ) ;
+    register int max      = Top() ;
+    register int min      = Bot() ;
+
+    while( optr < eptr )
+	if( *iptr > max ) {
+	    *optr++ = bytemax ;
+	     iptr++ ;
+	}
+	else if( *iptr < min ) {
+	    *optr++ = 0 ;
+	     iptr++ ;
+	}
+	else
+	    *optr++ = ( ( ( *iptr++ - min ) * bytemax + ( bytemax >> 1 ) ) / ( max - min ) ) & 0xff ;
+
+    if( !last )
+	return ( buffer ) ;
+    else
+	return ( DeleteFillableSource( state ) ) ;
+}
+
+
+Source PackShorts( input )
+Source input ;
+{
+    DeclareNew( PackSource, source ) ;
+
+    source->input = input ;
+
+    return ( SetFillableSource( source, pack_callback, "gen.c packing" ) ) ;
+}
+
+#endif  /* X11 */
+
+/***************************************************************************/
+
+#ifdef PC
+static lowerArgs( argv, argc )
+char **argv ;
+int argc ;
+{
+    register char *ptr ;
+    register int arg ;
+
+    for( arg=0 ; arg<=argc ; arg++ )
+	for( ptr=argv[arg] ; *ptr != '\000' ; ptr++ )
+	    if( isupper( *ptr ) )
+		*ptr = tolower( (int) *ptr ) ;
+    return ;
+}
+#endif
+
+
+/***************************************************************************
+* Set the value of versionstr to the model version number and current time.
+* The version number is the sccs <release-number>.<level-number> of the file
+* version.c. The current time is returned by ctime(time(0)).
+* This routine initializes the default version-string (headerstr), which is
+* later copied into the version-string (versionstr) during getopts().
+* In this way, the version-string is available for output at the head of
+* the help and the options (rc) files, and also output as part of the header,
+* (when output=on).
+* Note, the versionstr has to be quoted, otherwise the routine
+* processOptionFile in options.c will report an error (Detected Trailing...)
+* when it finds blanks within a line. This happens when trying to read an
+* options file, for example when reviewing. The addition of quotes enables
+* a line containing blanks to be read complete by the subroutine getName.
+***************************************************************************/
+
+#include "version.c"
+
+getversion( name )
+char *name ;
+{
+  char  releasestr[8] ;
+  char  levelstr[8]   ;
+  char  timestr[32]   ;
+  char *namestr       ;
+  long int  timeval   ;
+
+  sprintf(releasestr, "%d", atoi( version_Id ) ) ;
+  sprintf(levelstr, "%d", atoi( version_Id + strlen(releasestr) + 1 ) ) ;
+
+  if ( ( namestr = strrchr( name, '/' ) ) == (char *)0 )  namestr = name ;
+  else namestr++ ;
+
+#if defined( PC ) || defined( THINK_C )
+  sprintf(headerstr, "\"AIM MRC-APU Release R%s.%s [%s]\"", releasestr, levelstr, namestr ) ;
+#else
+  timeval = time(0);
+  sprintf(timestr,"%s", ctime(&timeval) ) ;
+  timestr[strlen(timestr) - 1] = '\0';  /* remove newline */
+  sprintf(headerstr, "\"AIM MRC-APU Release R%s.%s [%s] %s\"", releasestr, levelstr, namestr, timestr ) ;
+#endif
+
+}