param.vtme

来自「speech signal process tools」· VTME 代码 · 共 924 行 · 第 1/3 页

.nf
 
.ft CW
	%plotsd
	%play
.ft LR

.fi
(i.e., without any command line options), the selected range of the same
file will be displayed and then played.  Note that \fIwaves\fP+ has a
mode (global parameter \fIwrite_common\fP non-zero) in which the ESPS
Common is written whenever the mouse is used to mark a segment of a
displayed ESPS file.  
.lp
For most ESPS programs, common file processing is enabled (i.e., parameter
file values will be superseded by Common file values if rules (2)-(3) or
(2)-(4) above apply).  Rule (4) was introduced to make it easier for ESPS
programs to do what users expect \- often, it would be annoying or a
mistake to use values from ESPS common unless one is processing the same
file that was being processed when ESPS common was written.  Which set of
rules applies can be determined from the "ESPS COMMON" section of the
manual pages.  
.sh 2 "Common File Location"
.lp
The default ESPS common file is
".espscom" in the user's home directory, but this can be reset by using
the ESPSCOM \s-1UNIX\s+1 environment variable, e.g.:  
.nf
.ft CW
.sp .5
    %setenv ESPSCOM /usr/shore/fftcommon
.sp .5
.fi
.ft LR
.sh 2 "User Control of Common Processing"
.lp
Before running an ESPS program, you can always disable common file
processing by removing the common file or touching the parameter file
(so that the common file is not younger than the parameter file).
Also, you can disable common processing completely by setting the Unix
environment variable USE_ESPS_COMMON to "off".  For example, with
\fIcsh\fP, the following will do the trick:
.nf
.ft CW

    %setenv USE_ESPS_COMMON off

.ft LR
.fi
.lp
In a \fIsh\fP script, common can be disabled by means of the following:
.nf
.ft CW

    USE_ESPS_COMMON=off
    export USE_ESPS_COMMON

.fi
.ft LR
.sh 2 "User Feedback of Parameter and Common file Processing"
.lp
Parameter sets for different ESPS programs can be combined in one parameter
file \- since each program only reads the parameters it needs, no harm is
done by having other parameters in the same file.  One result of this is
that some users prefer to maintain one large parameter file for all of the
programs they run.  This can be error prone as it's easy to forget what's
in such a file.  Further confusion can arise from common file processing,
since the final values for parameters can depend on the relative age of
the common file, on which program is being run, and on which programs have
been run previously.
.lp
For these reasons, ESPS provides a mechanism by which you can see 
the parameter values that actually are used by a particular program.  
The degree of feedback is determined by the Unix environment variable
ESPS_VERBOSE according to the following scheme (higher values of 
ESPS_VERBOSE include the feedback provided by lower values):
.bp
.nf

.TS
box,center,tab(/);
c s
c | c
c | lw(3i).
\fBESPS Parameter Processing Feedback\fP
_
ESPS_VERBOSE = /Feedback
_
0/no feedback
_
1/T{
reports if common is processed
T}
_
2 or greater/T{
reports parameter file used and individual parameter values 
as taken from the parameter file or the common file
T}
.TE

.fi
.lp
The default setting of ESPS_VERBOSE is 2.  As you become more 
experienced with ESPS, you should set a lower value for ESPS_VERBOSE
in your .login file.  
.nf
.ft CW
.lp
As an example, consider a case where the range of a sampled data
file is selected by running \fIplotsd\fP (1\-\s-1ESPS\s+1) followed
by \fIrange\fP (1\-\s-1ESPS\s+1):
.nf
.ft CW

    %plotsd test.sd
    %range

.ft LR
.fi
.lp
After \fIrange\fP finishes, the contents of ESPS Common is as follows:
.nf
.ft CW

    string filename = "test.sd";
    string prog = "range";
    int start = 192;
    int nan = 4251;
    int beginplot = 0;
    int endplot = 8000;

.ft LR
.fi
.lp
Next, suppose you run \fIrefcof\fP (1\-\s-1ESPS\s+1) with the 
following parameter file:
.ft CW
.nf

    int start = 1;
    int nan = 1024;
    int frame_len = 1024;
    int order = 10;

.fi
.ft LR
.lp
If ESPS_VERBOSE = 3, you would see the following output:
.nf
.ft CW

    %refcof test.sd test.spec
    read_params: Common processed.
    getsym_i: symbol start, value 192, taken from Common.
    getsym_i: symbol nan, value 4251, taken from Common.
    getsym_i: symbol frame_len, value 1024 taken from param file.
    getsym_i: symbol order, value 10 taken from param file.

.ft LR
.fi
.lp
If you happened to use the \fB\-l\fP0 option on \fIrefcof\fP (so that
the the full range is treated as a single frame), you would see the
following output:
.nf
.ft CW

    %refcof -l0 test.sd test.spec
    read_params: Common processed.
    getsym_i: symbol start, value 192, taken from Common.
    getsym_i: symbol nan, value 4251, taken from Common.
    getsym_i: symbol order, value 10 taken from param file.

.ft LR
.fi
.sh 1 "Format of Parameter and Common Files"
.lp
Parameter files and common files are written in
a C-like language. Parameters may have six types: integer, real (stored
as double precision values), string, character, array of integer, and
array of real. 
.lp
For each parameter, the parameter file contains the following: 
.ip
parameter type
.ip
parameter name
.ip
definite assigned value (operator "=") or indefinite assigned value
(operator "?=")
.ip
(optional) prompt string
.ip
(optional) parameter limitations (discrete choices or range of values)
.lp
If the assigned value for a parameter is indefinite (indicated by the
assignment operator "?=" or "=?"), then the user will be prompted for
the value to be used. The prompt will occur at runtime when the
corresponding \fIgetsym\fP (3\-\s-1ESPS\s+1) call is made.  If the
optional prompt string was supplied in the parameter file, that string
will be used as the prompt; otherwise the parameter name will be used.
If the user enters a RETURN in answer to the prompt, the default value
will be used.
.lp
If the optional parameter limitations are supplied, they are appended
to the prompt string that is used for indefinite assignments.  While
they are not enforced by the \fIgetsym\fP (3\-\s-1ESPS\s+1) routines,
the limitations are available to user programs by means of
\fIsymchoices\fP (3\-\s-1ESPS\s+1) and \fIsymrange\fP
(3\-\s-1ESPS\s+1).  (The program \fIxprompt\fP (1\-\s-1ESPS\s+1), for
example, does exploit this information.)  
.lp
A simplified grammar follows. In this grammar, parentheses indicate that the
contents may be repeated zero or more times. Square brackets indicate that
the contents are optional (zero or one repetitions). Vertical bars indicate
"or". CHRVAL, STRVAL, FLOVAL, and INTVAL represent legal C tokens for
characters, strings, real values, and integers respectively. IDENT
represents any legal C variable name, other than one of the reserved
keywords. Case is significant, and all characters of names are significant
(the restriction imposed by LEX, which builds the lexical analyzer, is about
200 characters). Most C escape sequences like '\en' are supported in
character and string constants. Character constants like '^b', meaning
control-b, are also supported. However, octal and hexadecimal numbers are
not supported. Multiline strings are not supported.
.(l
.ft CW
file      :==  ( statement )
statement :== type decl ( \fR'\fP,\fR'\fP decl ) \fR'\fP;\fR'\fP
type      :== "int" | "float" | "char" | "string" | "char *"
decl      :== IDENT assop value [prompt] [limits]
value     :== CHRVAL | STRVAL | FLOVAL | INTVAL | array
array     :== \fR'\fP{\fR'\fP num ( \fR'\fP,\fR'\fP num ) \fR'\fP}\fR'\fP
num       :== INTVAL | FLOVAL
prompt    :== \fR'\fP:\fR'\fP STRVAL
limits    :== choices | range
choices   :== \fR'\fP:\fR'\fP strarray
strarray  :== \fR'\fP{\fR'\fP STRVAL ( \fR'\fP,\fR'\fP STRVAL) \fR'\fP}\fR'\fP
range     :== \fR'\fP:\fR'\fP \fR'\fP[\fR'\fP num \fR'\fP,\fR'\fP num \fR'\fP]\fR'\fP 
assop     :== \fR'\fP=\fR'\fP | \fR'\fP=\fR'\fP \fR'\fP?\fR'\fP | \fR'\fP?\fR'\fP \fR'\fP=\fR'\fP
.ft CW
.)l
The following keywords are reserved: int, char, string, float,
yes, no, true, false. The keywords "yes" and "true" are treated
as integer constants with value one (the C convention for expressing
logical true); the keywords "no" and "false" are integer constants
with value zero.
.lp
The comment convention is different from C. It is the same as for the
C shell. A '#' character indicates that the rest of the line is a
comment, unless it is contained in a character or string constant.
This makes it easier to comment out lines.
.lp
Here is an example of a parameter file:
.(l
.ft CW
int order      ?= 10 : "Model order"; # ask for prompt
int verbose     = no;
#preemphasis specification
int preflg      = yes;
float pre_num   = { 0.9, -0.5 },   # zeros of preemph filter
      pre_den   = { 0.99, -0.99 }, # poles of preemph filter
      scale     = 0.25;
int frmlen     ?= 150: "Length of analysis window";
int nshft      ?= 180: "Distance between frames";
#method for autocorrelation computation
string method   = "BURG"; #Burg method
.ft LR
.)l
.sh 2 "Parameter Assignment Statements"
.lp
There are three types of assignment statements.
The most basic statement is something like
.(l
.ft CW
int M = 22;
.ft LR
.)l
In this type of statement, a symbol named M is created, assigned the type
integer and the value 22.  If the name has been declared previously, an
error occurs.  Type conversions, where sensible, work.  An integer or
character value may be assigned to a floating variable, and a character may
be assigned to an integer variable.  Integers in the range 0:127 may be
assigned to character variables.  Arrays may mix integers and floating
values, provided that the array is assigned to a floating variable.  Some
things that don't work:
.(l
.ft CW
int n    = 12.0; # cannot assign float to int
char q   = "a"; # cannot assign string (even 1 char) to char
string a = \fR'\fPc\fR'\fP; # cannot assign character to string
char a   = \fR'\fPb\fR'\fP, *c = "def"; # unlike C, "char *" is just
                            # a synonym for "string";
                            # no mixing allowed
.ft LR
.)l
The other two types of assignment statements attach a default value
to a variable and are indicated by adding a question mark to the
equal sign (either before or after). An optional prompt string may
appear, separated by a colon from the declaration.
.(l
.ft CW
int M ?= 22 : "Model order";
.ft LR
.)l
When an attempt is made to retrieve the value of M, the user is prompted.
If no prompt string is given, the variable name is used as the prompt.  The
default value is placed in square brackets:
.(l