## 34 Function list ¶

This chapter contains a list of functions currently defined within Festival available for general use. This list is automatically generated from the documentation strings of the functions as they are defined within the system, so has some chance in being up-to-date.

Note some of the functions which have origins in the SIOD system itself are little used in Festival and may not work fully, particularly, the arrays.

Cross references to sections elsewhere in the manual are given where appropriate.

`(% X Y)`

  Return X%Y.

`(%%closure ENVIRONMENT CODE)`

  Make a closure from given environment and code.

`(%%closure-code CLOSURE)`

  Return code part of closure.

`(%%closure-env CLOSURE)`

  Return environment part of closure.

`(%%stack-limit AMOUNT SILENT)`

  Set stacksize to AMOUNT, if SILENT is non nil do it silently.

`(* NUM1 NUM2 ...)`

  Returns the product of NUM1 and NUM2 ... An error is given is any argument is not a number.

`(*catch TAG . BODY)`

  Evaluate BODY, if a *throw occurs with TAG then return value specified by *throw.

`(*throw TAG VALUE)`

  Jump to *catch with TAG, causing *catch to return VALUE.

`(+ NUM1 NUM2 ...)`

  Returns the sum of NUM1 and NUM2 ... An error is given is any argument is not a number.

`(- NUM1 NUM2)`

  Returns the difference between NUM1 and NUM2. An error is given is any argument is not a number.

`(/ NUM1 NUM2)`

  Returns the quotient of NUM1 and NUM2. An error is given is any argument is not a number.

`(:backtrace [FRAME])`

  This function called *immediately* after an error will display a backtrace of the functions evaluated before the error. With no arguments it lists all stack frames, with the (possibly shortened) forms that were evaluated at that level. With a numeric argument it displays the form at that level in full. This function only works at top level in the read-eval-print loop (command interpreter). Note that any valid command will leave the backtrace stack empty. Also note that backtrace itself does not reset the backtrace, unless you make an error in calling it.

`(< NUM1 NUM2)`

  Returns t if NUM1 is less than NUM2, nil otherwise. An error is given is either argument is not a number.

`(<= NUM1 NUM2)`

  Returns t if NUM1 is less than or equal to NUM2, nil otherwise. An error is given is either argument is not a number.

`(> NUM1 NUM2)`

  Returns t if NUM1 is greater than NUM2, nil otherwise. An error is given is either argument is not a number.

`(>= NUM1 NUM2)`

  Returns t if NUM1 is greater than or equal to NUM2, nil otherwise. An error is given is either argument is not a number.

`(acos NUM)`

  Return arccosine of NUM.

`(acost:build_disttabs UTTTYPES PARAMS)`

  Built matrices of distances between each ling_item in each each list of ling_items in uttypes. Uses acoustic weights in PARAMS and save the result as a matrix for later use.

`(acost:file_difference FILENAME1 FILENAME2 PARAMS)`

  Load in the two named tracks and find the acoustic difference over all based on the weights in PARAMS.

`(acost:utt.load_coeffs UTT PARAMS)`

  Load in the acoustic coefficients into UTT and set the Acoustic_Coeffs feature for each segment in UTT.

`(add-doc-var VARNAME DOCSTRING)`

  Add document string DOCSTRING to VARNAME. If DOCSTRING is nil this has no effect. If VARNAME already has a document string replace it with DOCSTRING.

`(and CONJ1 CONJ2 ... CONJN)`

  Evaluate each conjunction CONJn in turn until one evaluates to nil. Otherwise return value of CONJN.

`(append L0 L1 ...)`

  Append each list to the first list in turn.

`(append LIST1 LIST2)`

  Returns LIST2 appended to LIST1, LIST1 is distroyed.

`(apply FUNC ARGS)`

  Call FUNC with ARGS as arguments.

`(apply_hooks HOOK OBJ)`

  Apply HOOK(s) to OBJ. HOOK is a function or list of functions that take one argument.

`(apply_method METHOD UTT)`

  Apply the appropriate function to utt defined in parameter.

`(approx-equal? a b diff)`

  True is the difference between a b is less than diff. This allows equality between floats which may have been written out and read in and hence have slightly different precision.

`(aref ARRAY INDEX)`

  Return ARRAY[INDEX]

`(aset ARRAY INDEX VAL)`

  Set ARRAY[INDEX] = VAL

`(asin NUM)`

  Return arcsine of NUM.

`(assoc KEY A-LIST)`

  Return pair with KEY in A-LIST or nil.

`(assoc_string key alist)`

  Look up key in alist using string-equal. This allow indexing by string rather than just symbols.

`(assq ITEM ALIST)`

  Returns pairs from ALIST whose car is ITEM or nil if ITEM is not in ALIST.

`(atan NUM)`

  Return arctangent of NUM.

`(atom X)`

  True if X is not a cons cells, nil otherwise.

`(audio_mode MODE)`

  Control audio specific modes. Five subcommands are supported. If MODE is async, start the audio spooler so that Festival need not wait for a waveform to complete playing before continuing. If MODE is sync wait for the audio spooler to empty, if running, and they cause future plays to wait for the playing to complete before continuing. Other MODEs are, close which waits for the audio spooler to finish any waveforms in the queue and then closes the spooler (it will restart on the next play), shutup, stops the current waveform playing and empties the queue, and query which lists the files in the queue. The queue may be up to five waveforms long. [see Audio output]

`(backquote FORM)`

  Backquote function for expanding forms in macros.

`(basename PATH SUFFIX)`

  Return a string with directory removed from basename. If SUFFIX is specified remove that from end of PATH. Basically the same function as the UNIX command of the same name.

`(begin . BODY)`

  Evaluate s-expressions in BODY returning value of from last expression.

`(english_token_to_words TOKENSTREAM TOKENNAME)`

  Returns a list of words expanded from TOKENNAME. Note that as this function may be called recursively TOKENNAME may not be the name of TOKENSTREAM.

`(Builtin_PostLex UTT)`

  Post-lexical rules. Currently only vowel reduction applied to each syllable using postlex_vowel_reduce_cart_tree, and the table of vowel reduction pairs in postlex_vowel_reduce_table.

`(caar X)`

  Return the (car (car X)).

`(caddr X)`

  Return the (car (cdr (cdr X))).

`(cadr X)`

  Return the (car (cdr X)).

`(car DATA1)`

  Returns car of DATA1. If DATA1 is nil or a symbol, return nil.

`(cd DIRNAME)`

  Change directory to DIRNAME, if DIRNAME is nil or not specified change directory to user’s HOME directory.

`(cdar X)`

  Return the (cdr (car X)).

`(cdddr X)`

  Return the (cdr (cdr (cdr X))).

`(cddr X)`

  Return the (cdr (cdr X)).

`(cdr DATA1)`

  Returns cdr of DATA1. If DATA1 is nil or a symbol, return nil.

`(cl_mapping UTT PARAMS)`

  Impose prosody up to some percentage, and not absolutely.

`(Pauses UTT)`

  Predict pause insertion.

`(Classic_Phrasify UTT)`

  Creates phrases from words, if pos_supported is non-nil, a more elaborate system of prediction is used. Here probability models based on part of speech and B/NB distribution are used to predict breaks. This system uses standard Viterbi decoding techniques. If pos_supported is nil, a simple CART-based prediction model is used. [see Phrase breaks]

`(Classic_POS UTT)`

  Predict part of speech tags for the existing word stream. If the variable pos_lex_name is nil nothing happens, otherwise it is assumed to point to a lexicon file giving part of speech distribution for words. An ngram model file should be in pos_ngram_name. The system uses standard Viterbi decoding techniques. [see POS tagging]

`(Classic_PostLex utt)`

  Apply post lexical rules (both builtin and those specified in postlex_rules_hooks).

`(Classic_Word UTT)`

  Build the syllable/segment/SylStructure from the given words using the Lexicon. Uses part of speech information in the lexicon look up if present.

`(clunits:list)`

  List names of currently loaded cluster databases.

`(clunits:load_all_coefs FILEIDLIST)`

  Load in coefficients, signal and join coefficients for each named fileid. This is can be called at startup to to reduce the load time during synthesis (though may make the image large).

`(clunits:load_db PARAMS)`

  Load index file for cluster database and set up params, and select it.

`(clunits:select NAME)`

  Select a previously loaded cluster database.

`(Clunits_Get_Units UTT)`

  Construct Unit relation from the selected units in Segment and extract their parameters from the clunit db.

`(Clunits_Select UTT)`

  Select units from current databases using cluster selection method.

`(Clunits_Simple_Wave UTT)`

  Naively concatenate signals together into a single wave (for debugging).

`(Clunits_SmoothedJoin_Wave UTT)`

  smoothed join.

`(Clunits_Windowed_Wave UTT)`

  Use hamming window over edges of units to join them, no prosodic modification though.

`(combine_waves)`

  Join all the waves together into the desired output file and delete the intermediate ones.

`(compile-file FILENAME)`

  Compile lisp forms in FILENAME.scm to FILENAME.bin.

`(compile_library)`

  Compile all the scheme files in the library directory.

`(cons DATA1 DATA2)`

  Construct cons pair whose car is DATA1 and cdr is DATA2.

`(cons-array DIM KIND)`

  Construct array of size DIM and type KIND. Where KIND may be one of double, long, string or lisp.

`(copy-list LIST)`

  Return new list with same members as LIST.

`(cos NUM)`

  Return cosine of NUM.

`(debug_output ARG)`

  If ARG is non-nil cause all future debug output to be sent to cerr, otherwise discard it (send it to /dev/null).

`(def_feature_docstring FEATURENAME FEATUREDOC)`

  As some feature are used directly of stream items with no accompanying feature function, the features are just values on the feature list. This function also those features to have an accompanying documentation string.

`(define (FUNCNAME ARG1 ARG2 ...) . BODY)`

  Define a new function call FUNCNAME with arguments ARG1, ARG2 ... and BODY.

`(defmac-macro MACRONAME FORM)`

  Define a macro. Macro expand FORM in-line.

`(defPhoneSet PHONESETNAME FEATURES PHONEDEFS)`

  Define a new phoneset named PHONESETNAME. Each phone is described with a set of features as described in FEATURES. Some of these FEATURES may be significant in various parts of the system. Copying an existing description is a good start. [see Phonesets]

`(defSynthType TYPE . BODY)`

  Define a new wave synthesis type. TYPE is an atomic type that identifies the type of synthesis. BODY is evaluated with argument utt, when utt.synth is called with an utterance of type TYPE. [see Utterance types]

`(defUttType TYPE . BODY)`

  Define a new utterance type. TYPE is an atomic type that is specified as the first argument to the function Utterance. BODY is evaluated with argument utt, when utt.synth is called with an utterance of type TYPE. You almost always require the function Initialize first. [see Utterance types]

`(delete-file FILENAME)`

  Delete named file.

`(delq ITEM LIST)`

  Destructively delete ITEM from LIST, returns LIST, if ITEM is not first in LIST, cdr of LIST otherwise. If ITEM is not in LIST, LIST is returned unchanged.

`(describe_all_modules)`

  Print descriptions of all proclaimed modules

`(describe_module MOD)`

  Describe the module named by the symbol MOD.

`(diphone_present? STR)`

  Checks whether the given STRing corresponds to any diphone in the current database.

`(directory-entries DIRECTORY &opt NOFLAGDIR)`

  Return a list of the entries in the directory. If NOFLAGDIR is non-null don’t check to see which are directories.

`(display utt)`

  Display an utterance’s waveform, F0 and segment labels in Xwaves. Xwaves must be running on the current machine, with a labeller for this to work.

`(doc SYMBOL)`

  Return documentation for SYMBOL.

`(Donovan_Init PARAMS)`

  Initialize the Donovan LPC diphone database. PARAMS are an assoc list of parameter name and value. The two parameters are index_file (value is a pathname for "diphlocs.txt") and diphone_file (value is a pathname for "lpcdiphs.bin"). [see LPC diphone synthesizer]

`(Donovan_Synthesize UTT)`

  Synthesize a waveform using the Donovan LPC diphone synthesizer. This is called from Synthesize when the Synth_Method Parameter has the value Donovan. [see LPC diphone synthesizer]

`(downcase SYMBOL)`

  Returns a string with the downcased version of SYMBOL’s printname.

`(du_voice.get_jc_f0_weight DU_VOICE)`

  Gets the joincost f0 weight

`(du_voice.get_jc_f0_weight DU_VOICE)`

  Gets the joincost f0 weight

`(du_voice.get_jc_f0_weight DU_VOICE)`

  Gets the joincost f0 weight

`(du_voice.getDiphoneCoverage DU_VOICE FILENAME)`

  prints diphone coverage information for this voice use filename ’-’ for stdout.

`(du_voice.precomputeJoinCosts DU_VOICE PHONELIST)`

  Calculate and store the join costs for all instances of phones present in the phone list.

`(du_voice.prosodic_modification DU_VOICE)`

  Status of prosodic modification on or off.

`(du_voice.regetUnits DU_VOICE UTT)`

  Voice object DU_VOICE looks at the unit relation in utterance UTT redoes the viterbi, respecting candidates flagged for omission

`(du_voice.set_jc_f0_weight DU_VOICE FLOAT)`

  Sets the joincost f0 weight (default 1)

`(du_voice.set_jc_power_weight DU_VOICE FLOAT)`

  Sets the joincost power weight (default 1)

`(du_voice.set_jc_spectral_weight DU_VOICE FLOAT)`

  Sets the joincost spectral weight (default 1)

`(du_voice.set_ob_pruning_beam DU_VOICE BEAMFLOAT)`

  Sets the observation beam pruning parameter for Viterbi search

`(du_voice.set_prosodic_modification DU_VOICE INT)`

  Turns prosodic modification on or off (default is 0 [off]) This will only work if durations and f0 targets are provided

`(du_voice.set_pruning_beam DU_VOICE BEAMFLOAT)`

  Sets the beam pruning parameter for Viterbi search

`(du_voice.set_target_cost_weight DU_VOICE FLOAT)`

  Sets the target cost weight (default is 1)

`(du_voice.set_tc_rescoring_beam DU_VOICE BEAMFLOAT)`

  Sets the target cost rescoring beam width for Viterbi search (set to -1.0 to disable)

`(du_voice.set_tc_rescoring_weight DU_VOICE WEIGHTFLOAT)`

  Sets the target cost rescoring weight for Viterbi search (set to 0.0 to disable)

`(du_voice.setDiphoneBackoff DU_VOICE LIST)`

  Adds diphone backoff rules to the voice.

`(du_voice.setJoinCost DU_VOICE JOINCOST)`

  Sets the voice joincost function. If t is specified then the default joincost is used.

`(du_voice.setTargetCost DU_VOICE TARGETCOST)`

  Sets the voice targetcost function. If t is specified then the default targetcost is used. If nil is specified then a null targetcost is used. If a closure is specified, this is called as the target cost. If ’apml is specified and apml targetcost is uses.

`(du_voice_function DU_VOICE)`

  Does something to a DU_VOICE only

`(Duration utt)`

  Predict segmental durations using Duration_Method defined in Parameters. Four methods are currently available: averages, Klatt rules, CART tree based, and fixed duration.

`(Duration_Averages UTT)`

  Label all segments with their average duration found from the assoc list of phone names to averages in phoneme_durations. This module is called through the module Duration when the Parameter Duration_Method is set to Averages. [see Average durations]

`(Duration_Default UTT)`

  Label all segments with a fixed duration of 100ms. This module is called through the module Duration when the Parameter Duration_Method is unset or set to Default. [see Default durations]

`(duration_find_stretch utt seg)`

  Find any relavant duration stretch.

`(Duration_Klatt UTT)`

  This uses an implementation of the Klatt Duration rules to predict durations for each segment in UTT. It uses the information in duration_klatt_params for mean and lower bound for each phone. This module is called through the module Duration when the Parameter Duration_Method is set to Klatt. This method modifies its predicted durations by the factor set in the Parameter Duration_Stretch (if set). [see Klatt durations]

`(Duration_LogZScores utt)`

  Predicts duration to segments using the CART tree in duration_logzscore_tree and duration_logzscore_tree_silence which produces a zscore of the log duration. The variable duration_logzscore_ph_info contains (log) means and std for each phone in the set.

`(Duration_Tree UTT)`

  Uses the CART tree in duration_cart_tree to predict absolute durations for each segment in UTT. This module is called through the module Duration when the Parameter Duration_Method is set to Tree. This method modifies its predicted durations by the factor set in the Parameter Duration_Stretch (if set). [see CART durations]

`(Duration_Tree_ZScores UTT)`

  Uses the CART tree in duration_cart_tree to predict z scores duration values for each segment in UTT. The z scores are converted back to absolute values by the assoc list of phones to means and standard deviations in the variable duration_ph_info. This module is called through the module Duration when the Parameter Duration_Method is set to Tree_ZScores. This method modifies its predicted durations by the factor set in the Parameter Duration_Stretch (if set). [see CART durations]

`(duration_unzscore phname zscore table)`

  Look up phname in table and convert xscore back to absolute domain.

`(english_token_to_words TOKEN NAME)`

  Returns a list of words for NAME from TOKEN. This allows the user to customize various non-local, multi-word, context dependent translations of tokens into words. If this function is unset only the builtin translation rules are used, if this is set the builtin rules are not used unless explicitly called. [see Token to word rules]

`(env-lookup VARNAME ENVIRONMENT)`

  Return value of VARNAME in ENVIRONMENT.

`(eof_val)`

  Returns symbol used to indicate end of file. May be used (with eq?) to determine when end of file occurs while reading files.

`(eq? DATA1 DATA2)`

  Returns t if DATA1 and DATA2 are the same object.

`(equal? A B)`

  t if s-expressions A and B are recursively equal, nil otherwise.

`(eqv? DATA1 DATA2)`

  Returns t if DATA1 and DATA2 are the same object or equal numbers.

`(error MESSAGE DATA)`

  Prints MESSAGE about DATA and throws an error.

`(eval DATA)`

  Evaluate DATA and return result.

`(exit [RCODE])`

  Exit from program, if RCODE is given it is given as an argument to the system call exit.

`(exp NUM)`

  Return e**NUM.

`(extract_tokens FILE TOKENS OUTFILE)`

  Find all occurrences of TOKENS in FILE and output specified context around the token. Results are appended to OUTFILE, if OUTFILE is nil, output goes to stdout.

`(f2b_lts WORD FEATURES)`

  Letter to sound rule system for f2b (American English), uses the NRL LTS ruleset and maps the result to the radio phone set.

`(fasdump FILENAME FORMS)`

  Fast dump FORMS into FILENAME.

`(fasl-close TABLE)`

  Close fasl table.

`(fasl-open FILENAME MODE)`

  Open fasl FILENAME as MODE. Returns a fasl-table.

`(fasload FILENAME ARGS)`

  Fast load FILENAME.

`(fasload_library FILENAME)`

  Load binary file from library

`(fast-print P TABLE)`
`(fast-read TABLE)`
`(fclose FILEP)`

  Close filepoint FILEP.

`(feats.get FEATS FEATNAME)`

  Return value of FEATNAME (which may be a simple feature name or a pathname) in FEATS. If FEATS is nil a new feature set is created

`(feats.make)`

  Return an new empty features object.

`(feats.present FEATS FEATNAME)`

  Return t is FEATNAME is present in FEATS, nil otherwise.

`(feats.remove FEATS FEATNAME)`

  Remove feature names FEATNAME from FEATS.

`(feats.set FEATS FEATNAME VALUE)`

  Set FEATNAME to VALUE in FEATS.

`(feats.tolisp FEATS)`

  Gives a lisp representation of the features, this is a debug function and may or may not exist tomorrow.

`(feats.value_sort FEATURES NAME)`
`(festival_warranty)`

  Display Festival’s copyright and warranty. [see Copying]

`(fflush FILEP)`

  Flush FILEP. If FILEP is nil, then flush stdout.

`(find_month_from_number token string-number)`

  Find the textual representation of the month from the given string number

`find_peak_seg_anchor ie pk_pos`

  Part of the workings of peak_segment_anchor.

`(Fixed_Prosody UTT)`

  Add fixed duration and fixed monotone F0 to the sgements in UTT. Uses values of FP_duration and FP_F0 as fixed values.

`(flatten LIST)`

  Return flatend list (list of all atoms in LIST).

`(fopen FILENAME HOW)`

  Return file pointer for FILENAME opened in mode HOW.

`(format FD FORMATSTRING ARG0 ARG1 ...)`

  Output ARGs to FD using FROMATSTRING. FORMATSTRING is like a printf formatstrng. FD may be a filedescriptor, or t (standard output) or nil (return as a string). Note not all printf format directive are supported. %l is additionally support for Lisp objects. [see Scheme I/O]

`(fread BUFFER FILE)`

  BUFFER is a string of length N, N bytes are read from FILE into BUFFER.

`(fseek FILEP OFFSET DIRECTION)`

  Position FILEP to OFFSET. If DIRECTION is 0 offset is from start of file. If DIRECTION is 1, offset is from current position. If DIRECTION is 2 offset is from end of file.

`(ftell FILEP)`

  Returns position in file FILEP is currently pointing at.

`(fwarning MODE)`

  For controlling various levels of warning messages. If MODE is nil, or not specified stop all warning messages from being displayed. If MODE display warning messages.

`(fwrite BUFFER FILE)`

  Write BUFFER into FILE.

`(gc)`

  Collect garbage now, where gc method supports it.

`(gc-status OPTION)`

  Control summary information during garbage collection. If OPTION is t, output information at each garbage collection, if nil do gc silently.

`(Gen_Viterbi UTT)`

  Applies viterbi search algorithm based on the parameters in gen_vit_params. Basically allows user candidate selection function combined with ngrams.

`(get SYM KEY)`

  Get property named KEY for SYM.

`(get_anchor_value sylSyl seg_num)`

  Gets the c/v value of the segment within a syllable.

`(get_param name params default)`

  Get named parameters in params returning default if its not present.

`(get_url URL OUTFILE)`

  Get URL and put contents in OUTFILE. Currently only http, and file type URLs are supported.

`(getc FILEP)`

  Get next character from FILEP. Character is returned as a number. If FILEP is nil, or not specified input comes from stdin.

`(getenv VARNAME)`

  Returns value of UNIX environment variable VARNAME, or nil if VARNAME is unset.

`(getpid)`

  Return process id.

`(href TABLE KEY)`

  Return value in hash table TABLE with KEY.

`(hset TABLE KEY VALUE)`

  Set hash table TABLE KEY to VALUE.

`(hts21_mlsa_resynthesis TRACK)`

  Return a WAVE synthesized from the F0/MCEP TRACK.

`(HTS21_Synthesis UTT)`

  Synthesize a waveform using the HTS 2.1 Engine and the current models

`(HTS_Synthesis UTT)`

  Synthesize a waveform using the hts_engine and the current models

`(if COND TRUEPART FALSEPART)`

  If COND evaluates to non-nil evaluate TRUEPART and return result, otherwise evaluate and return FALSEPART. If COND is nil and FALSEPART is nil, nil is returned.

`(Initialize UTT)`

  This module should be called first on all utterances it does some necessary initialization of the utterance and loads the base streams with the information from the input form.

`(insert_final_pause UTT)`

  Always have a final silence if the utterance is non-empty.

`(insert_initial_pause UTT)`

  Always have an initial silence if the utterance is non-empty. Insert a silence segment after the last segment in WORDITEM in UTT.

`(insert_pause UTT WORDITEM)`

  Insert a silence segment after the last segment in WORDITEM in UTT.

`(Int_Targets utt)`

  The second stage in F0 prediction. This generates F0 targets related to segments using one of three methods, a simple hat, linear regression based on ToBI markings, and a simple declining slope. This second part deals with actual F0 values and durations, while the previous section only deals with accent (and boundary tone) assignment. [see Intonation]

`(Int_Targets_5_LR UTT)`

  Predict Target F0 points using linear regression from factors such as accent, tone, stress, position in phrase etc. This utterance module is called through the module Int_Targets when the Parameter Int_Method is set to ToBI, even though this technique is not restricted to the ToBI labelling system. [see Tree intonation]

`(Int_Targets_Default UTT)`

  This module creates two Targets causing a simple downward continuous F0 through the whole utterance. The code is in an appropriate named file called duffint. This module is called when the Parameter Int_Method is not set or set to Default. This module is called through the Int_Targets module. Optional parameters for a start value (default 130) and end value (default 110) may be set in the variable diffint_params. This can be used to generate a monotone intonation with a setting like (set! duffint_params ’((start 100) (end 100))). [see Default intonation]

`(Int_Targets_General UTT)`

  Add targets based on the functions defined in int_general_params. This method allows quite detailed control over the general of targets per syllable, see manual for details and examples. This module is called when the Parameter Int_Method is set to General. This module is called through the Int_Targets module. [see General intonation]

`(Int_Targets_LR UTT)`

  Predict Target F0 points using linear regression from factors such as accent, tone, stress, position in phrase etc. This utterance module is called through the module Int_Targets when the Parameter Int_Method is set to ToBI, even though this technique is not restricted to the ToBI labelling system. [see Tree intonation]

`(Int_Targets_Relation UTT)`
`(Int_Targets_Simple UTT)`

  Naively add targets for hat shaped accents for each accent in the IntEvent stream. This module is called when the Parameter Int_Method is set to Simple. This module is called through the Int_Targets module. [see Simple intonation]

`(Int_Targets_Tilt utt)`

  Assign Tilt parameters to each IntEvent and then generate the F0 contour and assign targets.

`(intern ATOM)`

  Intern ATOM on the oblist.

`(Intonation utt)`

  Select between different intonation modules depending on the Parameter Int_Method. Currently offers three types: Simple, hats on each content word; ToBI, a tree method for predicting ToBI accents; and Default a really bad method with a simple downward sloping F0. This is the first of a two-stage intonation prediction process. This adds accent-like features to syllables, the second, Int_Targets generates the F0 contour itself. [see Intonation]

`(Intonation_Default UTT)`

  this method is such a bad intonation module that it does nothing at all. This utterance module is called when the Parameter Int_Method is not set or set to Default. This module is called through the Intonation module. [see Default intonation]

`(Intonation_Simple)`

  Assign accents to each content word, creating an IntEvent stream. This utterance module is called when the Parameter Int_Method is set to Simple. This module is called through the Intonation module. [see Simple intonation]

`(Intonation_Tilt utt)`

  Assign accent and boundary IntEvents to each syllable, and fill in spaces with silence and connections.

`(Intonation_Tree UTT)`

  Use the CART trees in int_tone_cart_tree and int_accent_cart_tree to create an IntEvent stream of tones and accents related to syllables. This module is called through the Intonation module and is selected when the Parameter Int_Method is ToBI. [see Tree intonation]

`(intro)`

  Synthesize an introduction to the Festival Speech Synthesis System.

`(intro-spanish)`

  Synthesize an introduction to the Festival Speech Synthesis System in spanish. Spanish voice must already be selected for this.

`(item.add_link ITEMFROM ITEMTO)`

  Add a link from ITEMFROM to ITEMTO is the relation ITEMFROM is in.

`(item.append_daughter ITEM1 ITEM2)`

  Add a ITEM2 a new daughter (right-most) to ITEM1 in the relation of ITEM1. If ITEM2 is of type item then it is added directly otherwise ITEM2 is treated as a description of an item and a one is created with that description (name features).

`(item.daughter1 ITEM)`

  Return the first daughter of ITEM, or nil if there is none.

`(item.daughter1_to s relname)`

  Follow daughter1 links of s in its current relation until an item is found that is also in relname, is s is in relname it is returned. The return item is returned in relation relname, or nil if there is nothing in relname.

`(item.daughter2 ITEM)`

  Return the second daughter of ITEM, or nil if there is none.

`(item.daughtern ITEM)`

  Return the last daughter of ITEM, or nil if there is none.

`(item.daughter1_to s relname)`

  Follow daughtern links of s in its current relation until an item is found that is also in relname, is s is in relname it is returned. The return item is returned in relation relname, or nil if there is nothing in relname.

`(item.daughters parent)`

  Return a list of all daughters of parent.

`(item.delete ITEM)`

  Remove this item from all relations it is in and delete it.

`(item.down ITEM)`

  Return the item below ITEM, or nil if there is none.

`(item.exchange_tree FROM TO)`

  Exchanged contents of FROM and TO, and descendants of FROM and TO. Returns t if successful, or nil if FROM or TO contain each other.

`(item.feat ITEM FEATNAME)`

  Return value of FEATNAME (which may be a simple feature name or a pathname) of ITEM.

`(item.feat.present item feat)`

  nil if feat doesn’t existing in this item, non-nil otherwise.

`(item.features ITEM EVALUATE_FEATURES))`

  Returns all features in ITEM as an assoc list.

`(item.first_leaf ITEM)`

  Returns he left most leaf in the tree dominated by ITEM. This is like calling item.daughter1 recursively until an item with no daughters is found.

`(item.get_utt ITEM)`

  Get utterance from given ITEM (if possible).

`(item.insert ITEM1 ITEM2 DIRECTION)`

  Insert ITEM2 in ITEM1’s relation with respect to DIRECTION. If DIRECTION is unspecified, after, is assumed. Valid DIRECTIONS as before, after, above and below. Use the functions item.insert_parent and item.append_daughter for specific tree adjoining. If ITEM2 is of type item then it is added directly, otherwise it is treated as a description of an item and new one is created.

`(item.insert_parent ITEM1 ITEM2)`

  Insert a new parent between this ITEM1 and its parentm in ITEM1’s relation. If ITEM2 is of type item then it is added directly, otherwise it is treated as a description of an item and one is created with that description (name features).

`(item.last_leaf ITEM)`

  Returns he right most leaf in the tree dominated by ITEM. This is like calling item.daughtern recursively until an item with no daughters is found.

`(item.relation.leafs item relname)`

  Return a list of the leafs of this item in this relation.

`(item.link1 ITEM)`

  Return first item linked to ITEM in current relation.

`(item.link2 ITEM)`

  Return second item linked to ITEM in current relation.

`(item.linkedfrom ITEM)`

  Return the item tht is linked to ITEM.

`(item.linkn ITEM)`

  Return last item linked to ITEM in current relation.

`(item.merge FROM TO)`

  Merge FROM into TO making them the same items. All features in FROM are merged into TO and all references to FROM are made to point to TO.

`(item.move_tree FROM TO)`

  Move contents, and descendants of FROM to TO. Old daughters of TO are deleted. FROM will be deleted too if it is being viewed as the same same relation as TO. FROM will be deleted from its current place in TO’s relation. Returns t if successful, returns nil if TO is within FROM.

`(item.name ITEM)`

  Returns the name of ITEM. [see Accessing an utterance]

`(item.next ITEM)`

  Return the next ITEM in the current relation, or nil if there is no next.

`(item.next_item ITEM)`

  Will give next item in this relation visiting every item in the relation until the end. Traverses in pre-order, root followed by daughters (then siblings).

`(item.next_leaf ITEM)`

  Return the next leaf item (i.e. one with no daughters) in this relation. Note this may traverse up and down the relation tree significantly to find it.

`(item.next_link ITEM)`

  Return next item licked to the same item ITEM is linked to.

`(item.parent ITEM)`

  Return the item of ITEM, or nil if there is none.

`(item.parent_to s relname)`

  Find the first ancestor of s in its current relation that is also in relname. s is treated as an ancestor of itself so if s is in relname it is returned. The returned value is in will be in relation relname or nil if there isn’t one.

`(item.prepend_daughter ITEM1 ITEM2)`

  Add a ITEM2 a new daughter (left-most) to ITEM1 in the relation of ITEM1. If ITEM2 is of type item then it is added directly otherwise ITEM2 is treated as a description of an item and a one is created with that description (name features).

`(item.prev ITEM)`

  Return the previous ITEM in the current relation, or nil if there is no previous.

`(item.raw_feat ITEM FEATNAME)`

  Return value of FEATNAME as native features structure (which may be a simple feature name or a pathname) of ITEM.

`(item.relation ITEM RELATIONNAME)`

  Return the item such whose relation is RELATIONNAME. If ITEM is not in RELATIONNAME then nil is return.

`(item.relation.append_daughter parent relname daughter)`

  Make add daughter to parent as a new daughter in relname.

`(item.relation.daughter1 item relname)`

  Return the first daughter of this item in this relation.

`(item.relation.daughter2 item relname)`

  Return the second daughter of this item in this relation.

`(item.relation.daughtern item relname)`

  Return the final daughter of this item in this relation.

`(item.relation.daughters parent relname)`

  Return a list of all daughters of parent by relname.

`(item.relation.first item relname)`

  Return the most previous item from this item in this relation.

`(item.relation.insert si relname newsi direction)`

  Insert newsi in relation relname with respect to direction. If direction is ommited after is assumed, valid directions are after before, above and below. Note you should use item.relation.append_daughter for tree adjoining. newsi maybe a item itself of a LISP description of one.

`(item.relation.leafs item relname)`

  Return a list of the leafs of this item in this relation.

`(item.relation.name ITEM)`

  Return the name of the relation this ITEM is currently being viewed through.

`(item.relation.next item relname)`

  Return the next item in this relation.

`(item.relation.parent item relname)`

  Return the parent of this item in this relation.

`(item.relation.prev item relname)`

  Return the previous item in this relation.

`(item.relation.remove ITEM RELATIONNAME)`

  Remove this item from Relation, if it apears in no other relation it will be deleted too, in contrast item.delete will remove an item from all other relations, while this just removes it from this relation. Note this will also remove all daughters of this item in this relation from this relation.

`(item.relations ITEM)`

  Return a list of names of the relations this item is in.

`(item.remove_feature ITEM FNAME)`

  Remove feature named FNAME from ITEM. Returns t is successfully remove, nil if not found.

`(item.root s)`

  Follow parent link until s has no parent.

`(item.set_feat ITEM FEATNAME VALUE)`

  Set FEATNAME to VALUE in ITEM.

`(item.set_function ITEM FEATNAME FEATFUNCNAME)`

  Set FEATNAME to feature function name FEATFUNCNAME in ITEM.

`(item.set_name ITEM NAME)`

  Sets ITEM’s name to NAME. [see Accessing an utterance]

`(item.up ITEM)`

  Return the item above ITEM, or nil if there is none.

`(lambda (ARG1 ARG2 ...) . BODY)`

  Create closure (anonymous function) with arguments ARG1, ARG2 ... and BODY.

`(language-location NAME DIR DOCSTRING)`

  Record the location of a language. Called for each language found on language-path. Can be called in site-init or .festivalrc for additional languages which exist elsewhere.

`Returns a list with the installed voices for language langname`
`(language.list)`

  List of all (potential) languages in the system. This checks the language-location list of potential languages found be scanning the language-path at start up time.

`(language.names.add LANGUAGE ALIASES)`

  Describe a language to the systen. LANGUAGE should be atomic name, that conventionally will have language_ prepended to name the basic selection function. ALIASES is a list of names for that language.

`(language.select LANG)`

  Call function to set up language LANG. This is normally done by prepending language_ to LANG and call it as a function.

`(last A)`

  Last (cdr) element in list A.

`(lastline STRING)`

  Returns the part of the string which between the last newline and the end of string.

`(length LIST)`

  Return length of LIST, or 0 if LIST is not a list.

`(let-internal STUFF)`

  Internal function used to implement let.

`(let ((VAR1 VAL1) (VAR2 VAL2) ...) . BODY)`

  Evaluate BODY in an environment where VAR1 is set to VAL1, VAR2 is set to VAL2 etc.

`(lex.add.entry ENTRY)`

  Add ENTRY to the addenda of the current lexicon. As the addenda is checked before the compiled lexicon or letter to sound rules, this will cause ENTRY to be found before all others. If a word already in the addenda is added again the most recent addition will be found (part of speech tags are respected in the look up). [see Lexical entries]

`(lex.compile ENTRYFILE COMPILEFILE)`

  Compile the list of lexical entries in ENTRYFILE into a compiled file in COMPILEFILE. [see Defining lexicons]

`(lex.create LEXNAME)`

  Create a new lexicon of name LEXNAME. If it already exists, the old one is deleted first. [see Defining lexicons]

`(lex.entrycount WORD)`

  Return the number of entries in the compiled lexicon that match this word. This is used in detecting homographs.

`(lex.list)`

  List names of all currently defined lexicons.

`(lex.lookup WORD FEATURES)`

  Lookup word in current lexicon. The addenda is checked first, if WORD with matching FEATURES (so far this is only the part of speech tag) is not found the compiled lexicon is checked. Only if the word is still not found the letter to sound rules (or whatever method specified by the current lexicon’s lts.method is used). [see Lookup process]

`(lex.lookup_all WORD)`

  Return list of all entries in the addenda and compiled lexicon that match this word. The letter to sound rules and user defined unknown word function is ignored.

`(lex.select LEXNAME)`

  Select LEXNAME as current lexicon. The name of the previously selected lexicon is returned.

`(lex.set.compile.file COMPFILENAME)`

  Set the current lexicon’s compile file to COMPFILENAME. COMPFILENAME is a compiled lexicon file created by lex.compile. [see Defining lexicons]

`(lex.set.lts.method METHOD)`

  Set the current lexicon’s letter-to-sound method to METHOD. METHOD can take any of the following values: Error (the default) signal a festival error if a word is not found in the lexicon; lts_rules use the letter to sound rule set named by lts_ruleset; none return simply nil in the pronunciation field; function use call the two argument function lex_user_unknown_word (as set by the user) with the word and features to provide an entry. [see Letter to sound rules]

`(lex.set.lts.ruleset RULESETNAME)`

  Set the current lexicon’s letter-to-sound ruleset to RULESETNAME. A ruleset of that name must already be defined. This is used if lts.method is set to lts_rules. [see Letter to sound rules]

`(lex.set.phoneset PHONESETNAME)`

  Set current lexicon’s phone set to PHONESETNAME. PHONESETNAME must be a currently defined (and, of course, loaded) phone set. [see Defining lexicons]

`(lex.set.pos.map POSMAP)`

  A reverse assoc-list mapping part of speech tags to the lexical part of speech tag set. [see Lexical entries]

`(lex.set.post_hooks HOOKS)`

  Set a function or list of functions that are to be applied to the entry after lookup. Returns previous value [see Lexical entries]

`(lex.set.pre_hooks HOOKS)`

  Set a function or list of functions that are to be applied to the entry before lookup. Returns previous value [see Lexical entries]

`(lex.syllabify.phstress PHONELIST)`

  Syllabify the given phone list (if current phone set). Vowels may have the numerals 0, 1, or 2 as suffixes, if so these are taken to be stress for the syllable they are in. This format is similar to the entry format in the CMU and BEEP lexicons. [see Defining lexicons]

`(lex_user_unknown_word WORD FEATS)`

  Function called by lexicon when ’function type letter to sound rules is defined. It is the user’s responsibility to defined this function themselves when they want to deal with unknown words themselves.

`(library_expand_filename FILENAME)`

  Search for filename by appending FILENAME to each member of load-path. Full expanded pathname is returned. If not found in load-path FILENAME is returned.

`(linear_regression ITEM MODEL)`

  Use linear regression MODEL on ITEM. MODEL consists of a list of features, weights and optional map list. E.g. ((Intercept 100) (tobi_accent 10 (H* !H*))).

`(list A0 A1 ...)`

  Return list containing A0 A1 ...

`(load FILENAME OPTION)`

  Load s-expressions in FILENAME. If OPTION is nil or unspecified evaluate each s-expression in FILENAME as it is read, if OPTION is t, return them unevaluated in a list.

`(load_library FILENAME)`

  Load file from library, appends FILENAME to each path in load-path until a valid file is found. If none found loads name itself

`(log NUM)`

  Return natural log of NUM.

`(lr_predict ITEM LRMODEL)`

  Apply the linear regression model LRMODEL to ITEM in. This returns float value by summing the product of the coeffients and values returned by the specified features in ITEM. [see Linear regression]

`(lts.apply WORD RULESETNAME)`

  Apply lts ruleset RULESETNAME to word returning result. [see Letter to sound rules]

`(lts.in.alphabet WORD RULESETNAME)`

  Returns t is all characters in symbol word (or items in list WORD) are in the alphabet of letter to sound ruleset name RULESETNAME. nil otherwise. [see Letter to sound rules]

`(lts.list)`

  Return list of all current defined LTS rulesets.

`(lts.ruleset NAME RULES SETS)`

  Define a new set of letter to sound rules. [see Letter to sound rules]

`(make-a-doc FILENAME DOCLIST)`

  Make a texinfo document in FILENAME as a texinfo table, items are from DOCLIST. DOCLIST names which doclist to use, it may be one of ’function, ’features or ’vars.

`(make-doc)`

  Find function and variable document strings and save them in texinfo format to respective files.

`(make-list SIZE VALUE)`

  Return list of SIZE with each member VALUE.

`(make_du_voice BASENAMES DATADIRS SAMPLERATE)`

  Creates a Diphone UnitSelection Voice, using the list of file basenames in LISP list BASENAMES, and the four directory strings in the DATADIRS list. The voice waveform data files are sampled at SAMPLERATE.

`(make_du_voice_module BASENAMES DATADIRS SAMPLERATE)`

  Creates a Diphone UnitSelection Voice Module, using the list of file basenames in LISP list BASENAMES, and the four directory strings in the DATADIRS list. The voice waveform data files are sampled at SAMPLERATE.

`(make_tmp_filename)`

  Return name of temporary file.

`(manual SECTION)`

  Display SECTION in the manual. SECTION is a string identifying a manual section (it could be an initial substring. If SECTION is nil or unspecifed then the Manual table of contents is displayed. This uses netscape to display the manual page so you must have that (use variable manual-browser to identify it) and the variable manual-url pointing to a copy of the manual. [see Getting some help]

`(manual-sym SYMBOL)`

  Display the section in the manual that SYMBOL’s docstring has identified as the most relevant. The section is named on the last line of a documentation string with no newlines within it prefixed by "[see " with a "]" just immediately before the end of the documentation string. The manual section name is translated to the section in the HTML version of the manual and a URL is and sent to Netscape for display. [see Getting some help]

`(map_to_relation UTT Source_relation Target_relation new_relation)`

  From the F0 contour in F0_relation, create a set of pitchmarks in PM_relation. If END_TIME is not nil, Extra pitchmarks will be created at the default interval up to this point

`(mapcar FUNCTION ARGS [ARGS2])`

  Apply FUNCTION to each member of ARGS (and [ARGS2]), returning list of return values.

`(num_tokens x)`

  This is probably controversial, but its good to have a maximum number of tokens in an utterance. You really dont want to wait on very long utterances, some utts can be thousands of words long, these maybe shouldn’t be spoken, but we do have to deal with them.

`(MBROLA_Synth UTT)`

  Synthesize using MBROLA as external module. Basically dump the info from this utterance. Call MBROLA and reload the waveform into utt. [see MBROLA]

`(me_mlsa TRACK STRTRACK)`

  Return a WAVE synthesized from the F0/MCEP TRACK, STRTRACK is non-nil, use mixed excitation. Deprecated! Use mlsa_resynthesis instead

`(member ITEM LIST)`

  Returns subset of LIST whose car is ITEM if it exists, nil otherwise.

`(member_string STRING LIST)`

  Returns subset of LIST whose car is STRING if it exists, nil otherwise.

`(mlpg TRACK)`

  Return a track suitable for mlsa from a TRACK with dynamics in it.

`(mlsa_resynthesis TRACK STRTRACK FILTERTRACK)`

  Return a WAVE synthesized from the F0/MCEP TRACK, STRTRACK is non-nil, use mixed excitation. If FILTERTRACK is non-nil, it has filters for excitation

`(module_description MOD)`

  Returns the description record of the module named by symbol MOD

`(month_range SC)`

  1 if SC’s name is > 0 and < 32, 0 otherwise.

`(mt_accent syl)`

  Accent or 0 if none.

`(mt_break syl)`

  Break or 0 if none.

`(mt_close n)`

  The number of consituents this is the end of, Effectively the number of closing brackets after this word.

`(mt_fssw s)`

  1 if first stressed syllable in word, 0 otherwise.

`(mt_lssp s)`

  1 if last stressed syllable in phrase, 0 otherwise.

`(nfssw s)`

  1 if second or later stressed syllable in word, 0 otherwise.

`(mt_num_s s)`

  The number of s MetricalValues from here to a w or top.

`(mt_num_w s)`

  The number of w MetricalValues from here to a s or top.

`(mt_open n)`

  The number of consituents this is the start of, Effectively the number of opening brackets before this word.

`(mt_postype syl)`

  Returns single, initial, final or middle.

`(mt_strong s)`

  1 if all MetricalValues a s to a word, 0 otherwise.

`(MultiProbParse UTT)`

  Parse part of speech tags in Word relation. Unlike ProbParse this allows multiple sentences to appear in the one utterance. The CART tree in eos_tree is used to define end of sentence. Loads the grammar from scfg_grammar_filename and saves the best parse in the Syntax Relation.

`(multisyn_hybrid_fill_target_coefficients VOICE UTT TRACKFILE)`

  Use the voice to add the given target cost coefficients to the utterance.

`(play_wave FILENAME)`

  Play given wavefile

`(nconc A B)`

  Destructively append B to A, if A is nil return B.

`(ngram.load NAME FILENAME)`

  Load an ngram from FILENAME and store it named NAME for later access.

`(nint NUMBER)`

  Returns nearest int to NUMBER.

`(not DATA)`

  Returns t if DATA is nil, nil otherwise.

`(nth N LIST)`

  Returns nth car of LIST, 0 is car.

`(nth_cdr N LIST)`

  Returns nth cdr of LIST, 0 is LIST.

`(null? DATA)`

  Returns t if DATA is nil, nil otherwise.

`(num_digits SC)`

  Returns number of digits (actually chars) is SC’s name.

`(num_postvocalic_c syl)`

  Finds the number of postvocalic consonants in a syllable.

`(number? DATA)`

  Returns t if DATA is a number, nil otherwise.

`(oblist)`

  Return oblist.

`(or DISJ1 DISJ2 ...)`

  Evaluate each disjunction DISJn in turn until one evaluates to non-nil. Otherwise return nil.

`(pair? DATA)`

  Returns t if DATA is a cons cell, nil otherwise.

`(Param.def NAME VAL)`

  Set parameter NAME to VAL if not already set

`(Param.get NAME)`

  Get parameter NAME’s value (nil if unset)

`(Param.set NAME VAL)`

  Set parameter NAME to VAL (deleting any previous setting)

`(Parameter.def NAME VAL)`

  Set parameter NAME to VAL if not already set. This is an OLD function you shold use Param.def instead.

`(Parameter.get NAME)`

  Get parameter NAME’s value (nil if unset). This is an OLD function and may not exist in later versions (or change functionality). This function (unlike Param.get) may return sylbols (rather than strings if the val doesn’t contain whitespace (to allow older functions to still work.

`(Parameter.set NAME VAL)`

  Set parameter NAME to VAL (deleting any previous setting). This is an old function and you should use Param.set instead.

`(parse-number SYMBOL)`

  Returns a number form a symbol or string whose print name is a number.

`(parse_url URL)`

  Split URL into a list (protocol host port path) suitable for giving to fopen.

`(path-append DIRECTORY-PATH ADDITION1 ADDITION2 ...)`

  Return a the path for ADDITION in DIRECTORY.

`(path-as-directory PATHNAME)`

  Return PATH as a directory name.

`(path-as-file PATHNAME)`

  Return PATH as a non-directory name.

`(path-basename PATHNAME)`

  Return name part of PATH.

`(path-is-dirname PATHNAME)`

  Is PATH a directory name.

`(path-is-filename PATHNAME)`

  Is PATH a non-directory name.

`(Pause_optional_deleting_B_X utt)`

  Delete all phone symbols starting with ’B_’ from the segemt relation (a B_150 e.g. is a 150ms pause) if symbol ’Pause_delete_B_X is defined.

`(Pauses utt)`

  Insert pauses where required.

`peak_segment_anchor ie`

  Determines what segment acts as the anchor for a peak. Returns number of segments from start of accented syllable to peak.

`peak_wi_seg segment pk_pos`

  Finds if a peak occurs w/i a segment

`(phone_feature phone feat)`

  Return the feature for given phone in current phone set, or 0 if it doesn’t exist.

`(Phoneset.description OPTIONS)`

  Returns a lisp for of the current phoneme set. Options is a list of parts of the definition you require. OPTIONS may include, silences, phones, features and/or name. If nil all are returned.

`(Phoneset.list)`

  List the names of all currently defined Phonesets.

`(PhoneSet.select PHONESETNAME)`

  Select PHONESETNAME as current phoneset. [see Phonesets]

`(PhoneSet.silences LIST)`

  Declare LIST of phones as silences. The first in the list should be the "most" silent. [see Phonesets]

`(Phrasify utt)`

  Construct phrasify over Words module.

`(POS utt)`

  Apply part of speech tagging (and possible parsing too) to Word relation.

`(position thing l)`

  What position is thing in l, -1 if it doesn’t exist.

`(PostLex utt)`

  Apply post lexical rules to segment stream. These may be almost arbitrary rules as specified by the particular voice, through the postlex_hooks variable. A number of standard post lexical rule sets are provided including reduction, posessives etc. These rules are also used to mark standard segments with their cluster information used in creating diphone names.

`(postlex_a utt)`

  If POS of "a" is "nn" and segment feature "reducable", set it to 0. This is a bugfix, but still requires the target cost function to add a penalty if a candidate is reducable but the target is not. expro_target_cost does that.

`(postlex_apos_s_check UTT)`

  Deal with possesive s for English (American and British). Delete schwa of ’s if previous is not an alveolar or palatal fricative or affricative, and change voiced to unvoiced s if previous is not voiced.

`(postlex_intervoc_r UTT)`

  Remove any word-final /r/ which is phrase-final or not going to be inter-vocalic i.e. the following words does not start with a vowel.

  NOTE: in older versions of unilex-rpx.out for Festival, there is no word-final /r/.

`(postlex_stop_deletion utt)`

  Delete any stop or affricative (phone which has a closure) immediately followed by another stop or affricative.

  Also save the identity of the deleted phone for the context cost functions. Consider:

  backtrack /b a k t r a k/ -> /b a t r a k/ (actually Jenny reduces : /b a k_cl k t_cl t r a k/ -> /b a k_cl t r a k/) If we then look for a diphone /a t/ we want to favour candidates coming from the same context i.e. which are actually a reduced /a k t/. In the data base, the 1st /a/ gets the feature right_context=k and the /t/ gets the fearture left_context=k.

`(postlex_the_vs_thee utt)`

  Unnreduce the schwa in "the" when a vowel follows. Reduce the vowel in "the" when no vowel follows (this requires a lexicon entry for "the" with feature "reduced", otherwise there will be no reduction).

`(postlex_the_vs_thee_changeflag utt)`

  Unnreduce the schwa in "the" when a vowel follows. Reduce the vowel in "the" when no vowel follows (this requires a lexicon entry for "the" with feature "reduced", otherwise there will be no reduction).

`(postlex_unilex_vowel_reduction utt)`

  Perform vowel reduction based on unilex specification of what can be reduced.

`(pow X Y)`

  Return X**Y.

`(pprintf EXP [FD])`

  Pretty print EXP to FD, if FD is nil print to the screen.

`(print DATA)`

  Print DATA to stdout if textual form. Not a pretty printer.

`(print_string DATA)`

  Returns a string representing the printing of DATA.

`(printfp DATA FILEP)`

  Print DATA to file indicated by file pointer FILEP. File pointers are are created by fopen.

`(probe_file FILENAME)`

  Returns t if FILENAME exists and is readable, nil otherwise.

`(ProbParse UTT)`

  Parse part of speech tags in Word relation. Loads the grammar from scfg_grammar_filename and saves the best parse in the Syntax Relation.

`(ProbParseGeneralized (list utt gram prel pfeat crel))`

  Parse utt over the prel relation using its pfeat feature Load grammar from gram, and save parse in relation crel

`(proclaim_language NAME DESCRIPTION)`

  Describe a language to the systen. NAME should be atomic name, that conventionally will have language_ prepended to name the basic selection function. OPTIONS is an assoc list of feature and value and must have at least features for default_male, default_female and name aliases. Values for these features must be lists of atoms.

`(proclaim_voice NAME DESCRIPTION)`

  Describe a voice to the systen. NAME should be atomic name, that conventionally will have voice_ prepended to name the basic selection function. OPTIONS is an assoc list of feature and value and must have at least features for language, gender, dialect and description. The first there of these are atomic, while the description is a text string describing the voice.

`(provide FILENAME)`

  Adds FNAME to the variable provided (if not already there). This means that future calls to (require FILENAME) will not cause FILENAME to be re-loaded.

`(putc ECHAR FILEP)`

  Put ECHAR (a number) as a character to FILEP. If FILEP is nil or not specified output goes to stdout.

`(putprop SYM VAL KEY)`

  Put property VAL named KEY for SYM.

`(puts STRING FILEP)`

  Write STRING (print name of symbol) to FILEP. If FILEP is nil or not specified output goes to stdout.

`(pwd)`

  Returns current directory as a string.

`(quit)`

  Exit from program, does not return.

`(quote DATA)`

  Return data (unevaluated).

`(rand)`

  Returns a pseudo random number between 0 and 1 using the libc rand() function.

`(read)`

  Read next s-expression from stdin and return it.

`(read-from-string SYMBOL)`

  Return first s-expression in print name of SYMBOL.

`(readfp FILEP)`

  Read and return next s-expression from file indicated by file pointer FILEP. File pointers are created by fopen.

`(remove ITEM LIST)`

  (Non-destructively) remove ITEM from LIST.

`(remove-duplicates LIST)`

  Remove duplicate items in LIST.

`(remove_leading_zeros name)`

  Remove leading zeros from given string.

`(remove_leadtrail_underscores name)`

  Get rid of leading and trailing underscores that may be used for emphasis, not this is called when there are underscores at the beginning and end but there may not be an equal number of them.

`(replace BEFORE AFTER)`

  Destructively replace contents of cons cell BEFORE with those of AFTER.

`(request FILENAME)`

  Checks if FNAME is already provided (member of variable provided) if not tries to loads it, appending ".scm" to FILENAME. Uses load_library to find the file. Unlike require, fname isn’t found no error occurs

`(require FILENAME)`

  Checks if FNAME is already provided (member of variable provided) if not loads it, appending ".scm" to FILENAME. Uses load_library to find the file.

`(require_module l)`

  Check that certain compile-time modules are included in this installation. l may be a single atom or list of atoms. Each item in l must appear in *modules* otherwise an error is throw.

`(reverse LIST)`

  Returns destructively reversed LIST.

`(replacd A B)`

  Destructively replace the cdr of A with B.

`(save-forms FILENAME FORMS HOW)`

  Save FORMS in FILENAME. If HOW is a appending FORMS to FILENAME, or if HOW is w start from the beginning of FILENAME.

`Saves the waveform and records its so it can be joined into a`

  a single waveform at the end.

`(save_seg_mbrola_entry ENTRY NAME START DUR TARGS FD)`

  Entry contains, (name duration num_targs start 1st_targ_pos 1st_targ_val).

`(save_segments_mbrola UTT FILENAME)`

  Save segment information in MBROLA format in filename. The format is phone duration (ms) [% position F0 target]*. [see MBROLA]

`(save_waves_during_tts)`

  Save each waveform in the current directory in files "tts_file_XXX.wav". use (save_waves_during_tts_STOP) to stop saving waveforms

`(save_waves_during_tts_STOP)`

  Stop saving waveforms when doing tts.

`(SayPhones PHONES)`

  PHONES is a list of phonemes. This uses the Phones type utterance to synthesize and play the given phones. Fixed duration specified in FP_duration and fixed monotone duration (FP_F0) are used to generate prosody.

`(SayText TEXT)`

  TEXT, a string, is rendered as speech.

`(search-for-languages)`

  Search down language-path to locate languages.

`(search-for-voices)`

  Search down voice-path to locate voices.

`(search-for-voices-multisyn)`

  Search down multisyn voice-path to locate multisyn voices.

`(seg_word_final seg)`

  Is this segment word final?

`(segment_dpitch UTT SEG)`

  Returns delta pitch, this pitch minus previous pitch.

`(segs_to_peak sylSyl pk_pos)`

  Determines the number of segments from the start of a syllable to an intonation peak

`(select_language LANG)`

  Chooses language.

`(send-url-to-netscape URL)`

  Send given URL to netscape for display. This is primarily used to display parts of the manual referenced in documentation strings.

`(send_sexpr_to_client SEXPR)`

  Sends given sexpression to currently connected client.

`(set! SYMBOL VAL)`

  Set SYMBOL to have value VAL, returns VAL.

`(set-car! CONS1 DATA1)`

  Set car of CONS1 to be DATA1. Returns CONS1. If CONS1 not of type consp an error is is given. This is a destructive operation.

`(set-cdr! CONS1 DATA1)`

  Set cdr of CONS1 to be DATA1. Returns CONS1. If CONS1 not of type consp an error is is given. This is a destructive operation.

`(set-symbol-value! SYMBOLNAME VALUE)`

  Set SYMBOLNAME’s value to VALUE, this is much faster than set! but use with caution.

`(set_backtrace arg)`

  If arg is non-nil a backtrace will be display automatically after errors if arg is nil, a backtrace will not automatically be displayed (use (:backtrace) for display explicitly.

`(set_module_description MOD DESC)`

  Set the description for the module named MOD.

`(set_server_safe_functions LIST)`

  Sets restricted list to LIST. When restricted list is non-nil only functions whose names appear in this list may be executed. This is used so that clients in server mode may be restricted to a small number of safe commands. [see Server/client API]

`set_voice_default VOICES sets as voice_default the first voice available from VOICES list`
`(setenv VARNAME VALUE)`

  Set the UNIX environment variable VARNAME to VALUE.

`(setup_beep_lex)`

  Lexicon derived from the British English Example Pronunciation dictionary (BEEP) from Tony Robinson ajr@eng.cam.ac.uk. Around 160,000 entries.

`(setup_cmu6_lex)`

  Lexicon derived from the CMU lexicon (cmudict-0.6), around 100,000 entries, in the radio phoneset (sort of darpa-like). Includes letter to sound rule model trained from this data, the format of this lexicon is suitable for the UniSyn metrical phonology modules. That is the entries are not syllabified,

`(setup_cmu_lex)`

  Lexicon derived from the CMU lexicon (cmudict-0.4), around 100,000 entries, in the radio phoneset (sort of darpa-like). Includes letter to sound rule model trained from this data, and uses the lexical stress predictor from OALD.

`(setup_cmumt_lex)`

  Lexicon derived from the CMU lexicon (cmudict-0.4), around 100,000 entries, in the radio phoneset (sort of darpa-like). Includes letter to sound rule model trained from this data, and uses the lexical stress predictor from OALD.

`(setup_cstr_lexicon)`

  Define and setup the CSTR lexicon. The CSTR lexicon consists of about 25,000 entries in the mrpa phone set. A large number of specific local entries are also added to the addenda.

`(setup_moby_lexicon)`

  Define and setup the MOBY lexicon. This is derived from the public domain version of the Moby (TM) Pronunciator II lexicon. It can be converted automatically to British English mrpa phoneset which of course is sub-optimal. It contains around 120,000 entries and has part of speech information for homographs.

`(setup_oald_lexicon)`

  Define and setup the CUVOALD lexicon. This is derived from the Computer Users Version of the Oxford Advanced Learners’ Dictionary of Current English. This version includes a trained set of letter to sound rules which have also been used to reduce the actual lexicon size by over half, for those entries that the lts model gets exactly the same.

`(sin NUM)`

  Return sine of NUM.

`(socket_open HOST PORT HOW)`

  Open a file descriptor to the BSD socket on HOST at PORT. HOW may be "r" or "w" for a read only or write only filedescriptor. If HOW is unspecified or NIL, "w" is assumed. If HOW is "rw" then a list of two file descriptors is returned, the first for reading the second for writing. Take care when using the bidiectional socket that deadlock doesn’t occur.

`(sort-and-dump-docstrings DOCSTRINGS FILEFP)`

  DOCSTRINGS is an assoc list of name and document string var-docstrings or func-docstrings. This very individual function sorts the list and prints out the documentation strings as texinfo list members to FILEFP.

`(sqrt NUM)`

  Return square root of NUM.

`(srand SEED)`

  Seeds the libc pseudo random number generator with the integer SEED.

`(string-after ATOM AFTER)`

  Returns an atom whose printname is the substring of ATOM’s printname which appears after AFTER. This is a wraparound for the EST_String.after function in C++, and hence has the same conditions for boundary cases.

`(string-append STR1 STR2 ...)`

  Return a string made from the concatenation of the print names of STR1 STR2 ...

`(string-before ATOM BEFORE)`

  Returns an atom whose printname is the substring of ATOM’s printname which appears before BEFORE. This is a wraparound for the EST_String.before function in C++, and hence has the same conditions for boundary cases.

`(string-equal ATOM1 ATOM2)`

  Returns t if ATOM’s printname is equal to ATOM’s print name, otherwise it returns nil.

`(string-length SYMBOL)`

  Return the number of characters in the print name of SYMBOL.

`(string-matches ATOM REGEX)`

  Returns t if ATOM’s printname matches the regular expression REGEX, otherwise it returns nil.

`(sub_utt ITEM)`

  Return a new utterance that contains a copy of this item and all its descendants and related descendants.

`(substring STRING START LENGTH)`

  Return a substring of STRING starting at START of length LENGTH.

`(sxhash OBJ N)`

  Return hashing value for OBJ, in range n.

`(symbol-bound? VARNAME)`

  Return t is VARNAME has a value, nil otherwise.

`(symbol-value SYMBOLNAME)`

  Returns the value of SYMBOLNAME, an error is given SYMBOLNAME is not a bound symbol.

`(symbol? DATA)`

  Returns t if DATA is a symbol, nil otherwise.

`(symbolconc SYMBOL1 SYMBOL2 ...)`

  Form new symbol by concatenation of the print forms of each of SYMBOL1 SYMBOL2 etc.

`(symbolexplode SYMBOL)`

  Returns list of atoms one for each character in the print name of SYMBOL.

`(SynthText TEXT)`

  TEXT, a string, is rendered as speech.

`(system COMMAND)`

  Execute COMMAND (a string) with the UNIX shell.

`(tan NUM)`

  Return tangent of NUM.

`(targets_to_f0 UTT)`

  Make f0 relation, and place an f0 contour in it, using F0 targets from the Target Relation

`(terpri FILEP)`

  Print newline to FILEP, is FILEP is nil or not specified a newline it is printed to stdout.

`(Text UTT)`

  From string in input form tokenize and create a token stream.

`(the-environment)`

  Returns the current (SIOD) environment.

`(tilt_add_intevent utt syl name)`

  Add a new IntEvent related to syl with name.

`(tilt_assign_parameters utt)`

  Assigned tilt parameters to IntEvents, depending on the value of the Parameter tilt_method uses wagon trees (cart) or linear regression models (lr).

`(tilt_assign_parameters_lr utt)`

  Assing parameters (start_f0, tilt, amplitude, peak_pos and duration) to each IntEvent. Prediction by linear regression models

`(tilt_assign_parameters_wagon utt)`

  Assing parameters (start_f0, tilt, amplitude, peak_pos and duration) to each IntEvent. Uses Wagon trees to predict values

`(tilt_assign_params_lr ie lrmodels)`

  Assign the names parameters to ie using the trees and names in trees.

`(tilt_assign_params_wagon ie trees)`

  Assign the names parameters to ie using the trees and names in trees.

`(tilt_map_f0_range utt)`

  In order fo better trained models to be used for voices which don’t have the necessary data to train models from the targets may be mapped to a different pitch range. Note this is not optimal as pitch ranges don’t map that easily, but the the results can sometimes be better than using a less sophisticated F0 generation model. The method used is to define the mean and standard deviation of the speaker the model was trained on and the mean and standard deciation of the desired speaker. Mapping is by converting the actual F0 value to zscores (distance from mean in number of stddev) and back into the other domain. The variable int_tilt_params is used to find the values.

`(tilt_validate utt)`

  Checks that the predicted tilt parameter fall with reasonable limits and modify them where possible to be more reasonable.

`(time)`

  Returns number of seconds since start of epoch (if OS permits it countable).

`(time_to_next_vowel syl)`

  The time from vowel_start to next vowel_start

`(tok_allcaps sc)`

  Returns 1 if sc’s name is all capitals, 0 otherwise

`(tok_rex sc)`

  Returns 1 if King like title is within 3 tokens before or 2 after.

`(tok_rex sc)`

  Returns 1 if this is a King-like name.

`(tok_roman_to_numstring ROMAN)`

  Takes a string of roman numerals and converts it to a number and then returns the printed string of that. Only deals with numbers up to 50.

`(tok_section_name sc)`

  Returns 1 if sc’s name is in list of things that are section/chapter like.

`(tok_string_as_letters NAME)`

  Return list of letters marked as letter part of speech made by exploding NAME.

`(Token UTT)`

  Build a Word stream from the Token stream, analyzing compound words numbers etc as tokens into words. Respects the Parameter Language to choose the appropriate token to word module.

`(Token_Any UTT)`

  Build a Word stream from the Token stream, in a language independent way, which means that all simple tokens should be in the lexicon, or analysed by letter to sound rules.

`(token_end_punc UTT WORD)`

  If punctuation at end of related Token and if WORD is last word in Token return punc, otherwise 0.

`(Token_English UTT)`

  Build a Word stream from the Token stream, for English (American and British English), analyzing compound words, numbers, etc. as tokens into words.

`(token_money_expand type)`

  Convert shortened form of money identifier to words if of a known type.

`(token_no_starting_quote TOKEN)`

  Check to see if a single quote (or backquote) appears as prepunctuation in this token or any previous one in this utterance. This is used to disambiguate ending single quote as possessive or end quote.

`(Token_POS UTT)`

  Assign feature token_pos to tokens that match CART trees in the variable token_pos_cart_trees. These are used for gross level pos such as identifying how numbers should be pronunced.

`(tok_pos sc)`

  Returns a general pos for sc’s name. numeric All digits number float or comma’d numeric sym Contains at least one non alphanumeric month has month name (or abbrev) day has day name (or abbrev) rootname else downcased alphabetic. Note this can be used to find token_pos but isn’t used directly as its not disciminatory enough.

`(Token_Spanish UTT)`

  Build a Word stream from the Token stream, for Castillian Spanish, analyzing compound words, numbers etc as tokens into words.

`(english_token_to_words TOKEN NAME)`

  Returns a list of words for NAME from TOKEN. This allows the user to customize various non-local, multi-word, context dependent translations of tokens into words. If this function is unset only the builtin translation rules are used, if this is set the builtin rules are not used unless explicitly called. [see Token to word rules]

`(Token_Welsh UTT)`

  Build a Word stream from the Token stream, for Welsh, analyzing compound words, numbers etc as tokens into words.

`(zerostart sc)`

  Returns, 1 if first char of sc’s name is 0, 0 otherwise.

`(track.copy TRACK)`

  Return a copy of TRACK.

`(track.get TRACK X Y)`

  Get value of X Y in TRACK.

`(track.get_time TRACK X)`

  Get time of X in TRACK.

`(track.index_below TRACK TIME)`

  Returns the first frame index before this time.

`(track.insert TRACK1 X1 TRACK2 X2 COUNT)`

  Insert TRACK2 from X2 to X2+COUNT into TRACK1 at X1. TRACK1 is resized as required.

`(track.load FILENAME FILETYPE ISHIFT)`

  Load and return a track from FILENAME. Respect FILETYPE is specified and ISHIFT if specified.

`(track.num_channels TRACK)`

  Returns number of channels in TRACK.

`(track.num_frames TRACK)`

  Returns number of frames in TRACK.

`(track.resize TRACK NEWFRAMES NEWCHANNELS)`

  Resize TRACK to have NEWFRAMES number of frames and NEWCHANNELS number of channels. If TRACK is nil a new track is made of the requested size.

`(track.save TRACK FILENAME FILETYPE)`

  Save TRACK in FILENAME, in format FILETYPE, est is used if FILETYPE is unspecified or nil.

`(track.set TRACK X Y V)`

  Set position X Y to V in TRACK.

`(track.set_time TRACK X TIME)`

  Set time at X to TIME in TRACK.

`(tts FILE MODE)`

  Convert FILE to speech. MODE identifies any special treatment necessary for FILE. This is simply a front end to tts_file but puts the system in async audio mode first. [see TTS]

`(tts_file FILE MODE)`

  Low level access to tts function, you probably want to use the function tts rather than this one. Render data in FILE as speech. Respect MODE. Currently modes are defined through the variable tts_text_modes.

`(tts_file_xml FILE)`

  Low level tts processor for XML files. This assumes that element instructions are set up in the variable xxml_elements.

`(find_text_mode FILE ALIST)`

  Search through ALIST for one that matches FILE. Returns nil if nothing macthes.

`(tts_return_to_client)`

  This function is called by clients who wish to return waveforms of their text samples asynchronously. This replaces utt.play in tts_hooks with utt.send.wave.client.

`(tts_text STRING mode)`

  Apply tts on given string. That is, segment it into utterances and apply tts_hooks to each utterance. This is naively done by saving the string to a file and calling tts_file on that file. This differs from SayText which constructs a single utterance for the whole given text.

`(tts_textall STRING MODE)`

  Apply tts to STRING. This function is specifically designed for use in server mode so a single function call may synthesize the string. This function name maybe added to the server safe functions.

`(tts_textasterisk STRING MODE)`

  Apply tts to STRING. This function is specifically designed for use in server mode so a single function call may synthesize the string. This function name may be added to the server safe functions.

`(typeof OBJ)`

  Returns typeof of given object.

`(Unilex_Word UTT)`

  Build the syllable/segment/SylStructure from the given words using the Lexicon. Uses part of speech information in the lexicon look up if present.

`(UniSyn_Duration utt)`

  predicts Segment durations is some speficied way but holds the result in a way necessary for other Unisyn code.

`(Unisyn_Pauses UTT)`

  Predict pause insertion in a Unisyn utterance structure.

`(unwind-protect NORMALFORM ERRORFORM)`

  If an error is found while evaluating NORMALFORM catch it and evaluate ERRORFORM and continue. If an error occurs while evaluating NORMALFORM all file open evaluating NORMALFORM up to the error while be automatically closed. Note interrupts (ctrl-c) is not caught by this function.

`(upcase SYMBOL)`

  Returns a string with the upcased version of SYMBOL’s printname.

`(us_db_params)`

  Return parameters of current UniSyn database.

`(us_db_select NAME)`

  Select named UniSyn database.

`(us_diphone_init DIPHONE_NAME)`

  Initialise UniSyn diphone synthesizer with database DIPHONE_NAME.

`(us_ps_synthesis UTT SIGPR)`

  Synthesize utterance UTT using signal processing technique SIGPR for the UniSyn pitch-synchronous synthesizer.

`(us_f0_to_pitchmarks UTT F0_relation PM_relation END_TIME)`

  From the F0 contour in F0_relation, create a set of pitchmarks in PM_relation. If END_TIME is not nil, Extra pitchmarks will be created at the default interval up to this point

`(us_ps_synthesis UTT SIGPR)`

  Synthesize utterance UTT using signal processing technique SIGPR for the UniSyn pitch-synchronous synthesizer.

`(us_td_synthesis UTT FILTER_METHOD OLA_METHOD)`

  Synthesize utterance UTT using signal processing technique SIGPR for the UniSyn pitch-synchronous synthesizer.

`(warp_utterance UTT (Wavefile Pitchmark_file))`

  Change waveform to match prosodic specification of utterance.

`(us_get_synthesis UTT)`

  Construct a unit stream in UTT comprising suitable diphones. The unit stream produced is suitable for immediate use in us_ps_synthesis.

`(us_insert_initial_pause UTT)`

  Always have an initial silence if the utterance is non-empty. Insert a silence segment after the last segment in WORDITEM in UTT.

`(us_insert_pause UTT WORDITEM)`

  Insert a silence segment after the last segment in WORDITEM in UTT.

`(us_linear_smooth_amplitude UTT)`

  Perform linear amplitute smoothing on diphone joins.

`(us_list_dbs)`

  List names of UniSyn databases currently loaded.

`(us_make_group_file FILENAME PARAMS)`

  Make a group file from the currently specified diphone set. PARAMS is an optional assoc list and allows specification of the track_file_format (default est_binary), sig_file_format (default snd) and sig_sample_format (default mulaw). This is recommended for LPC databases. For PSOLA based databases the sig_sample_format should probably be set to short.

`(us_mapping UTT method)`

  Synthesize utterance UTT using signal processing technique SIGPR for the UniSyn pitch-synchronous synthesizer.

`(us_unit_concat UTT)`

  Concat coef and wave information in unit stream into a single Frames structure storing the result in the Frame relation

`(us_init_raw_concat UTT).`
`(utf8chr ord)`

  Returns the utf8 character corresponding to given decimal value. Invalid characters are replaced by 0xFFFD.

`(utf8explode utf8string)`

  Returns a list of utf-8 characters in given string.

`(utf8ord utf8char)`

  Returns the decimal value utf8 character. -1 if character is invalid.

`(utt.copy_relation UTT FROM TO)`

  copy relation "from" to a new relation "to". Note that items are NOT copied, simply linked into the new relation

`(utt.copy_relation_and_items UTT FROM TO)`

  copy relation and contents of items "from" to a new relation "to"

`(utt.evaluate UTT)`

  evaluate all the features in UTT, replacing feature functions with their evaluation.

`(utt.evaluate.relation UTT)`

  evaluate all the features in RELATION in UTT, replacing feature functions with their evaluation.

`(utt.feat UTT FEATNAME)`

  Return value of feature name in UTT.

`(utt.features UTT RELATIONNAME FUNCLIST)`

  Get vectors of feature values for each item in RELATIONNAME in UTT. [see Features]

`(utt.flat_repr UTT)`

  Returns a flat, string representation of the linguistic information contained in fully formed utterance structure UTT.

`(utt.id UTT id_number)`

  Return the item in UTT whose id matches id_number.

`(utt.import.track UTT FILENAME RELATION FEATURE_NAME)`

  Load track in FILENAME into UTT in R:RELATION.first.FEATURE_NAME. Deletes RELATION if it already exists. (you maybe want to use track.load directly rather than this legacy function.

`(utt.import.wave UTT FILENAME APPEND)`

  Load waveform in FILENAME into UTT in R:Wave.first.wave. If APPEND is specified and non-nil append this to the current waveform.

`(utt.load UTT FILENAME)`

  Loads UTT with the streams and stream items described in FILENAME. The format is Xlabel-like as saved by utt.save. If UTT is nil a new utterance is created, loaded and returned. If FILENAME is "-" the data is read from stdin.

`(utt.play UTT)`

  Play waveform in utt by current audio method.

`(utt.relation UTT RELATIONNAME)`

  Return root item of relation RELATIONNAME in UTT.

`(utt.relation.append UTT RELATIONNAME ITEM)`

  Append ITEM to top of RELATIONNAM in UTT. ITEM may be a LISP description of an item or an item itself.

`(utt.relation.create UTT RELATIONNAME)`

  Create new relation called RELATIONNAME in UTT.

`(utt.relation.delete UTT RELATIONNAME)`

  Delete relation from utt, it the stream items are not linked elsewhere in the utterance they will be deleted too.

`(utt.relation.feat UTT RELNAME FEATNAME)`

  Return value of FEATNAME on relation RELNAME in UTT.

`(utt.relation.first UTT RELATIONNAME)`

  Returns a the first item in this relation.

`(utt.relation.items UTT RELATIONNAME)`

  Return a list of stream items in RELATIONNAME in UTT. If this relation is a tree, the parent streamitem is listed before its daughters.

`(utt.relation.last UTT RELATIONNAME)`

  Returns a the last item in this relation.

`(utt.relation.leafs UTT RELATIONNAME)`

  Returns a list of all the leafs in this relation.

`(utt.relation.load UTT RELATIONNAME FILENAME)`

  Loads (and creates) RELATIONNAME from FILENAME into UTT. FILENAME should contain simple Xlabel format information. The label part may contain the label proper followed by semi-colon separated pairs of feature and value.

`(utt.relation.present UTT RELATIONNAME)`

  Returns t if UTT caontains a relation called RELATIONNAME, nil otherwise.

`(utt.relation.print UTT NAME)`

  print contents of relation NAME

`(utt.relation.remove_feat UTT RELNAME FEATNAME)`

  Remove FEATNAME on relation RELNAME in UTT.

`(utt.relation.remove_item_feat UTT RELNAME FEATNAME)`

  Remove FEATNAME on every item in relation RELNAME in UTT.

`(utt.relation.set_feat UTT RELNAME FEATNAME VALUE)`

  Set FEATNAME to VALUE on relation RELNAME in UTT.

`(utt.relation_tree UTT RELATIONNAME)`

  Return a tree of stream items in RELATIONNAME in UTT. This will give a simple list if the relation has no ups and downs. [see Accessing an utterance]

`(utt.relationnames UTT)`

  List of all relations in this utterance.

`(utt.resynth LABFILE F0FILE)`

  Resynthesize an utterance from a label file and F0 file (in any format supported by the Speech Tool Library). This loads, synthesizes and plays the utterance.

`(utt.save UTT FILENAME TYPE)`

  Save UTT in FILENAME in an Xlabel-like format. If FILENAME is "-" then print output to stdout. TYPE may be nil or est_ascii

`(utt.save.f0 UTT FILENAME)`

  Save F0 of UTT as esps track file in FILENAME.

`(utt.save UTT RELATIONNAME FILENAME EVALUATE_FEATURES)`

  Save relation RELATIONNAME in FILENAME in an Xlabel-like format. If FILENAME is "-" then print output to stdout.

`(utt.save.segs UTT FILE)`

  Save segments of UTT in a FILE in xlabel format.

`(utt.save.til_events UTT FILENAME)`

  Save tilt events in UTT to FILENAME in a format suitable for ev_synth.

`(utt.save.track utt filename relation feature)`

  DEPRICATED use trace.save instead.

`(utt.save.wave UTT FILENAME FILETYPE)`

  Save waveform in UTT in FILENAME with FILETYPE (if specified) or using global parameter Wavefiletype.

`(utt.save.words UTT FILE)`

  Save words of UTT in a FILE in xlabel format.

`(utt.send.wave.asterisk UTT)`

  Sends wave in UTT to client. If not in server mode gives an error Note the client must be expecting to receive the waveform. The waveform is rescaled and resampled according to what asterisk needs

`(utt.send.wave.client UTT)`

  Sends wave in UTT to client. If not in server mode gives an error Note the client must be expecting to receive the waveform.

`(utt.set_feat UTT FEATNAME VALUE)`

  Set feature FEATNAME with VALUE in UTT.

`(utt.synth UTT)`

  The main synthesis function. Given UTT it will apply the functions specified for UTT’s type, as defined with deffUttType and then those demanded by the voice. After modules have been applied synth_hooks are applied to allow extra manipulation. [see Utterance types]

`(utt.tag_unit UTT INT)`

  Tags the candidate used in Unit INT in the Unit relation for omission in subsequent reruns of viterbi search for the unit sequence.

`(utt.type UTT)`

  Returns the type of UTT.

`(utt.wave UTT)`

  Get waveform from wave (R:Wave.first.wave).

`(utt.wave.resample UTT RATE)`

  Resample waveform in UTT to RATE (if it is already at that rate it remains unchanged).

`(utt.wave.rescale UTT FACTOR NORMALIZE)`

  Modify the gain of the waveform in UTT by GAIN. If NORMALIZE is specified and non-nil the waveform is maximized first.

`(Utterance TYPE DATA)`

  Build an utterance of type TYPE from DATA. Different TYPEs require different types of data. New types may be defined by defUttType. [see Utterance types]

`(utttype_recursify definition)`

  Change the linear list of module names into a recursive list so you can truly modify the utterance within the synthesis process.

`(voice-location NAME DIR DOCSTRING)`

  Record the location of a voice. Called for each voice found on voice-path. Can be called in site-init or .festivalrc for additional voices which exist elsewhere.

`(voice-location NAME ROOTNAME DIR DOCSTRING)`

  Record the location of a voice. Called for each voice found on voice-path. Can be called in site-init or .festivalrc for additional voices which exist elsewhere.

`(voice.addModule VOICE BASENAMES DATADIRS SAMPLERATE)`

  Creates a Diphone UnitSelection Voice Module, using the list of file basenames in LISP list BASENAMES, and the three directory strings in the remaining argument DATADIRS and adds it to the current voice. The voice waveform data files are sampled at SAMPLERATE.

`(voice.debugLevel VOICE LEVEL)`

  Query and/or set the level of debugging for VOICE to LEVEL (positive int). A level of 0 switches off all debugging messages in the voice. Leaving level unspecified simply returns the current level.

`(voice.describe NAME)`

  Describe voice NAME by saying its description. Unfortunately although it would be nice to say that voice’s description in the voice itself its not going to work cross language. So this just uses the current voice. So here we assume voices describe themselves in English which is pretty anglo-centric, shitsurei shimasu.

`(voice.description NAME)`

  Output description of named voice. If the named voice is not yet loaded it is loaded.

`(voice.find PARAMETERS)`

  List of the (potential) voices in the system that match the PARAMETERS described in the proclaim_voice description fields.

`(voice.getName VOICE)`

  Gets the name of a voice.

`(voice.getUnits VOICE UTT)`

  Voice object VOICE looks at the segment relation in utterance UTT and adds a suitable unit sequence in the Unit relation.

`(voice.getUtteranceByFileID VOICE FILEIDSTRING)`

  Returns copy of the Utterance in the voice module database, with all the Unit relation filled in, ready for synthesis.

`(voice.init VOICE IGNORE_BAD)`

  Perform any necessary initialisation for the UnitSelection Voice object VOICE. If optional IGNORE_BAD is not nil, then phones marked with a "bad" feature in the segment relation will not be added to the diphone inventory

`(voice.list)`

  List of all (potential) voices in the system. This checks the voice-location list of potential voices found be scanning the voice-path at start up time. These names can be used as arguments to voice.description and voice.describe.

`(voice.numAvailableCandidates VOICE UNIT)`

  Returns the number of instances of speech fragment UNIT (string) present in the VOICE

`(voice.numUnits VOICE)`

  Total units available in Voice object VOICE.

`(voice.numUnitTypes VOICE)`

  Number of different unit types available in Voice object VOICE.

`voice.remove_unavailable VOICES takes a list of voice names and returns`

  a list with the voices in VOICES available.

`(voice.select NAME)`

  Call function to set up voice NAME. This is normally done by prepending voice_ to NAME and call it as a function.

`(voice.setName VOICE NAME)`

  Sets the name of a voice.

`(voice.unitAvailable VOICE UNIT)`

  Returns true or false whether speech fragment UNIT (string) is present in the VOICE

`(voice_reset)`

  This resets all variables back to acceptable values that may affect voice generation. This function should always be called at the start of any function defining a voice. In addition to reseting standard variables the function current_voice_reset will be called. This should always be set by the voice definition function (even if it does nothing). This allows voice specific changes to be reset when a new voice is selection. Unfortunately I can’t force this to be used.

`(voicemodule.getUtterance VOICEMODULE UTTNUMBER)`

  Returns copy of UTTNUMBER Utterance in the voice module database.

`(wagon ITEM TREE)`

  Apply the CART tree TREE to ITEM. This returns the full predicted form, you need to extract the value from the returned form itself. [see CART trees]

`(wagon_predict ITEM TREE)`

  Predict with given ITEM and CART tree and return the prediction (the last item) rather than whole probability distribution.

`(wave.copy WAVE1 WAVE2)`

  Destuctively append WAVE2 to WAVE1 and return WAVE1.

`(wave.copy WAVE)`

  Return a copy of WAVE.

`(wave.get WAVE X Y)`

  Get value of X Y in WAVE.

`(wave.info WAVE)`

  Returns assoc list of info about this wave.

`(wave.load FILENAME FILETYPE SAMPLETYPE SAMPLERATE)`

  Load and return a wave from FILENAME. Respect FILETYPE is specified if not specified respect whatever header is on the file. SAMPLETYPE and SAMPLERATE are only used if FILETYPE is raw.

`(wave.play WAVE)`

  Play wave of selected audio

`(wave.resample WAVE NEWRATE)`

  Resamples WAVE to NEWRATE.

`(wave.rescale WAVE GAIN NORMALIZE)`

  If NORMALIZE is specified and non-nil, maximizes the waveform first before applying the gain.

`(wave.resize WAVE NEWSAMPLES NEWCHANNELS)`

  Resize WAVE to have NEWSAMPLES number of frames and NEWCHANNELS number of channels. If WAVE is nil a new wave is made of the requested size.

`(wave.save WAVE FILENAME FILETYPE SAMPLETYPE)`

  Save WAVE in FILENAME, respecting FILETYPE and SAMPLETYPE if specified if these last two arguments are unspecified the global parameters Wavefiletype and Wavesampletype are used. Returns t is successful and throws an error if not.

`(wave.save.data.fp WAVE FILEPOINTER FILETYPE SAMPLETYPE)`

  Write WAVE to FILEPOINTER, respecting FILETYPE and SAMPLETYPE if specified ignoring any file header. if these last two arguments are unspecified the global parameters Wavefiletype and Wavesampletype are used. Returns t is successful and throws an error if not. It can be used with wave.save.header in order to concatenate several waves.

`(wave.save.fp WAVE FILEPOINTER FILETYPE SAMPLETYPE)`

  Write WAVE to FILEPOINTER, respecting FILETYPE and SAMPLETYPE if specified if these last two arguments are unspecified the global parameters Wavefiletype and Wavesampletype are used. Returns t is successful and throws an error if not.

`(wave.save.header FILEPOINTER WAVE FILETYPE SAMPLETYPE OVERRIDEPARAMS)`

  Write a wave header of format FILETYPE to FILEPOINTER. Header parameters are read first from WAVE and SAMPLETYPE, and can be overridden with OVERRIDEPARAMS OVERRIDEPARAMS = ( ("numsamples" 84000) ("numchannels" 1) ("samplerate" 16000) ("bo" 10) ("numsamples" 16000) )

`(wave.set WAVE X Y V)`

  Set position X Y to V in WAVE.

`(wave.set_sample_rate WAVE SR)`

  set sample rate to SR.

`(Wave_Synth UTT)`

  Generate waveform from information in UTT, at least a Segment stream must exist. The actual form of synthesis used depends on the Parameter Synth_Method. If it is a function that is applied. If it is atom it should be a SynthType as defined by defSynthType [see Utterance types]

`(wavevector.getwave WAVEVECTOR FRAMENUM)`

  retrieves an EST_Wave frame (int FRAMENUM) from a wavevector.

`(wfst.load NAME FILENAME)`

  Load a WFST from FILENAME and store it named NAME for later access.

`(wfst.trasduce WFSTNAME INPUT)`

  Transduce list INPUT (or exploded INPUT if its an atom) to a list of outputs. The atom FAILED is return if the transduction fails.

`(while COND . BODY)`

  While COND evaluates to non-nil evaluate BODY.

`(Word utt)`

  Construct (synthesis specific) syllable/segments from Word relation using current lexicon and specific module.

`(xml_register_id PATTERN RESULT)`

  Add a rule for where to find XML entities such as DTDs. The pattern is a regular expression, the result is a string with substitutions. If the PATTERN matches the a PUBLIC or SYSTEM identifier of an XML entity, the RESULT is expanded and then used as a filename.

`(xml_registered_ids)`

  Return the current list of places to look for XML entities.

`(xxml_attval ATTNAME ATTLIST)`

  Returns attribute value of ATTNAME in ATTLIST or nil if it doesn’t exists.

`(xxml_synth UTT)`

  This applies the xxml_hooks (mode specific) and tts_hooks to the given utterance. This function should be called from xxml element definitions that signal an utterance boundary.