This is festival.info, produced by Makeinfo version 3.12h from
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-2001 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:

* accessing Lisp variables:              Writing a new module.
* access strategies:                     Access strategies.
* acknowledgements:                      Acknowledgements.
* addenda:                               Defining lexicons.
* adding new directories:                Writing a new module.
* adding new LISP objects:               Writing a new module.
* adding new modules:                    Writing a new module.
* adding new voices:                     Defining a new voice.
* after_analysis_hooks:                  Utterance types.
* after_synth_hooks:                     Utterance types.
* alternate diphones:                    UniSyn synthesizer.
* apostrophe s:                          Post-lexical rules.
* asynchronous synthesis:                Audio output.
* atof:                                  Scheme I/O.
* audio command:                         Audio output.
* audio command output:                  Site initialization.
* audio devices:                         Audio output.
* 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.
* auto-text-mode-alist:                  Text modes.
* backtrace:                             Scheme Festival specifics.
* batch mode:                            Basic command line options.
* BEEP lexicon <1>:                      Available lexicons.
* BEEP lexicon:                          Lookup process.
* before_synth_hooks:                    Utterance types.
* bug reports:                           Getting some help.
* 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.
* C interface:                           C only API.
* client:                                Server/client API.
* client/server protocol:                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.
* config/config:                         Configuration.
* 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.
* defSynthType:                          Utterance types.
* defUttType:                            Utterance types.
* /dev/audio:                            Audio output.
* /dev/dsp:                              Audio output.
* dictionary:                            Lexicons.
* diphone alternates:                    UniSyn synthesizer.
* diphone group files:                   UniSyn synthesizer.
* diphone index:                         UniSyn synthesizer.
* diphone_module_hooks:                  Diphone selection.
* diphone names:                         Diphone selection.
* diphone_phone_name:                    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.
* eou_tree:                              Utterance chunking.
* errors in Scheme:                      Scheme Festival specifics.
* exiting Festival:                      Simple command driven session.
* extracting features:                   Extracting features.
* F0 generation:                         Simple intonation.
* fclose:                                Scheme I/O.
* feature extraction:                    Extracting features.
* features <1>:                          Feature functions.
* features <2>:                          CART trees.
* features:                              Features.
* festival_client:                       Server/client API.
* festival_client.c:                     C only API.
* festival.el:                           Emacs interface.
* .festivalrc:                           Site initialization.
* Festival relations:                    Utterance structure.
* Festival script files:                 Basic command line options.
* file i/o in Scheme:                    Scheme I/O.
* fixed durations:                       Default durations.
* fopen:                                 Scheme I/O.
* format:                                Scheme I/O.
* formatted output:                      Scheme I/O.
* FreeBSD:                               Audio output.
* g++:                                   Requirements.
* garbage collection:                    POS Example.
* GC:                                    POS Example.
* GNU g++:                               Requirements.
* GNU readline:                          Requirements.
* grouped diphones:                      UniSyn synthesizer.
* group files <1>:                       Group files.
* group files:                           UniSyn synthesizer.
* heap size:                             Basic command line options.
* hello world:                           Simple command driven session.
* help:                                  Getting some help.
* homographs <1>:                        Homograph disambiguation.
* homographs:                            Lexical entries.
* hooks:                                 Scheme Festival specifics.
* initialization:                        Site initialization.
* Initialize:                            Utterance types.
* init.scm:                              Site initialization.
* installation initialization:           Site initialization.
* int_accent_cart_tree:                  Simple intonation.
* interactive mode:                      Basic command line options.
* IntEvent labelling:                    Labelling databases.
* intonation:                            Intonation.
* i/o in Scheme:                         Scheme I/O.
* IRIX:                                  Audio output.
* item functions:                        Accessing an utterance.
* Items:                                 Utterance structure.
* Java:                                  Java and JSAPI.
* JSAPI:                                 Java and JSAPI.
* Klatt duration rules:                  Klatt durations.
* labelling:                             Labelling databases.
* language specification:                Basic command line options.
* laryngograph:                          UniSyn synthesizer.
* letter to sound rules <1>:             Building a new voice.
* letter to sound rules <2>:             Letter to sound rules.
* letter to sound rules:                 Defining lexicons.
* lexical entries:                       Lexical entries.
* lexical stress:                        Lexical entries.
* lexicon <1>:                           Available lexicons.
* lexicon <2>:                           Lexicons.
* lexicon:                               Requirements.
* 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>:                 Linear regression.
* linear regression:                     Features.
* Linux <1>:                             Audio output.
* Linux:                                 Configuration.
* loading a waveform:                    Utterance I/O.
* loading data from files:               Scheme I/O.
* load-path:                             Site initialization.
* local duration stretch:                Duration.
* lookup hooks:                          Lookup process.
* LPC analysis:                          UniSyn synthesizer.
* LPC residual:                          UniSyn synthesizer.
* LTS:                                   Letter to sound rules.
* manual:                                Getting some help.
* 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.
* nsgmls:                                XML/SGML 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.
* parse-number:                          Scheme I/O.
* 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.
* Phones utterance:                      Example utterance types.
* phrase breaks:                         Phrase breaks.
* pitchmarking:                          UniSyn synthesizer.
* playing an utterance:                  Simple command driven session.
* POS:                                   Lexical entries.
* POS example:                           POS Example.
* possessives <1>:                       Post-lexical rules.
* possessives:                           Lexicon requirements.
* POS tagging:                           POS tagging.
* post_hooks:                            Lookup process.
* post-lexical rules:                    Post-lexical rules.
* power normalisation:                   UniSyn synthesizer.
* predicting stress:                     Building letter to sound rules.
* pre_hooks:                             Lookup process.
* pretty printing:                       Scheme I/O.
* proclaim_voice:                        Defining a new voice.
* programming:                           Programming.
* pronunciation:                         Lexical entries.
* PSOLA:                                 UniSyn synthesizer.
* punctuation:                           Tokenizing.
* quit:                                  Simple command driven session.
* 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>:                         Writing a new module.
* Relations:                             Utterance structure.
* 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.
* Sable.v0_2.dtd:                        Sable example.
* 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.
* say-minor-mode:                        Emacs interface.
* SayPhones:                             Example utterance types.
* SayText:                               Simple command driven session.
* Scheme <1>:                            Simple command driven session.
* Scheme:                                Acknowledgements.
* 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.
* SegF0 utterance:                       Example utterance types.
* Segment labelling:                     Labelling databases.
* Segments utterance:                    Example utterance types.
* selecting a phoneset:                  Phonesets.
* selection-based synthesis:             Synthesizers in development.
* selection of diphones:                 UniSyn synthesizer.
* separate diphones:                     UniSyn synthesizer.
* server/client protocol:                Server/client API.
* 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>:                          Building a new voice.
* silences:                              Phonesets.
* SIOD:                                  Acknowledgements.
* siteinit.scm:                          Site initialization.
* 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.
* texi2html:                             Requirements.
* text2wave:                             Simple command driven session.
* text modes <1>:                        Text modes.
* text modes:                            TTS.
* text to speech:                        Simple command driven session.
* text-to-speech mode:                   Quick start.
* text to wave:                          Simple command driven session.
* Text utterance:                        Example utterance types.
* thanks:                                Acknowledgements.
* tokenizing:                            Tokenizing.
* tokens to words:                       Token to word rules.
* Tokens utterance:                      Example utterance types.
* tools:                                 Tools.
* TTS:                                   Simple command driven session.
* tts mode <1>:                          Basic command line options.
* tts mode:                              Quick start.
* TTS processes:                         Utterance structure.
* ungrouped diphones:                    UniSyn synthesizer.
* UniSyn:                                UniSyn synthesizer.
* unknown words <1>:                     Lexicon requirements.
* unknown words:                         Letter to sound rules.
* unwind-protect:                        Scheme Festival specifics.
* us_diphone_init:                       UniSyn synthesizer.
* user initialization:                   Site initialization.
* using Sable:                           Using Sable.
* utterance <1>:                         Utterance structure.
* utterance <2>:                         Utterances.
* utterance:                             Simple command driven session.
* utterance chunking:                    Utterance chunking.
* utterance examples:                    Example utterance types.
* Utterance structure:                   Utterance structure.
* utterance types:                       Utterance types.
* utt.import.wave:                       Utterance I/O.
* utt.load:                              Utterance I/O.
* utt.relation functions:                Accessing an utterance.
* utt.save:                              Utterance I/O.
* utt.save.segs:                         Utterance I/O.
* utt.save.wave:                         Utterance I/O.
* utt.synth:                             Utterance types.
* Visual C++:                            Configuration.
* Viterbi decoder:                       Viterbi decoder.
* voice-path:                            Defining a new voice.
* voice_reset:                           Building a new voice.
* voices:                                Current voices.
* voxware:                               Audio output.
* wagon <1>:                             Building models.
* wagon:                                 CART trees.
* waveform synthesis:                    UniSyn synthesizer.
* Wave utterance:                        Example utterance types.
* whitespace:                            Tokenizing.
* wild card matching:                    Regular expressions.
* Windows 95 audio:                      Audio output.
* Windows NT/95:                         Requirements.
* Windows NT audio:                      Audio output.
* Word labelling:                        Labelling databases.
* Words utterance:                       Example utterance types.
* XML <1>:                               XML/SGML requirements.
* XML:                                   XML/SGML mark-up.
* Xwaves:                                Utterance I/O.
* Y2K:                                   Y2K.


