This is Info file festival.info, produced by Makeinfo-1.63 from the
input file festival.texi.

   This file documents the `Festival' Speech Synthesis System a general
text to speech system for making your computer talk and developing new
synthesis techniques.

   Copyright (C) 1996-1999 University of Edinburgh

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided that
the entire resulting derived work is distributed under the terms of a
permission notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that this permission notice may be stated in a
translation approved by the authors.


File: festival.info,  Node: Index,  Up: Top

Index
*****

* Menu:

* after_analysis_hooks:                 Utterance types.
* after_synth_hooks:                    Utterance types.
* atof:                                 Scheme I/O.
* auto-text-mode-alist:                 Text modes.
* before_synth_hooks:                   Utterance types.
* defSynthType:                         Utterance types.
* defUttType:                           Utterance types.
* diphone_module_hooks:                 Diphone selection.
* diphone_phone_name:                   Diphone selection.
* eou_tree:                             Utterance chunking.
* fclose:                               Scheme I/O.
* fopen:                                Scheme I/O.
* format:                               Scheme I/O.
* Initialize:                           Utterance types.
* int_accent_cart_tree:                 Simple intonation.
* item functions:                       Accessing an utterance.
* load-path:                            Site initialization.
* manual:                               Getting some help.
* parse-number:                         Scheme I/O.
* Phones utterance:                     Example utterance types.
* proclaim_voice:                       Defining a new voice.
* quit:                                 Simple command driven session.
* say-minor-mode:                       Emacs interface.
* SayPhones:                            Example utterance types.
* SayText:                              Simple command driven session.
* SegF0 utterance:                      Example utterance types.
* Segments utterance:                   Example utterance types.
* Text utterance:                       Example utterance types.
* Tokens utterance:                     Example utterance types.
* unwind-protect:                       Scheme Festival specifics.
* us_diphone_init:                      UniSyn synthesizer.
* utt.import.wave:                      Utterance I/O.
* utt.load:                             Utterance I/O.
* utt.relation functions:               Accessing an utterance.
* utt.save.segs:                        Utterance I/O.
* utt.save.wave:                        Utterance I/O.
* utt.save:                             Utterance I/O.
* utt.synth:                            Utterance types.
* voice-path:                           Defining a new voice.
* voice_reset:                          Building a new voice.
* Wave utterance:                       Example utterance types.
* Words utterance:                      Example utterance types.
* .festivalrc:                          Site initialization.
* /dev/audio:                           Audio output.
* /dev/dsp:                             Audio output.
* config/config:                        Configuration.
* festival.el:                          Emacs interface.
* init.scm:                             Site initialization.
* nsgmls:                               XML/SGML requirements.
* Sable.v0_2.dtd:                       Sable example.
* siteinit.scm:                         Site initialization.
* texi2html:                            Requirements.
* access strategies:                    Access strategies.
* accessing Lisp variables:             Writing a new module.
* acknowledgements:                     Acknowledgements.
* addenda:                              Defining lexicons.
* adding new directories:               Writing a new module.
* adding new modules:                   Writing a new module.
* adding new voices:                    Defining a new voice.
* alternate diphones:                   UniSyn synthesizer.
* apostrophe s:                         Post-lexical rules.
* asynchronous synthesis:               Audio output.
* audio command:                        Audio output.
* audio command output:                 Site initialization.
* audio hardware:                       Requirements.
* audio output:                         Audio output.
* audio output filetype:                Site initialization.
* audio output rate:                    Site initialization.
* audio problems:                       Checking an installation.
* audio spooler:                        Audio output.
* automatic selection of text mode:     Text modes.
* automounter:                          Configuration.
* backtrace:                            Scheme Festival specifics.
* batch mode:                           Basic command line options.
* BEEP lexicon <1>:                     Available lexicons.
* BEEP lexicon:                         Lookup process.
* bug reports:                          Getting some help.
* C interface:                          C only API.
* C++:                                  Requirements.
* CART trees <1>:                       CART trees.
* CART trees:                           Features.
* Cascading style sheets:               XML/SGML mark-up.
* catching errors:                      Scheme Festival specifics.
* catching errors in Scheme:            Scheme Festival specifics.
* change libdir at run-time:            Site initialization.
* client:                               Server/client API.
* CMU lexicon <1>:                      Available lexicons.
* CMU lexicon:                          Lookup process.
* command line options:                 Basic command line options.
* command mode <1>:                     Basic command line options.
* command mode:                         Quick start.
* compiled lexicons:                    Lookup process.
* compiling a lexicon:                  Defining lexicons.
* compressing the lexicon:              Building letter to sound rules.
* configuration:                        Configuration.
* consonant clusters:                   Diphone selection.
* convert string to number:             Scheme I/O.
* creating a lexicon:                   Defining lexicons.
* creating utterances:                  Labelling databases.
* CSLU:                                 Current voices.
* CSS:                                  XML/SGML mark-up.
* current voice:                        Building a new voice.
* CUVOALD lexicon:                      Available lexicons.
* dark l's:                             Diphone selection.
* database labelling:                   Labelling databases.
* databases:                            Building models from databases.
* debugging Scheme errors:              Scheme Festival specifics.
* debugging scripts:                    Scheme Festival specifics.
* declaring text modes:                 Example text mode.
* default diphone:                      UniSyn synthesizer.
* default voice:                        Site initialization.
* dictionary:                           Lexicons.
* diphone alternates:                   UniSyn synthesizer.
* diphone group files:                  UniSyn synthesizer.
* diphone index:                        UniSyn synthesizer.
* diphone names:                        Diphone selection.
* diphone selection:                    UniSyn synthesizer.
* diphone synthesis <1>:                Diphone synthesizer.
* diphone synthesis:                    UniSyn synthesizer.
* directory structure:                  The source code.
* display:                              Utterance I/O.
* documentation:                        Requirements.
* DSSSL:                                XML/SGML mark-up.
* duff intonation:                      Default intonation.
* duration:                             Duration.
* duration stretch:                     Duration.
* Edinburgh Speech Tools Library:       Acknowledgements.
* editline:                             Requirements.
* Emacs interface:                      Emacs interface.
* email mode:                           Example text mode.
* errors in Scheme:                     Scheme Festival specifics.
* exiting Festival:                     Simple command driven session.
* extracting features:                  Extracting features.
* F0 generation:                        Simple intonation.
* feature extraction:                   Extracting features.
* features <1>:                         CART trees.
* features <1>:                         Feature functions.
* features:                             Features.
* Festival relations:                   Utterance structure.
* Festival script files:                Basic command line options.
* festival_client:                      Server/client API.
* festival_client.c:                    C only API.
* file i/o in Scheme:                   Scheme I/O.
* fixed durations:                      Default durations.
* formatted output:                     Scheme I/O.
* FreeBSD:                              Audio output.
* g++:                                  Requirements.
* garbage collection:                   POS Example.
* GC:                                   POS Example.
* GNU g++:                              Requirements.
* GNU readline:                         Requirements.
* group files <1>:                      UniSyn synthesizer.
* group files:                          Group files.
* grouped diphones:                     UniSyn synthesizer.
* heap size:                            Basic command line options.
* hello world:                          Simple command driven session.
* help:                                 Getting some help.
* homographs <1>:                       Lexical entries.
* homographs:                           Homograph disambiguation.
* hooks:                                Scheme Festival specifics.
* i/o in Scheme:                        Scheme I/O.
* initialization:                       Site initialization.
* installation initialization:          Site initialization.
* interactive mode:                     Basic command line options.
* IntEvent labelling:                   Labelling databases.
* intonation:                           Intonation.
* IRIX:                                 Audio output.
* Items:                                Utterance structure.
* Java:                                 Java and JSAPI.
* JSAPI:                                Java and JSAPI.
* Klatt duration rules:                 Klatt durations.
* labelling:                            Labelling databases.
* language specification <1>:           Site initialization.
* language specification:               Basic command line options.
* laryngograph:                         UniSyn synthesizer.
* letter to sound rules <1>:            Building a new voice.
* letter to sound rules <1>:            Defining lexicons.
* letter to sound rules:                Letter to sound rules.
* lexical entries:                      Lexical entries.
* lexical stress:                       Lexical entries.
* lexicon <1>:                          Requirements.
* lexicon <1>:                          Available lexicons.
* lexicon:                              Lexicons.
* lexicon addenda:                      Defining lexicons.
* lexicon compression:                  Building letter to sound rules.
* lexicon creation:                     Building a new voice.
* lexicon hooks:                        Lookup process.
* lexicon requirements:                 Lexicon requirements.
* linear regression <1>:                Features.
* linear regression:                    Linear regression.
* Linux <1>:                            Audio output.
* Linux:                                Configuration.
* loading a waveform:                   Utterance I/O.
* loading data from files:              Scheme I/O.
* local duration stretch:               Duration.
* lookup hooks:                         Lookup process.
* LPC analysis:                         UniSyn synthesizer.
* LPC residual:                         UniSyn synthesizer.
* LTS:                                  Letter to sound rules.
* mapping between phones:               Phonesets.
* MBROLA:                               MBROLA.
* minimal system:                       Configuration.
* MOBY lexicon:                         Available lexicons.
* modules:                              Utterance modules.
* monotone:                             Default intonation.
* mrpa lexicon:                         Available lexicons.
* multiple lexical entries:             Lookup process.
* NAS:                                  Audio output.
* netaudio:                             Audio output.
* new modules:                          Writing a new module.
* NFS:                                  Configuration.
* ngrams:                               Ngrams.
* NO digits:                            Lexicon requirements.
* offline TTS:                          Simple command driven session.
* OTHER_DIRS:                           Configuration.
* output file type:                     Site initialization.
* output sample rate:                   Site initialization.
* overriding diphone names:             Diphone selection.
* Oxford Advanced Learners' Dictionary: Available lexicons.
* Paradigm Associates:                  Acknowledgements.
* Parameters:                           Utterance modules.
* part of speech map:                   Lexical entries.
* part of speech tag:                   Lexical entries.
* part of speech tagging:               POS tagging.
* perl:                                 Server/client API.
* personal text modes:                  Text modes.
* phone maps:                           Phonesets.
* phoneme definitions:                  Phonesets.
* phoneset definitions:                 Building a new voice.
* phonesets:                            Phonesets.
* phrase breaks:                        Phrase breaks.
* pitchmarking:                         UniSyn synthesizer.
* playing an utterance:                 Simple command driven session.
* POS:                                  Lexical entries.
* POS example:                          POS Example.
* POS tagging:                          POS tagging.
* possessives <1>:                      Lexicon requirements.
* possessives:                          Post-lexical rules.
* post-lexical rules:                   Post-lexical rules.
* power normalisation:                  UniSyn synthesizer.
* predicting stress:                    Building letter to sound rules.
* pretty printing:                      Scheme I/O.
* programming:                          Programming.
* pronunciation:                        Lexical entries.
* PSOLA:                                UniSyn synthesizer.
* punctuation:                          Tokenizing.
* read-eval-print loop:                 Simple command driven session.
* reading from files:                   Scheme I/O.
* readline:                             Requirements.
* redistribution:                       Copying.
* reducing the lexicon:                 Building letter to sound rules.
* regex:                                Regular expressions.
* regular expressions:                  Regular expressions.
* Relations <1>:                        Utterance structure.
* Relations:                            Writing a new module.
* remote audio:                         Audio output.
* requirements:                         Requirements.
* resampling:                           Utterance I/O.
* rescaling a waveform:                 Utterance I/O.
* reseting globals:                     Building a new voice.
* residual:                             UniSyn synthesizer.
* restrictions:                         Copying.
* resynthesis:                          Utterance I/O.
* run-time configuration:               Site initialization.
* rxp:                                  XML/SGML requirements.
* Sable:                                XML/SGML mark-up.
* SABLE DTD:                            Sable example.
* Sable tags:                           Supported Sable tags.
* Sable using:                          Using Sable.
* saving relations:                     Utterance I/O.
* saving Sable waveforms:               Using Sable.
* saving segments:                      Utterance I/O.
* saving the waveform:                  Utterance I/O.
* saving TTS waveforms:                 Using Sable.
* Scheme <1>:                           Acknowledgements.
* Scheme:                               Simple command driven session.
* Scheme heap size:                     Basic command line options.
* Scheme introduction:                  Scheme.
* Scheme programming:                   Scheme API.
* Scheme references:                    Scheme references.
* script files:                         Basic command line options.
* script programming:                   POS Example.
* scripts:                              Scheme API.
* security:                             Server/client API.
* Segment labelling:                    Labelling databases.
* selecting a phoneset:                 Phonesets.
* selection of diphones:                UniSyn synthesizer.
* selection-based synthesis:            Synthesizers in development.
* separate diphones:                    UniSyn synthesizer.
* server mode:                          Server/client API.
* server security:                      Server/client API.
* SGI:                                  Audio output.
* SGML:                                 XML/SGML mark-up.
* SGML parser:                          XML/SGML requirements.
* shell programming:                    Shell API.
* silences <1>:                         Phonesets.
* silences:                             Building a new voice.
* SIOD:                                 Acknowledgements.
* smaller system:                       Configuration.
* snack:                                Audio output.
* source:                               The source code.
* spanish voice:                        Building a new voice.
* Spoken Text Mark-up Language:         XML/SGML mark-up.
* SSML:                                 XML/SGML mark-up.
* STML:                                 XML/SGML mark-up.
* stress assignment:                    Building letter to sound rules.
* string to number:                     Scheme I/O.
* sun16:                                Audio output.
* sunaudio:                             Audio output.
* SunOS:                                Configuration.
* syllabification:                      Lookup process.
* Syllable labelling:                   Labelling databases.
* synthesis hooks:                      Utterance types.
* synthesis of natural utterances:      Utterance I/O.
* synthesizing an utterance:            Simple command driven session.
* SynthTypes:                           Utterance types.
* tagging:                              POS tagging.
* talking head:                         Utterance types.
* Target labelling:                     Labelling databases.
* TD-PSOLA:                             UniSyn synthesizer.
* text modes <1>:                       Text modes.
* text modes:                           TTS.
* text to speech:                       Simple command driven session.
* text to wave:                         Simple command driven session.
* text-to-speech mode:                  Quick start.
* text2wave:                            Simple command driven session.
* thanks:                               Acknowledgements.
* tokenizing:                           Tokenizing.
* tokens to words:                      Token to word rules.
* tools:                                Tools.
* TTS:                                  Simple command driven session.
* tts mode <1>:                         Quick start.
* tts mode:                             Basic command line options.
* TTS processes:                        Utterance structure.
* ungrouped diphones:                   UniSyn synthesizer.
* UniSyn:                               UniSyn synthesizer.
* unknown words <1>:                    Letter to sound rules.
* unknown words:                        Lexicon requirements.
* user initialization:                  Site initialization.
* using Sable:                          Using Sable.
* utterance <1>:                        Simple command driven session.
* utterance <1>:                        Utterances.
* utterance:                            Utterance structure.
* utterance chunking:                   Utterance chunking.
* utterance examples:                   Example utterance types.
* Utterance structure:                  Utterance structure.
* utterance types:                      Utterance types.
* Visual C++:                           Configuration.
* Viterbi decoder:                      Viterbi decoder.
* voices:                               Current voices.
* voxware:                              Audio output.
* wagon <1>:                            CART trees.
* wagon:                                Building models.
* waveform synthesis:                   UniSyn synthesizer.
* whitespace:                           Tokenizing.
* wild card matching:                   Regular expressions.
* Windows 95 audio:                     Audio output.
* Windows NT audio:                     Audio output.
* Windows NT/95:                        Requirements.
* Word labelling:                       Labelling databases.
* XML <1>:                              XML/SGML requirements.
* XML:                                  XML/SGML mark-up.
* Xwaves:                               Utterance I/O.
* Y2K:                                  Y2K.


